1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2022 Intel Corporation 4 */ 5 6 #include "xe_guc_log.h" 7 8 #include <linux/fault-inject.h> 9 10 #include <drm/drm_managed.h> 11 12 #include "regs/xe_guc_regs.h" 13 #include "xe_bo.h" 14 #include "xe_devcoredump.h" 15 #include "xe_force_wake.h" 16 #include "xe_gt.h" 17 #include "xe_gt_printk.h" 18 #include "xe_map.h" 19 #include "xe_mmio.h" 20 #include "xe_module.h" 21 22 static struct xe_guc * 23 log_to_guc(struct xe_guc_log *log) 24 { 25 return container_of(log, struct xe_guc, log); 26 } 27 28 static struct xe_gt * 29 log_to_gt(struct xe_guc_log *log) 30 { 31 return container_of(log, struct xe_gt, uc.guc.log); 32 } 33 34 static struct xe_device * 35 log_to_xe(struct xe_guc_log *log) 36 { 37 return gt_to_xe(log_to_gt(log)); 38 } 39 40 static size_t guc_log_size(void) 41 { 42 /* 43 * GuC Log buffer Layout 44 * 45 * +===============================+ 00B 46 * | Crash dump state header | 47 * +-------------------------------+ 32B 48 * | Debug state header | 49 * +-------------------------------+ 64B 50 * | Capture state header | 51 * +-------------------------------+ 96B 52 * | | 53 * +===============================+ PAGE_SIZE (4KB) 54 * | Crash Dump logs | 55 * +===============================+ + CRASH_SIZE 56 * | Debug logs | 57 * +===============================+ + DEBUG_SIZE 58 * | Capture logs | 59 * +===============================+ + CAPTURE_SIZE 60 */ 61 return PAGE_SIZE + CRASH_BUFFER_SIZE + DEBUG_BUFFER_SIZE + 62 CAPTURE_BUFFER_SIZE; 63 } 64 65 #define GUC_LOG_CHUNK_SIZE SZ_2M 66 67 static struct xe_guc_log_snapshot *xe_guc_log_snapshot_alloc(struct xe_guc_log *log, bool atomic) 68 { 69 struct xe_guc_log_snapshot *snapshot; 70 size_t remain; 71 int i; 72 73 snapshot = kzalloc(sizeof(*snapshot), atomic ? GFP_ATOMIC : GFP_KERNEL); 74 if (!snapshot) 75 return NULL; 76 77 /* 78 * NB: kmalloc has a hard limit well below the maximum GuC log buffer size. 79 * Also, can't use vmalloc as might be called from atomic context. So need 80 * to break the buffer up into smaller chunks that can be allocated. 81 */ 82 snapshot->size = xe_bo_size(log->bo); 83 snapshot->num_chunks = DIV_ROUND_UP(snapshot->size, GUC_LOG_CHUNK_SIZE); 84 85 snapshot->copy = kcalloc(snapshot->num_chunks, sizeof(*snapshot->copy), 86 atomic ? GFP_ATOMIC : GFP_KERNEL); 87 if (!snapshot->copy) 88 goto fail_snap; 89 90 remain = snapshot->size; 91 for (i = 0; i < snapshot->num_chunks; i++) { 92 size_t size = min(GUC_LOG_CHUNK_SIZE, remain); 93 94 snapshot->copy[i] = kmalloc(size, atomic ? GFP_ATOMIC : GFP_KERNEL); 95 if (!snapshot->copy[i]) 96 goto fail_copy; 97 remain -= size; 98 } 99 100 return snapshot; 101 102 fail_copy: 103 for (i = 0; i < snapshot->num_chunks; i++) 104 kfree(snapshot->copy[i]); 105 kfree(snapshot->copy); 106 fail_snap: 107 kfree(snapshot); 108 return NULL; 109 } 110 111 /** 112 * xe_guc_log_snapshot_free - free a previously captured GuC log snapshot 113 * @snapshot: GuC log snapshot structure 114 * 115 * Return: pointer to a newly allocated snapshot object or null if out of memory. Caller is 116 * responsible for calling xe_guc_log_snapshot_free when done with the snapshot. 117 */ 118 void xe_guc_log_snapshot_free(struct xe_guc_log_snapshot *snapshot) 119 { 120 int i; 121 122 if (!snapshot) 123 return; 124 125 if (snapshot->copy) { 126 for (i = 0; i < snapshot->num_chunks; i++) 127 kfree(snapshot->copy[i]); 128 kfree(snapshot->copy); 129 } 130 131 kfree(snapshot); 132 } 133 134 /** 135 * xe_guc_log_snapshot_capture - create a new snapshot copy the GuC log for later dumping 136 * @log: GuC log structure 137 * @atomic: is the call inside an atomic section of some kind? 138 * 139 * Return: pointer to a newly allocated snapshot object or null if out of memory. Caller is 140 * responsible for calling xe_guc_log_snapshot_free when done with the snapshot. 141 */ 142 struct xe_guc_log_snapshot *xe_guc_log_snapshot_capture(struct xe_guc_log *log, bool atomic) 143 { 144 struct xe_guc_log_snapshot *snapshot; 145 struct xe_device *xe = log_to_xe(log); 146 struct xe_guc *guc = log_to_guc(log); 147 struct xe_gt *gt = log_to_gt(log); 148 unsigned int fw_ref; 149 size_t remain; 150 int i; 151 152 if (!log->bo) 153 return NULL; 154 155 snapshot = xe_guc_log_snapshot_alloc(log, atomic); 156 if (!snapshot) 157 return NULL; 158 159 remain = snapshot->size; 160 for (i = 0; i < snapshot->num_chunks; i++) { 161 size_t size = min(GUC_LOG_CHUNK_SIZE, remain); 162 163 xe_map_memcpy_from(xe, snapshot->copy[i], &log->bo->vmap, 164 i * GUC_LOG_CHUNK_SIZE, size); 165 remain -= size; 166 } 167 168 fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FW_GT); 169 if (!fw_ref) { 170 snapshot->stamp = ~0ULL; 171 } else { 172 snapshot->stamp = xe_mmio_read64_2x32(>->mmio, GUC_PMTIMESTAMP_LO); 173 xe_force_wake_put(gt_to_fw(gt), fw_ref); 174 } 175 snapshot->ktime = ktime_get_boottime_ns(); 176 snapshot->level = log->level; 177 snapshot->ver_found = guc->fw.versions.found[XE_UC_FW_VER_RELEASE]; 178 snapshot->ver_want = guc->fw.versions.wanted; 179 snapshot->path = guc->fw.path; 180 181 return snapshot; 182 } 183 184 /** 185 * xe_guc_log_snapshot_print - dump a previously saved copy of the GuC log to some useful location 186 * @snapshot: a snapshot of the GuC log 187 * @p: the printer object to output to 188 */ 189 void xe_guc_log_snapshot_print(struct xe_guc_log_snapshot *snapshot, struct drm_printer *p) 190 { 191 size_t remain; 192 int i; 193 194 if (!snapshot) { 195 drm_printf(p, "GuC log snapshot not allocated!\n"); 196 return; 197 } 198 199 drm_printf(p, "GuC firmware: %s\n", snapshot->path); 200 drm_printf(p, "GuC version: %u.%u.%u (wanted %u.%u.%u)\n", 201 snapshot->ver_found.major, snapshot->ver_found.minor, snapshot->ver_found.patch, 202 snapshot->ver_want.major, snapshot->ver_want.minor, snapshot->ver_want.patch); 203 drm_printf(p, "Kernel timestamp: 0x%08llX [%llu]\n", snapshot->ktime, snapshot->ktime); 204 drm_printf(p, "GuC timestamp: 0x%08llX [%llu]\n", snapshot->stamp, snapshot->stamp); 205 drm_printf(p, "Log level: %u\n", snapshot->level); 206 207 drm_printf(p, "[LOG].length: 0x%zx\n", snapshot->size); 208 remain = snapshot->size; 209 for (i = 0; i < snapshot->num_chunks; i++) { 210 size_t size = min(GUC_LOG_CHUNK_SIZE, remain); 211 const char *prefix = i ? NULL : "[LOG].data"; 212 char suffix = i == snapshot->num_chunks - 1 ? '\n' : 0; 213 214 xe_print_blob_ascii85(p, prefix, suffix, snapshot->copy[i], 0, size); 215 remain -= size; 216 } 217 } 218 219 /** 220 * xe_guc_log_print_dmesg - dump a copy of the GuC log to dmesg 221 * @log: GuC log structure 222 */ 223 void xe_guc_log_print_dmesg(struct xe_guc_log *log) 224 { 225 struct xe_gt *gt = log_to_gt(log); 226 static int g_count; 227 struct drm_printer ip = xe_gt_info_printer(gt); 228 struct drm_printer lp = drm_line_printer(&ip, "Capture", ++g_count); 229 230 drm_printf(&lp, "Dumping GuC log for %ps...\n", __builtin_return_address(0)); 231 232 xe_guc_log_print(log, &lp); 233 234 drm_printf(&lp, "Done.\n"); 235 } 236 237 /** 238 * xe_guc_log_print - dump a copy of the GuC log to some useful location 239 * @log: GuC log structure 240 * @p: the printer object to output to 241 */ 242 void xe_guc_log_print(struct xe_guc_log *log, struct drm_printer *p) 243 { 244 struct xe_guc_log_snapshot *snapshot; 245 246 drm_printf(p, "**** GuC Log ****\n"); 247 248 snapshot = xe_guc_log_snapshot_capture(log, false); 249 drm_printf(p, "CS reference clock: %u\n", log_to_gt(log)->info.reference_clock); 250 xe_guc_log_snapshot_print(snapshot, p); 251 xe_guc_log_snapshot_free(snapshot); 252 } 253 254 int xe_guc_log_init(struct xe_guc_log *log) 255 { 256 struct xe_device *xe = log_to_xe(log); 257 struct xe_tile *tile = gt_to_tile(log_to_gt(log)); 258 struct xe_bo *bo; 259 260 bo = xe_managed_bo_create_pin_map(xe, tile, guc_log_size(), 261 XE_BO_FLAG_SYSTEM | 262 XE_BO_FLAG_GGTT | 263 XE_BO_FLAG_GGTT_INVALIDATE | 264 XE_BO_FLAG_PINNED_NORESTORE); 265 if (IS_ERR(bo)) 266 return PTR_ERR(bo); 267 268 xe_map_memset(xe, &bo->vmap, 0, 0, guc_log_size()); 269 log->bo = bo; 270 log->level = xe_modparam.guc_log_level; 271 272 return 0; 273 } 274 275 ALLOW_ERROR_INJECTION(xe_guc_log_init, ERRNO); /* See xe_pci_probe() */ 276 277 static u32 xe_guc_log_section_size_crash(struct xe_guc_log *log) 278 { 279 return CRASH_BUFFER_SIZE; 280 } 281 282 static u32 xe_guc_log_section_size_debug(struct xe_guc_log *log) 283 { 284 return DEBUG_BUFFER_SIZE; 285 } 286 287 /** 288 * xe_guc_log_section_size_capture - Get capture buffer size within log sections. 289 * @log: The log object. 290 * 291 * This function will return the capture buffer size within log sections. 292 * 293 * Return: capture buffer size. 294 */ 295 u32 xe_guc_log_section_size_capture(struct xe_guc_log *log) 296 { 297 return CAPTURE_BUFFER_SIZE; 298 } 299 300 /** 301 * xe_guc_get_log_buffer_size - Get log buffer size for a type. 302 * @log: The log object. 303 * @type: The log buffer type 304 * 305 * Return: buffer size. 306 */ 307 u32 xe_guc_get_log_buffer_size(struct xe_guc_log *log, enum guc_log_buffer_type type) 308 { 309 switch (type) { 310 case GUC_LOG_BUFFER_CRASH_DUMP: 311 return xe_guc_log_section_size_crash(log); 312 case GUC_LOG_BUFFER_DEBUG: 313 return xe_guc_log_section_size_debug(log); 314 case GUC_LOG_BUFFER_CAPTURE: 315 return xe_guc_log_section_size_capture(log); 316 } 317 return 0; 318 } 319 320 /** 321 * xe_guc_get_log_buffer_offset - Get offset in log buffer for a type. 322 * @log: The log object. 323 * @type: The log buffer type 324 * 325 * This function will return the offset in the log buffer for a type. 326 * Return: buffer offset. 327 */ 328 u32 xe_guc_get_log_buffer_offset(struct xe_guc_log *log, enum guc_log_buffer_type type) 329 { 330 enum guc_log_buffer_type i; 331 u32 offset = PAGE_SIZE;/* for the log_buffer_states */ 332 333 for (i = GUC_LOG_BUFFER_CRASH_DUMP; i < GUC_LOG_BUFFER_TYPE_MAX; ++i) { 334 if (i == type) 335 break; 336 offset += xe_guc_get_log_buffer_size(log, i); 337 } 338 339 return offset; 340 } 341 342 /** 343 * xe_guc_check_log_buf_overflow - Check if log buffer overflowed 344 * @log: The log object. 345 * @type: The log buffer type 346 * @full_cnt: The count of buffer full 347 * 348 * This function will check count of buffer full against previous, mismatch 349 * indicate overflowed. 350 * Update the sampled_overflow counter, if the 4 bit counter overflowed, add 351 * up 16 to correct the value. 352 * 353 * Return: True if overflowed. 354 */ 355 bool xe_guc_check_log_buf_overflow(struct xe_guc_log *log, enum guc_log_buffer_type type, 356 unsigned int full_cnt) 357 { 358 unsigned int prev_full_cnt = log->stats[type].sampled_overflow; 359 bool overflow = false; 360 361 if (full_cnt != prev_full_cnt) { 362 overflow = true; 363 364 log->stats[type].overflow = full_cnt; 365 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt; 366 367 if (full_cnt < prev_full_cnt) { 368 /* buffer_full_cnt is a 4 bit counter */ 369 log->stats[type].sampled_overflow += 16; 370 } 371 xe_gt_notice(log_to_gt(log), "log buffer overflow\n"); 372 } 373 374 return overflow; 375 } 376