933 lines · c
1// SPDX-License-Identifier: MIT2/*3 * Copyright © 2014-2019 Intel Corporation4 */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_2M19#define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE SZ_16M20#define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE SZ_1M21#elif defined(CONFIG_DRM_I915_DEBUG_GEM)22#define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE SZ_1M23#define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE SZ_2M24#define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE SZ_1M25#else26#define GUC_LOG_DEFAULT_CRASH_BUFFER_SIZE SZ_8K27#define GUC_LOG_DEFAULT_DEBUG_BUFFER_SIZE SZ_64K28#define GUC_LOG_DEFAULT_CAPTURE_BUFFER_SIZE SZ_1M29#endif30 31static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log);32 33struct guc_log_section {34 u32 max;35 u32 flag;36 u32 default_val;37 const char *name;38};39 40static 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 115static 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 123static 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 130static 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 137u32 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 144static 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 * +===============================+ 00B152 * | Debug state header |153 * +-------------------------------+ 32B154 * | Crash dump state header |155 * +-------------------------------+ 64B156 * | Capture state header |157 * +-------------------------------+ 96B158 * | |159 * +===============================+ PAGE_SIZE (4KB)160 * | Debug logs |161 * +===============================+ + DEBUG_SIZE162 * | Crash Dump logs |163 * +===============================+ + CRASH_SIZE164 * | Capture logs |165 * +===============================+ + CAPTURE_SIZE166 */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 log175 *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 from178 * i915_guc_load_status will print out firmware loading status and scratch179 * registers value.180 */181 182static 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_BUFFER187 };188 189 return intel_guc_send_nb(guc, action, ARRAY_SIZE(action), 0);190}191 192static int guc_action_flush_log(struct intel_guc *guc)193{194 u32 action[] = {195 INTEL_GUC_ACTION_FORCE_LOG_BUFFER_FLUSH,196 0197 };198 199 return intel_guc_send(guc, action, ARRAY_SIZE(action));200}201 202static 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 new219 * sub buffer, relay stays on the same sub buffer if 0 is returned.220 */221static 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 accepting228 * new data if there are no empty sub buffers left.229 * There is no strict synchronization enforced by relay between Consumer230 * and Producer. In overwrite mode, there is a possibility of getting231 * inconsistent/garbled data, the producer could be writing on to the232 * same sub buffer from which Consumer is reading. This can't be avoided233 * unless Consumer is fast enough and can always run in tandem with234 * 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 */245static 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 and255 * correspondingly have a single file exposed to User, through which256 * 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 */275static int remove_buf_file_callback(struct dentry *dentry)276{277 debugfs_remove(dentry);278 return 0;279}280 281/* relay channel callbacks */282static 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 288static 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 when292 * 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 304static 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 it308 * ourselves. NULL will be returned in no-overwrite mode, if all sub309 * buffers are full. Could have used the relay_write() to indirectly310 * copy the data, but that would have been bit convoluted, as we need to311 * write to only certain locations inside a sub buffer which cannot be312 * done without using relay_reserve() along with relay_write(). So its313 * better to use relay_reserve() alone.314 */315 return relay_reserve(log->relay.channel, 0);316}317 318bool 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 342unsigned 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 359size_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 374static 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 be399 * 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 buffer415 * (which is uncached mapped), on the stack to avoid reading416 * 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 consistency441 * set write pointer value to same value of sampled_write_ptr442 * 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 476out_unlock:477 mutex_unlock(&log->relay.lock);478}479 480static 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 488static 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 at497 * GuC Log Init time, but lets keep a ref for book-keeping498 */499 i915_gem_object_get(log->vma->obj);500 log->relay.buf_in_use = true;501 502 return 0;503}504 505static 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 513void 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 520static 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_i915(guc);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 buffer533 * but GuC log-events excludes the error-state-capture logs534 */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 sufficient539 * boot time logs and provides enough leeway to User, in terms of540 * latency, for consuming the logs from relay. Also doesn't take541 * 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 565static 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 573static 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_i915(guc);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 this583 * 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 589static 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_i915(guc);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 614int 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 to635 * data from memory during critical events such as error capture636 */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 653err:654 guc_err(guc, "Failed to allocate or map log buffer %pe\n", ERR_PTR(ret));655 return ret;656}657 658void 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 664int 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_i915(guc);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 0676 * 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 698out_unlock:699 mutex_unlock(&i915->drm.struct_mutex);700 701 return ret;702}703 704bool intel_guc_log_relay_created(const struct intel_guc_log *log)705{706 return log->buf_addr;707}708 709int 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 and725 * it should be present on the chipsets supporting GuC based726 * 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 745out_relay:746 guc_log_relay_destroy(log);747out_unlock:748 mutex_unlock(&log->relay.lock);749 750 return ret;751}752 753int 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 ignoring760 * the flush notification. This means that we need to unconditionally761 * 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 770void 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/ongoing780 * 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 no793 * possibility of race with start/flush since relay_write cannot race794 * relay_close.795 */796static 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_i915(guc);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 811void 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 822void 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 828static const char *829stringify_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 relay847 * @log: the GuC log848 * @p: the &drm_printer849 *850 * Pretty printer for GuC log info851 */852void 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 log875 * @log: the GuC log876 * @p: the &drm_printer877 * @dump_load_err: dump the log saved on GuC load error878 *879 * Pretty printer for the GuC log880 */881int 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