1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2014-2019 Intel Corporation 4 */ 5 6 #include <linux/debugfs.h> 7 #include <linux/string_helpers.h> 8 9 #include "gt/intel_gt.h" 10 #include "i915_drv.h" 11 #include "i915_irq.h" 12 #include "i915_memcpy.h" 13 #include "intel_guc_capture.h" 14 #include "intel_guc_log.h" 15 #include "intel_guc_print.h" 16 17 #if defined(CONFIG_DRM_I915_DEBUG_GUC) 18 #define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE SZ_2M 19 #define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE SZ_16M 20 #define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE SZ_1M 21 #elif defined(CONFIG_DRM_I915_DEBUG_GEM) 22 #define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE SZ_1M 23 #define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE SZ_2M 24 #define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE SZ_1M 25 #else 26 #define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE SZ_8K 27 #define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE SZ_64K 28 #define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE SZ_1M 29 #endif 30 31 static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log); 32 33 struct guc_log_section { 34 u32 max; 35 u32 flag; 36 u32 default_val; 37 const char *name; 38 }; 39 40 static void _guc_log_init_sizes(struct intel_guc_log *log) 41 { 42 struct intel_guc *guc = log_to_guc(log); 43 static const struct guc_log_section sections[GUC_LOG_SECTIONS_LIMIT] = { 44 { 45 GUC_LOG_CRASH_MASK >> GUC_LOG_CRASH_SHIFT, 46 GUC_LOG_LOG_ALLOC_UNITS, 47 GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE, 48 "crash dump" 49 }, 50 { 51 GUC_LOG_DEBUG_MASK >> GUC_LOG_DEBUG_SHIFT, 52 GUC_LOG_LOG_ALLOC_UNITS, 53 GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE, 54 "debug", 55 }, 56 { 57 GUC_LOG_CAPTURE_MASK >> GUC_LOG_CAPTURE_SHIFT, 58 GUC_LOG_CAPTURE_ALLOC_UNITS, 59 GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE, 60 "capture", 61 } 62 }; 63 int i; 64 65 for (i = 0; i < GUC_LOG_SECTIONS_LIMIT; i++) 66 log->sizes[i].bytes = sections[i].default_val; 67 68 /* If debug size > 1MB then bump default crash size to keep the same units */ 69 if (log->sizes[GUC_LOG_SECTIONS_DEBUG].bytes >= SZ_1M && 70 GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE < SZ_1M) 71 log->sizes[GUC_LOG_SECTIONS_CRASH].bytes = SZ_1M; 72 73 /* Prepare the GuC API structure fields: */ 74 for (i = 0; i < GUC_LOG_SECTIONS_LIMIT; i++) { 75 /* Convert to correct units */ 76 if ((log->sizes[i].bytes % SZ_1M) == 0) { 77 log->sizes[i].units = SZ_1M; 78 log->sizes[i].flag = sections[i].flag; 79 } else { 80 log->sizes[i].units = SZ_4K; 81 log->sizes[i].flag = 0; 82 } 83 84 if (!IS_ALIGNED(log->sizes[i].bytes, log->sizes[i].units)) 85 guc_err(guc, "Mis-aligned log %s size: 0x%X vs 0x%X!\n", 86 sections[i].name, log->sizes[i].bytes, log->sizes[i].units); 87 log->sizes[i].count = log->sizes[i].bytes / log->sizes[i].units; 88 89 if (!log->sizes[i].count) { 90 guc_err(guc, "Zero log %s size!\n", sections[i].name); 91 } else { 92 /* Size is +1 unit */ 93 log->sizes[i].count--; 94 } 95 96 /* Clip to field size */ 97 if (log->sizes[i].count > sections[i].max) { 98 guc_err(guc, "log %s size too large: %d vs %d!\n", 99 sections[i].name, log->sizes[i].count + 1, sections[i].max + 1); 100 log->sizes[i].count = sections[i].max; 101 } 102 } 103 104 if (log->sizes[GUC_LOG_SECTIONS_CRASH].units != log->sizes[GUC_LOG_SECTIONS_DEBUG].units) { 105 guc_err(guc, "Unit mismatch for crash and debug sections: %d vs %d!\n", 106 log->sizes[GUC_LOG_SECTIONS_CRASH].units, 107 log->sizes[GUC_LOG_SECTIONS_DEBUG].units); 108 log->sizes[GUC_LOG_SECTIONS_CRASH].units = log->sizes[GUC_LOG_SECTIONS_DEBUG].units; 109 log->sizes[GUC_LOG_SECTIONS_CRASH].count = 0; 110 } 111 112 log->sizes_initialised = true; 113 } 114 115 static void guc_log_init_sizes(struct intel_guc_log *log) 116 { 117 if (log->sizes_initialised) 118 return; 119 120 _guc_log_init_sizes(log); 121 } 122 123 static u32 intel_guc_log_section_size_crash(struct intel_guc_log *log) 124 { 125 guc_log_init_sizes(log); 126 127 return log->sizes[GUC_LOG_SECTIONS_CRASH].bytes; 128 } 129 130 static u32 intel_guc_log_section_size_debug(struct intel_guc_log *log) 131 { 132 guc_log_init_sizes(log); 133 134 return log->sizes[GUC_LOG_SECTIONS_DEBUG].bytes; 135 } 136 137 u32 intel_guc_log_section_size_capture(struct intel_guc_log *log) 138 { 139 guc_log_init_sizes(log); 140 141 return log->sizes[GUC_LOG_SECTIONS_CAPTURE].bytes; 142 } 143 144 static u32 intel_guc_log_size(struct intel_guc_log *log) 145 { 146 /* 147 * GuC Log buffer Layout: 148 * 149 * NB: Ordering must follow "enum guc_log_buffer_type". 150 * 151 * +===============================+ 00B 152 * | Debug state header | 153 * +-------------------------------+ 32B 154 * | Crash dump state header | 155 * +-------------------------------+ 64B 156 * | Capture state header | 157 * +-------------------------------+ 96B 158 * | | 159 * +===============================+ PAGE_SIZE (4KB) 160 * | Debug logs | 161 * +===============================+ + DEBUG_SIZE 162 * | Crash Dump logs | 163 * +===============================+ + CRASH_SIZE 164 * | Capture logs | 165 * +===============================+ + CAPTURE_SIZE 166 */ 167 return PAGE_SIZE + 168 intel_guc_log_section_size_crash(log) + 169 intel_guc_log_section_size_debug(log) + 170 intel_guc_log_section_size_capture(log); 171 } 172 173 /** 174 * DOC: GuC firmware log 175 * 176 * Firmware log is enabled by setting i915.guc_log_level to the positive level. 177 * Log data is printed out via reading debugfs i915_guc_log_dump. Reading from 178 * i915_guc_load_status will print out firmware loading status and scratch 179 * registers value. 180 */ 181 182 static int guc_action_flush_log_complete(struct intel_guc *guc) 183 { 184 u32 action[] = { 185 INTEL_GUC_ACTION_LOG_BUFFER_FILE_FLUSH_COMPLETE, 186 GUC_DEBUG_LOG_BUFFER 187 }; 188 189 return intel_guc_send_nb(guc, action, ARRAY_SIZE(action), 0); 190 } 191 192 static int guc_action_flush_log(struct intel_guc *guc) 193 { 194 u32 action[] = { 195 INTEL_GUC_ACTION_FORCE_LOG_BUFFER_FLUSH, 196 0 197 }; 198 199 return intel_guc_send(guc, action, ARRAY_SIZE(action)); 200 } 201 202 static int guc_action_control_log(struct intel_guc *guc, bool enable, 203 bool default_logging, u32 verbosity) 204 { 205 u32 action[] = { 206 INTEL_GUC_ACTION_UK_LOG_ENABLE_LOGGING, 207 (enable ? GUC_LOG_CONTROL_LOGGING_ENABLED : 0) | 208 (verbosity << GUC_LOG_CONTROL_VERBOSITY_SHIFT) | 209 (default_logging ? GUC_LOG_CONTROL_DEFAULT_LOGGING : 0) 210 }; 211 212 GEM_BUG_ON(verbosity > GUC_LOG_VERBOSITY_MAX); 213 214 return intel_guc_send(guc, action, ARRAY_SIZE(action)); 215 } 216 217 /* 218 * Sub buffer switch callback. Called whenever relay has to switch to a new 219 * sub buffer, relay stays on the same sub buffer if 0 is returned. 220 */ 221 static int subbuf_start_callback(struct rchan_buf *buf, 222 void *subbuf, 223 void *prev_subbuf, 224 size_t prev_padding) 225 { 226 /* 227 * Use no-overwrite mode by default, where relay will stop accepting 228 * new data if there are no empty sub buffers left. 229 * There is no strict synchronization enforced by relay between Consumer 230 * and Producer. In overwrite mode, there is a possibility of getting 231 * inconsistent/garbled data, the producer could be writing on to the 232 * same sub buffer from which Consumer is reading. This can't be avoided 233 * unless Consumer is fast enough and can always run in tandem with 234 * Producer. 235 */ 236 if (relay_buf_full(buf)) 237 return 0; 238 239 return 1; 240 } 241 242 /* 243 * file_create() callback. Creates relay file in debugfs. 244 */ 245 static struct dentry *create_buf_file_callback(const char *filename, 246 struct dentry *parent, 247 umode_t mode, 248 struct rchan_buf *buf, 249 int *is_global) 250 { 251 struct dentry *buf_file; 252 253 /* 254 * This to enable the use of a single buffer for the relay channel and 255 * correspondingly have a single file exposed to User, through which 256 * it can collect the logs in order without any post-processing. 257 * Need to set 'is_global' even if parent is NULL for early logging. 258 */ 259 *is_global = 1; 260 261 if (!parent) 262 return NULL; 263 264 buf_file = debugfs_create_file(filename, mode, 265 parent, buf, &relay_file_operations); 266 if (IS_ERR(buf_file)) 267 return NULL; 268 269 return buf_file; 270 } 271 272 /* 273 * file_remove() default callback. Removes relay file in debugfs. 274 */ 275 static int remove_buf_file_callback(struct dentry *dentry) 276 { 277 debugfs_remove(dentry); 278 return 0; 279 } 280 281 /* relay channel callbacks */ 282 static const struct rchan_callbacks relay_callbacks = { 283 .subbuf_start = subbuf_start_callback, 284 .create_buf_file = create_buf_file_callback, 285 .remove_buf_file = remove_buf_file_callback, 286 }; 287 288 static void guc_move_to_next_buf(struct intel_guc_log *log) 289 { 290 /* 291 * Make sure the updates made in the sub buffer are visible when 292 * Consumer sees the following update to offset inside the sub buffer. 293 */ 294 smp_wmb(); 295 296 /* All data has been written, so now move the offset of sub buffer. */ 297 relay_reserve(log->relay.channel, log->vma->obj->base.size - 298 intel_guc_log_section_size_capture(log)); 299 300 /* Switch to the next sub buffer */ 301 relay_flush(log->relay.channel); 302 } 303 304 static void *guc_get_write_buffer(struct intel_guc_log *log) 305 { 306 /* 307 * Just get the base address of a new sub buffer and copy data into it 308 * ourselves. NULL will be returned in no-overwrite mode, if all sub 309 * buffers are full. Could have used the relay_write() to indirectly 310 * copy the data, but that would have been bit convoluted, as we need to 311 * write to only certain locations inside a sub buffer which cannot be 312 * done without using relay_reserve() along with relay_write(). So its 313 * better to use relay_reserve() alone. 314 */ 315 return relay_reserve(log->relay.channel, 0); 316 } 317 318 bool intel_guc_check_log_buf_overflow(struct intel_guc_log *log, 319 enum guc_log_buffer_type type, 320 unsigned int full_cnt) 321 { 322 unsigned int prev_full_cnt = log->stats[type].sampled_overflow; 323 bool overflow = false; 324 325 if (full_cnt != prev_full_cnt) { 326 overflow = true; 327 328 log->stats[type].overflow = full_cnt; 329 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt; 330 331 if (full_cnt < prev_full_cnt) { 332 /* buffer_full_cnt is a 4 bit counter */ 333 log->stats[type].sampled_overflow += 16; 334 } 335 336 guc_notice_ratelimited(log_to_guc(log), "log buffer overflow\n"); 337 } 338 339 return overflow; 340 } 341 342 unsigned int intel_guc_get_log_buffer_size(struct intel_guc_log *log, 343 enum guc_log_buffer_type type) 344 { 345 switch (type) { 346 case GUC_DEBUG_LOG_BUFFER: 347 return intel_guc_log_section_size_debug(log); 348 case GUC_CRASH_DUMP_LOG_BUFFER: 349 return intel_guc_log_section_size_crash(log); 350 case GUC_CAPTURE_LOG_BUFFER: 351 return intel_guc_log_section_size_capture(log); 352 default: 353 MISSING_CASE(type); 354 } 355 356 return 0; 357 } 358 359 size_t intel_guc_get_log_buffer_offset(struct intel_guc_log *log, 360 enum guc_log_buffer_type type) 361 { 362 enum guc_log_buffer_type i; 363 size_t offset = PAGE_SIZE;/* for the log_buffer_states */ 364 365 for (i = GUC_DEBUG_LOG_BUFFER; i < GUC_MAX_LOG_BUFFER; ++i) { 366 if (i == type) 367 break; 368 offset += intel_guc_get_log_buffer_size(log, i); 369 } 370 371 return offset; 372 } 373 374 static void _guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log) 375 { 376 struct intel_guc *guc = log_to_guc(log); 377 unsigned int buffer_size, read_offset, write_offset, bytes_to_copy, full_cnt; 378 struct guc_log_buffer_state *log_buf_state, *log_buf_snapshot_state; 379 struct guc_log_buffer_state log_buf_state_local; 380 enum guc_log_buffer_type type; 381 void *src_data, *dst_data; 382 bool new_overflow; 383 384 mutex_lock(&log->relay.lock); 385 386 if (guc_WARN_ON(guc, !intel_guc_log_relay_created(log))) 387 goto out_unlock; 388 389 /* Get the pointer to shared GuC log buffer */ 390 src_data = log->buf_addr; 391 log_buf_state = src_data; 392 393 /* Get the pointer to local buffer to store the logs */ 394 log_buf_snapshot_state = dst_data = guc_get_write_buffer(log); 395 396 if (unlikely(!log_buf_snapshot_state)) { 397 /* 398 * Used rate limited to avoid deluge of messages, logs might be 399 * getting consumed by User at a slow rate. 400 */ 401 guc_err_ratelimited(guc, "no sub-buffer to copy general logs\n"); 402 log->relay.full_count++; 403 404 goto out_unlock; 405 } 406 407 /* Actual logs are present from the 2nd page */ 408 src_data += PAGE_SIZE; 409 dst_data += PAGE_SIZE; 410 411 /* For relay logging, we exclude error state capture */ 412 for (type = GUC_DEBUG_LOG_BUFFER; type <= GUC_CRASH_DUMP_LOG_BUFFER; type++) { 413 /* 414 * Make a copy of the state structure, inside GuC log buffer 415 * (which is uncached mapped), on the stack to avoid reading 416 * from it multiple times. 417 */ 418 memcpy(&log_buf_state_local, log_buf_state, 419 sizeof(struct guc_log_buffer_state)); 420 buffer_size = intel_guc_get_log_buffer_size(log, type); 421 read_offset = log_buf_state_local.read_ptr; 422 write_offset = log_buf_state_local.sampled_write_ptr; 423 full_cnt = log_buf_state_local.buffer_full_cnt; 424 425 /* Bookkeeping stuff */ 426 log->stats[type].flush += log_buf_state_local.flush_to_file; 427 new_overflow = intel_guc_check_log_buf_overflow(log, type, full_cnt); 428 429 /* Update the state of shared log buffer */ 430 log_buf_state->read_ptr = write_offset; 431 log_buf_state->flush_to_file = 0; 432 log_buf_state++; 433 434 /* First copy the state structure in snapshot buffer */ 435 memcpy(log_buf_snapshot_state, &log_buf_state_local, 436 sizeof(struct guc_log_buffer_state)); 437 438 /* 439 * The write pointer could have been updated by GuC firmware, 440 * after sending the flush interrupt to Host, for consistency 441 * set write pointer value to same value of sampled_write_ptr 442 * in the snapshot buffer. 443 */ 444 log_buf_snapshot_state->write_ptr = write_offset; 445 log_buf_snapshot_state++; 446 447 /* Now copy the actual logs. */ 448 if (unlikely(new_overflow)) { 449 /* copy the whole buffer in case of overflow */ 450 read_offset = 0; 451 write_offset = buffer_size; 452 } else if (unlikely((read_offset > buffer_size) || 453 (write_offset > buffer_size))) { 454 guc_err(guc, "invalid log buffer state\n"); 455 /* copy whole buffer as offsets are unreliable */ 456 read_offset = 0; 457 write_offset = buffer_size; 458 } 459 460 /* Just copy the newly written data */ 461 if (read_offset > write_offset) { 462 i915_memcpy_from_wc(dst_data, src_data, write_offset); 463 bytes_to_copy = buffer_size - read_offset; 464 } else { 465 bytes_to_copy = write_offset - read_offset; 466 } 467 i915_memcpy_from_wc(dst_data + read_offset, 468 src_data + read_offset, bytes_to_copy); 469 470 src_data += buffer_size; 471 dst_data += buffer_size; 472 } 473 474 guc_move_to_next_buf(log); 475 476 out_unlock: 477 mutex_unlock(&log->relay.lock); 478 } 479 480 static void copy_debug_logs_work(struct work_struct *work) 481 { 482 struct intel_guc_log *log = 483 container_of(work, struct intel_guc_log, relay.flush_work); 484 485 guc_log_copy_debuglogs_for_relay(log); 486 } 487 488 static int guc_log_relay_map(struct intel_guc_log *log) 489 { 490 lockdep_assert_held(&log->relay.lock); 491 492 if (!log->vma || !log->buf_addr) 493 return -ENODEV; 494 495 /* 496 * WC vmalloc mapping of log buffer pages was done at 497 * GuC Log Init time, but lets keep a ref for book-keeping 498 */ 499 i915_gem_object_get(log->vma->obj); 500 log->relay.buf_in_use = true; 501 502 return 0; 503 } 504 505 static void guc_log_relay_unmap(struct intel_guc_log *log) 506 { 507 lockdep_assert_held(&log->relay.lock); 508 509 i915_gem_object_put(log->vma->obj); 510 log->relay.buf_in_use = false; 511 } 512 513 void intel_guc_log_init_early(struct intel_guc_log *log) 514 { 515 mutex_init(&log->relay.lock); 516 INIT_WORK(&log->relay.flush_work, copy_debug_logs_work); 517 log->relay.started = false; 518 } 519 520 static int guc_log_relay_create(struct intel_guc_log *log) 521 { 522 struct intel_guc *guc = log_to_guc(log); 523 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 524 struct rchan *guc_log_relay_chan; 525 size_t n_subbufs, subbuf_size; 526 int ret; 527 528 lockdep_assert_held(&log->relay.lock); 529 GEM_BUG_ON(!log->vma); 530 531 /* 532 * Keep the size of sub buffers same as shared log buffer 533 * but GuC log-events excludes the error-state-capture logs 534 */ 535 subbuf_size = log->vma->size - intel_guc_log_section_size_capture(log); 536 537 /* 538 * Store up to 8 snapshots, which is large enough to buffer sufficient 539 * boot time logs and provides enough leeway to User, in terms of 540 * latency, for consuming the logs from relay. Also doesn't take 541 * up too much memory. 542 */ 543 n_subbufs = 8; 544 545 if (!guc->dbgfs_node) 546 return -ENOENT; 547 548 guc_log_relay_chan = relay_open("guc_log", 549 guc->dbgfs_node, 550 subbuf_size, n_subbufs, 551 &relay_callbacks, i915); 552 if (!guc_log_relay_chan) { 553 guc_err(guc, "Couldn't create relay channel for logging\n"); 554 555 ret = -ENOMEM; 556 return ret; 557 } 558 559 GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size); 560 log->relay.channel = guc_log_relay_chan; 561 562 return 0; 563 } 564 565 static void guc_log_relay_destroy(struct intel_guc_log *log) 566 { 567 lockdep_assert_held(&log->relay.lock); 568 569 relay_close(log->relay.channel); 570 log->relay.channel = NULL; 571 } 572 573 static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log) 574 { 575 struct intel_guc *guc = log_to_guc(log); 576 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 577 intel_wakeref_t wakeref; 578 579 _guc_log_copy_debuglogs_for_relay(log); 580 581 /* 582 * Generally device is expected to be active only at this 583 * time, so get/put should be really quick. 584 */ 585 with_intel_runtime_pm(&i915->runtime_pm, wakeref) 586 guc_action_flush_log_complete(guc); 587 } 588 589 static u32 __get_default_log_level(struct intel_guc_log *log) 590 { 591 struct intel_guc *guc = log_to_guc(log); 592 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 593 594 /* A negative value means "use platform/config default" */ 595 if (i915->params.guc_log_level < 0) { 596 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) || 597 IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ? 598 GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_NON_VERBOSE; 599 } 600 601 if (i915->params.guc_log_level > GUC_LOG_LEVEL_MAX) { 602 guc_warn(guc, "Log verbosity param out of range: %d > %d!\n", 603 i915->params.guc_log_level, GUC_LOG_LEVEL_MAX); 604 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) || 605 IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ? 606 GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_DISABLED; 607 } 608 609 GEM_BUG_ON(i915->params.guc_log_level < GUC_LOG_LEVEL_DISABLED); 610 GEM_BUG_ON(i915->params.guc_log_level > GUC_LOG_LEVEL_MAX); 611 return i915->params.guc_log_level; 612 } 613 614 int intel_guc_log_create(struct intel_guc_log *log) 615 { 616 struct intel_guc *guc = log_to_guc(log); 617 struct i915_vma *vma; 618 void *vaddr; 619 u32 guc_log_size; 620 int ret; 621 622 GEM_BUG_ON(log->vma); 623 624 guc_log_size = intel_guc_log_size(log); 625 626 vma = intel_guc_allocate_vma(guc, guc_log_size); 627 if (IS_ERR(vma)) { 628 ret = PTR_ERR(vma); 629 goto err; 630 } 631 632 log->vma = vma; 633 /* 634 * Create a WC (Uncached for read) vmalloc mapping up front immediate access to 635 * data from memory during critical events such as error capture 636 */ 637 vaddr = i915_gem_object_pin_map_unlocked(log->vma->obj, I915_MAP_WC); 638 if (IS_ERR(vaddr)) { 639 ret = PTR_ERR(vaddr); 640 i915_vma_unpin_and_release(&log->vma, 0); 641 goto err; 642 } 643 log->buf_addr = vaddr; 644 645 log->level = __get_default_log_level(log); 646 guc_dbg(guc, "guc_log_level=%d (%s, verbose:%s, verbosity:%d)\n", 647 log->level, str_enabled_disabled(log->level), 648 str_yes_no(GUC_LOG_LEVEL_IS_VERBOSE(log->level)), 649 GUC_LOG_LEVEL_TO_VERBOSITY(log->level)); 650 651 return 0; 652 653 err: 654 guc_err(guc, "Failed to allocate or map log buffer %pe\n", ERR_PTR(ret)); 655 return ret; 656 } 657 658 void intel_guc_log_destroy(struct intel_guc_log *log) 659 { 660 log->buf_addr = NULL; 661 i915_vma_unpin_and_release(&log->vma, I915_VMA_RELEASE_MAP); 662 } 663 664 int intel_guc_log_set_level(struct intel_guc_log *log, u32 level) 665 { 666 struct intel_guc *guc = log_to_guc(log); 667 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 668 intel_wakeref_t wakeref; 669 int ret = 0; 670 671 BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0); 672 GEM_BUG_ON(!log->vma); 673 674 /* 675 * GuC is recognizing log levels starting from 0 to max, we're using 0 676 * as indication that logging should be disabled. 677 */ 678 if (level < GUC_LOG_LEVEL_DISABLED || level > GUC_LOG_LEVEL_MAX) 679 return -EINVAL; 680 681 mutex_lock(&i915->drm.struct_mutex); 682 683 if (log->level == level) 684 goto out_unlock; 685 686 with_intel_runtime_pm(&i915->runtime_pm, wakeref) 687 ret = guc_action_control_log(guc, 688 GUC_LOG_LEVEL_IS_VERBOSE(level), 689 GUC_LOG_LEVEL_IS_ENABLED(level), 690 GUC_LOG_LEVEL_TO_VERBOSITY(level)); 691 if (ret) { 692 guc_dbg(guc, "guc_log_control action failed %pe\n", ERR_PTR(ret)); 693 goto out_unlock; 694 } 695 696 log->level = level; 697 698 out_unlock: 699 mutex_unlock(&i915->drm.struct_mutex); 700 701 return ret; 702 } 703 704 bool intel_guc_log_relay_created(const struct intel_guc_log *log) 705 { 706 return log->buf_addr; 707 } 708 709 int intel_guc_log_relay_open(struct intel_guc_log *log) 710 { 711 int ret; 712 713 if (!log->vma) 714 return -ENODEV; 715 716 mutex_lock(&log->relay.lock); 717 718 if (intel_guc_log_relay_created(log)) { 719 ret = -EEXIST; 720 goto out_unlock; 721 } 722 723 /* 724 * We require SSE 4.1 for fast reads from the GuC log buffer and 725 * it should be present on the chipsets supporting GuC based 726 * submissions. 727 */ 728 if (!i915_has_memcpy_from_wc()) { 729 ret = -ENXIO; 730 goto out_unlock; 731 } 732 733 ret = guc_log_relay_create(log); 734 if (ret) 735 goto out_unlock; 736 737 ret = guc_log_relay_map(log); 738 if (ret) 739 goto out_relay; 740 741 mutex_unlock(&log->relay.lock); 742 743 return 0; 744 745 out_relay: 746 guc_log_relay_destroy(log); 747 out_unlock: 748 mutex_unlock(&log->relay.lock); 749 750 return ret; 751 } 752 753 int intel_guc_log_relay_start(struct intel_guc_log *log) 754 { 755 if (log->relay.started) 756 return -EEXIST; 757 758 /* 759 * When GuC is logging without us relaying to userspace, we're ignoring 760 * the flush notification. This means that we need to unconditionally 761 * flush on relay enabling, since GuC only notifies us once. 762 */ 763 queue_work(system_highpri_wq, &log->relay.flush_work); 764 765 log->relay.started = true; 766 767 return 0; 768 } 769 770 void intel_guc_log_relay_flush(struct intel_guc_log *log) 771 { 772 struct intel_guc *guc = log_to_guc(log); 773 intel_wakeref_t wakeref; 774 775 if (!log->relay.started) 776 return; 777 778 /* 779 * Before initiating the forceful flush, wait for any pending/ongoing 780 * flush to complete otherwise forceful flush may not actually happen. 781 */ 782 flush_work(&log->relay.flush_work); 783 784 with_intel_runtime_pm(guc_to_gt(guc)->uncore->rpm, wakeref) 785 guc_action_flush_log(guc); 786 787 /* GuC would have updated log buffer by now, so copy it */ 788 guc_log_copy_debuglogs_for_relay(log); 789 } 790 791 /* 792 * Stops the relay log. Called from intel_guc_log_relay_close(), so no 793 * possibility of race with start/flush since relay_write cannot race 794 * relay_close. 795 */ 796 static void guc_log_relay_stop(struct intel_guc_log *log) 797 { 798 struct intel_guc *guc = log_to_guc(log); 799 struct drm_i915_private *i915 = guc_to_gt(guc)->i915; 800 801 if (!log->relay.started) 802 return; 803 804 intel_synchronize_irq(i915); 805 806 flush_work(&log->relay.flush_work); 807 808 log->relay.started = false; 809 } 810 811 void intel_guc_log_relay_close(struct intel_guc_log *log) 812 { 813 guc_log_relay_stop(log); 814 815 mutex_lock(&log->relay.lock); 816 GEM_BUG_ON(!intel_guc_log_relay_created(log)); 817 guc_log_relay_unmap(log); 818 guc_log_relay_destroy(log); 819 mutex_unlock(&log->relay.lock); 820 } 821 822 void intel_guc_log_handle_flush_event(struct intel_guc_log *log) 823 { 824 if (log->relay.started) 825 queue_work(system_highpri_wq, &log->relay.flush_work); 826 } 827 828 static const char * 829 stringify_guc_log_type(enum guc_log_buffer_type type) 830 { 831 switch (type) { 832 case GUC_DEBUG_LOG_BUFFER: 833 return "DEBUG"; 834 case GUC_CRASH_DUMP_LOG_BUFFER: 835 return "CRASH"; 836 case GUC_CAPTURE_LOG_BUFFER: 837 return "CAPTURE"; 838 default: 839 MISSING_CASE(type); 840 } 841 842 return ""; 843 } 844 845 /** 846 * intel_guc_log_info - dump information about GuC log relay 847 * @log: the GuC log 848 * @p: the &drm_printer 849 * 850 * Pretty printer for GuC log info 851 */ 852 void intel_guc_log_info(struct intel_guc_log *log, struct drm_printer *p) 853 { 854 enum guc_log_buffer_type type; 855 856 if (!intel_guc_log_relay_created(log)) { 857 drm_puts(p, "GuC log relay not created\n"); 858 return; 859 } 860 861 drm_puts(p, "GuC logging stats:\n"); 862 863 drm_printf(p, "\tRelay full count: %u\n", log->relay.full_count); 864 865 for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) { 866 drm_printf(p, "\t%s:\tflush count %10u, overflow count %10u\n", 867 stringify_guc_log_type(type), 868 log->stats[type].flush, 869 log->stats[type].sampled_overflow); 870 } 871 } 872 873 /** 874 * intel_guc_log_dump - dump the contents of the GuC log 875 * @log: the GuC log 876 * @p: the &drm_printer 877 * @dump_load_err: dump the log saved on GuC load error 878 * 879 * Pretty printer for the GuC log 880 */ 881 int intel_guc_log_dump(struct intel_guc_log *log, struct drm_printer *p, 882 bool dump_load_err) 883 { 884 struct intel_guc *guc = log_to_guc(log); 885 struct intel_uc *uc = container_of(guc, struct intel_uc, guc); 886 struct drm_i915_gem_object *obj = NULL; 887 void *map; 888 u32 *page; 889 int i, j; 890 891 if (!intel_guc_is_supported(guc)) 892 return -ENODEV; 893 894 if (dump_load_err) 895 obj = uc->load_err_log; 896 else if (guc->log.vma) 897 obj = guc->log.vma->obj; 898 899 if (!obj) 900 return 0; 901 902 page = (u32 *)__get_free_page(GFP_KERNEL); 903 if (!page) 904 return -ENOMEM; 905 906 intel_guc_dump_time_info(guc, p); 907 908 map = i915_gem_object_pin_map_unlocked(obj, I915_MAP_WC); 909 if (IS_ERR(map)) { 910 guc_dbg(guc, "Failed to pin log object: %pe\n", map); 911 drm_puts(p, "(log data unaccessible)\n"); 912 free_page((unsigned long)page); 913 return PTR_ERR(map); 914 } 915 916 for (i = 0; i < obj->base.size; i += PAGE_SIZE) { 917 if (!i915_memcpy_from_wc(page, map + i, PAGE_SIZE)) 918 memcpy(page, map + i, PAGE_SIZE); 919 920 for (j = 0; j < PAGE_SIZE / sizeof(u32); j += 4) 921 drm_printf(p, "0x%08x 0x%08x 0x%08x 0x%08x\n", 922 *(page + j + 0), *(page + j + 1), 923 *(page + j + 2), *(page + j + 3)); 924 } 925 926 drm_puts(p, "\n"); 927 928 i915_gem_object_unpin_map(obj); 929 free_page((unsigned long)page); 930 931 return 0; 932 } 933