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 = log->bo->size; 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 if (IS_ERR(bo)) 265 return PTR_ERR(bo); 266 267 xe_map_memset(xe, &bo->vmap, 0, 0, guc_log_size()); 268 log->bo = bo; 269 log->level = xe_modparam.guc_log_level; 270 271 return 0; 272 } 273 274 ALLOW_ERROR_INJECTION(xe_guc_log_init, ERRNO); /* See xe_pci_probe() */ 275 276 static u32 xe_guc_log_section_size_crash(struct xe_guc_log *log) 277 { 278 return CRASH_BUFFER_SIZE; 279 } 280 281 static u32 xe_guc_log_section_size_debug(struct xe_guc_log *log) 282 { 283 return DEBUG_BUFFER_SIZE; 284 } 285 286 /** 287 * xe_guc_log_section_size_capture - Get capture buffer size within log sections. 288 * @log: The log object. 289 * 290 * This function will return the capture buffer size within log sections. 291 * 292 * Return: capture buffer size. 293 */ 294 u32 xe_guc_log_section_size_capture(struct xe_guc_log *log) 295 { 296 return CAPTURE_BUFFER_SIZE; 297 } 298 299 /** 300 * xe_guc_get_log_buffer_size - Get log buffer size for a type. 301 * @log: The log object. 302 * @type: The log buffer type 303 * 304 * Return: buffer size. 305 */ 306 u32 xe_guc_get_log_buffer_size(struct xe_guc_log *log, enum guc_log_buffer_type type) 307 { 308 switch (type) { 309 case GUC_LOG_BUFFER_CRASH_DUMP: 310 return xe_guc_log_section_size_crash(log); 311 case GUC_LOG_BUFFER_DEBUG: 312 return xe_guc_log_section_size_debug(log); 313 case GUC_LOG_BUFFER_CAPTURE: 314 return xe_guc_log_section_size_capture(log); 315 } 316 return 0; 317 } 318 319 /** 320 * xe_guc_get_log_buffer_offset - Get offset in log buffer for a type. 321 * @log: The log object. 322 * @type: The log buffer type 323 * 324 * This function will return the offset in the log buffer for a type. 325 * Return: buffer offset. 326 */ 327 u32 xe_guc_get_log_buffer_offset(struct xe_guc_log *log, enum guc_log_buffer_type type) 328 { 329 enum guc_log_buffer_type i; 330 u32 offset = PAGE_SIZE;/* for the log_buffer_states */ 331 332 for (i = GUC_LOG_BUFFER_CRASH_DUMP; i < GUC_LOG_BUFFER_TYPE_MAX; ++i) { 333 if (i == type) 334 break; 335 offset += xe_guc_get_log_buffer_size(log, i); 336 } 337 338 return offset; 339 } 340 341 /** 342 * xe_guc_check_log_buf_overflow - Check if log buffer overflowed 343 * @log: The log object. 344 * @type: The log buffer type 345 * @full_cnt: The count of buffer full 346 * 347 * This function will check count of buffer full against previous, mismatch 348 * indicate overflowed. 349 * Update the sampled_overflow counter, if the 4 bit counter overflowed, add 350 * up 16 to correct the value. 351 * 352 * Return: True if overflowed. 353 */ 354 bool xe_guc_check_log_buf_overflow(struct xe_guc_log *log, enum guc_log_buffer_type type, 355 unsigned int full_cnt) 356 { 357 unsigned int prev_full_cnt = log->stats[type].sampled_overflow; 358 bool overflow = false; 359 360 if (full_cnt != prev_full_cnt) { 361 overflow = true; 362 363 log->stats[type].overflow = full_cnt; 364 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt; 365 366 if (full_cnt < prev_full_cnt) { 367 /* buffer_full_cnt is a 4 bit counter */ 368 log->stats[type].sampled_overflow += 16; 369 } 370 xe_gt_notice(log_to_gt(log), "log buffer overflow\n"); 371 } 372 373 return overflow; 374 } 375