Lines Matching refs:log
31 static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log);
40 static void _guc_log_init_sizes(struct intel_guc_log *log)
42 struct intel_guc *guc = log_to_guc(log);
66 log->sizes[i].bytes = sections[i].default_val;
69 if (log->sizes[GUC_LOG_SECTIONS_DEBUG].bytes >= SZ_1M &&
71 log->sizes[GUC_LOG_SECTIONS_CRASH].bytes = SZ_1M;
76 if ((log->sizes[i].bytes % SZ_1M) == 0) {
77 log->sizes[i].units = SZ_1M;
78 log->sizes[i].flag = sections[i].flag;
80 log->sizes[i].units = SZ_4K;
81 log->sizes[i].flag = 0;
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;
89 if (!log->sizes[i].count) {
90 guc_err(guc, "Zero log %s size!\n", sections[i].name);
93 log->sizes[i].count--;
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;
104 if (log->sizes[GUC_LOG_SECTIONS_CRASH].units != log->sizes[GUC_LOG_SECTIONS_DEBUG].units) {
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;
112 log->sizes_initialised = true;
115 static void guc_log_init_sizes(struct intel_guc_log *log)
117 if (log->sizes_initialised)
120 _guc_log_init_sizes(log);
123 static u32 intel_guc_log_section_size_crash(struct intel_guc_log *log)
125 guc_log_init_sizes(log);
127 return log->sizes[GUC_LOG_SECTIONS_CRASH].bytes;
130 static u32 intel_guc_log_section_size_debug(struct intel_guc_log *log)
132 guc_log_init_sizes(log);
134 return log->sizes[GUC_LOG_SECTIONS_DEBUG].bytes;
137 u32 intel_guc_log_section_size_capture(struct intel_guc_log *log)
139 guc_log_init_sizes(log);
141 return log->sizes[GUC_LOG_SECTIONS_CAPTURE].bytes;
144 static u32 intel_guc_log_size(struct intel_guc_log *log)
168 intel_guc_log_section_size_crash(log) +
169 intel_guc_log_section_size_debug(log) +
170 intel_guc_log_section_size_capture(log);
174 * DOC: GuC firmware log
176 * Firmware log is enabled by setting i915.guc_log_level to the positive level.
288 static void guc_move_to_next_buf(struct intel_guc_log *log)
297 relay_reserve(log->relay.channel, log->vma->obj->base.size -
298 intel_guc_log_section_size_capture(log));
301 relay_flush(log->relay.channel);
304 static void *guc_get_write_buffer(struct intel_guc_log *log)
315 return relay_reserve(log->relay.channel, 0);
318 bool intel_guc_check_log_buf_overflow(struct intel_guc_log *log,
322 unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
328 log->stats[type].overflow = full_cnt;
329 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
333 log->stats[type].sampled_overflow += 16;
336 guc_notice_ratelimited(log_to_guc(log), "log buffer overflow\n");
342 unsigned int intel_guc_get_log_buffer_size(struct intel_guc_log *log,
347 return intel_guc_log_section_size_debug(log);
349 return intel_guc_log_section_size_crash(log);
351 return intel_guc_log_section_size_capture(log);
359 size_t intel_guc_get_log_buffer_offset(struct intel_guc_log *log,
368 offset += intel_guc_get_log_buffer_size(log, i);
374 static void _guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log)
376 struct intel_guc *guc = log_to_guc(log);
384 mutex_lock(&log->relay.lock);
386 if (guc_WARN_ON(guc, !intel_guc_log_relay_created(log)))
389 /* Get the pointer to shared GuC log buffer */
390 src_data = log->buf_addr;
394 log_buf_snapshot_state = dst_data = guc_get_write_buffer(log);
402 log->relay.full_count++;
414 * Make a copy of the state structure, inside GuC log buffer
420 buffer_size = intel_guc_get_log_buffer_size(log, type);
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);
429 /* Update the state of shared log buffer */
454 guc_err(guc, "invalid log buffer state\n");
474 guc_move_to_next_buf(log);
477 mutex_unlock(&log->relay.lock);
482 struct intel_guc_log *log =
485 guc_log_copy_debuglogs_for_relay(log);
488 static int guc_log_relay_map(struct intel_guc_log *log)
490 lockdep_assert_held(&log->relay.lock);
492 if (!log->vma || !log->buf_addr)
496 * WC vmalloc mapping of log buffer pages was done at
499 i915_gem_object_get(log->vma->obj);
500 log->relay.buf_in_use = true;
505 static void guc_log_relay_unmap(struct intel_guc_log *log)
507 lockdep_assert_held(&log->relay.lock);
509 i915_gem_object_put(log->vma->obj);
510 log->relay.buf_in_use = false;
513 void intel_guc_log_init_early(struct intel_guc_log *log)
515 mutex_init(&log->relay.lock);
516 INIT_WORK(&log->relay.flush_work, copy_debug_logs_work);
517 log->relay.started = false;
520 static int guc_log_relay_create(struct intel_guc_log *log)
522 struct intel_guc *guc = log_to_guc(log);
528 lockdep_assert_held(&log->relay.lock);
529 GEM_BUG_ON(!log->vma);
532 * Keep the size of sub buffers same as shared log buffer
533 * but GuC log-events excludes the error-state-capture logs
535 subbuf_size = log->vma->size - intel_guc_log_section_size_capture(log);
560 log->relay.channel = guc_log_relay_chan;
565 static void guc_log_relay_destroy(struct intel_guc_log *log)
567 lockdep_assert_held(&log->relay.lock);
569 relay_close(log->relay.channel);
570 log->relay.channel = NULL;
573 static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log)
575 struct intel_guc *guc = log_to_guc(log);
579 _guc_log_copy_debuglogs_for_relay(log);
589 static u32 __get_default_log_level(struct intel_guc_log *log)
591 struct intel_guc *guc = log_to_guc(log);
614 int intel_guc_log_create(struct intel_guc_log *log)
616 struct intel_guc *guc = log_to_guc(log);
622 GEM_BUG_ON(log->vma);
624 guc_log_size = intel_guc_log_size(log);
632 log->vma = vma;
637 vaddr = i915_gem_object_pin_map_unlocked(log->vma->obj, I915_MAP_WC);
640 i915_vma_unpin_and_release(&log->vma, 0);
643 log->buf_addr = vaddr;
645 log->level = __get_default_log_level(log);
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));
654 guc_err(guc, "Failed to allocate or map log buffer %pe\n", ERR_PTR(ret));
658 void intel_guc_log_destroy(struct intel_guc_log *log)
660 log->buf_addr = NULL;
661 i915_vma_unpin_and_release(&log->vma, I915_VMA_RELEASE_MAP);
664 int intel_guc_log_set_level(struct intel_guc_log *log, u32 level)
666 struct intel_guc *guc = log_to_guc(log);
672 GEM_BUG_ON(!log->vma);
675 * GuC is recognizing log levels starting from 0 to max, we're using 0
683 if (log->level == level)
696 log->level = level;
704 bool intel_guc_log_relay_created(const struct intel_guc_log *log)
706 return log->buf_addr;
709 int intel_guc_log_relay_open(struct intel_guc_log *log)
713 if (!log->vma)
716 mutex_lock(&log->relay.lock);
718 if (intel_guc_log_relay_created(log)) {
724 * We require SSE 4.1 for fast reads from the GuC log buffer and
733 ret = guc_log_relay_create(log);
737 ret = guc_log_relay_map(log);
741 mutex_unlock(&log->relay.lock);
746 guc_log_relay_destroy(log);
748 mutex_unlock(&log->relay.lock);
753 int intel_guc_log_relay_start(struct intel_guc_log *log)
755 if (log->relay.started)
763 queue_work(system_highpri_wq, &log->relay.flush_work);
765 log->relay.started = true;
770 void intel_guc_log_relay_flush(struct intel_guc_log *log)
772 struct intel_guc *guc = log_to_guc(log);
775 if (!log->relay.started)
782 flush_work(&log->relay.flush_work);
787 /* GuC would have updated log buffer by now, so copy it */
788 guc_log_copy_debuglogs_for_relay(log);
792 * Stops the relay log. Called from intel_guc_log_relay_close(), so no
796 static void guc_log_relay_stop(struct intel_guc_log *log)
798 struct intel_guc *guc = log_to_guc(log);
801 if (!log->relay.started)
806 flush_work(&log->relay.flush_work);
808 log->relay.started = false;
811 void intel_guc_log_relay_close(struct intel_guc_log *log)
813 guc_log_relay_stop(log);
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);
822 void intel_guc_log_handle_flush_event(struct intel_guc_log *log)
824 if (log->relay.started)
825 queue_work(system_highpri_wq, &log->relay.flush_work);
846 * intel_guc_log_info - dump information about GuC log relay
847 * @log: the GuC log
850 * Pretty printer for GuC log info
852 void intel_guc_log_info(struct intel_guc_log *log, struct drm_printer *p)
856 if (!intel_guc_log_relay_created(log)) {
857 drm_puts(p, "GuC log relay not created\n");
863 drm_printf(p, "\tRelay full count: %u\n", log->relay.full_count);
868 log->stats[type].flush,
869 log->stats[type].sampled_overflow);
874 * intel_guc_log_dump - dump the contents of the GuC log
875 * @log: the GuC log
877 * @dump_load_err: dump the log saved on GuC load error
879 * Pretty printer for the GuC log
881 int intel_guc_log_dump(struct intel_guc_log *log, struct drm_printer *p,
884 struct intel_guc *guc = log_to_guc(log);
896 else if (guc->log.vma)
897 obj = guc->log.vma->obj;
910 guc_dbg(guc, "Failed to pin log object: %pe\n", map);
911 drm_puts(p, "(log data unaccessible)\n");