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.
287 static void guc_move_to_next_buf(struct intel_guc_log *log)
296 relay_reserve(log->relay.channel, log->vma->obj->base.size -
297 intel_guc_log_section_size_capture(log));
300 relay_flush(log->relay.channel);
303 static void *guc_get_write_buffer(struct intel_guc_log *log)
314 return relay_reserve(log->relay.channel, 0);
317 bool intel_guc_check_log_buf_overflow(struct intel_guc_log *log,
321 unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
327 log->stats[type].overflow = full_cnt;
328 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
332 log->stats[type].sampled_overflow += 16;
335 guc_notice_ratelimited(log_to_guc(log), "log buffer overflow\n");
341 unsigned int intel_guc_get_log_buffer_size(struct intel_guc_log *log,
346 return intel_guc_log_section_size_debug(log);
348 return intel_guc_log_section_size_crash(log);
350 return intel_guc_log_section_size_capture(log);
358 size_t intel_guc_get_log_buffer_offset(struct intel_guc_log *log,
367 offset += intel_guc_get_log_buffer_size(log, i);
373 static void _guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log)
375 struct intel_guc *guc = log_to_guc(log);
383 mutex_lock(&log->relay.lock);
385 if (guc_WARN_ON(guc, !intel_guc_log_relay_created(log)))
388 /* Get the pointer to shared GuC log buffer */
389 src_data = log->buf_addr;
393 log_buf_snapshot_state = dst_data = guc_get_write_buffer(log);
401 log->relay.full_count++;
413 * Make a copy of the state structure, inside GuC log buffer
419 buffer_size = intel_guc_get_log_buffer_size(log, type);
425 log->stats[type].flush += log_buf_state_local.flush_to_file;
426 new_overflow = intel_guc_check_log_buf_overflow(log, type, full_cnt);
428 /* Update the state of shared log buffer */
453 guc_err(guc, "invalid log buffer state\n");
473 guc_move_to_next_buf(log);
476 mutex_unlock(&log->relay.lock);
481 struct intel_guc_log *log =
484 guc_log_copy_debuglogs_for_relay(log);
487 static int guc_log_relay_map(struct intel_guc_log *log)
489 lockdep_assert_held(&log->relay.lock);
491 if (!log->vma || !log->buf_addr)
495 * WC vmalloc mapping of log buffer pages was done at
498 i915_gem_object_get(log->vma->obj);
499 log->relay.buf_in_use = true;
504 static void guc_log_relay_unmap(struct intel_guc_log *log)
506 lockdep_assert_held(&log->relay.lock);
508 i915_gem_object_put(log->vma->obj);
509 log->relay.buf_in_use = false;
512 void intel_guc_log_init_early(struct intel_guc_log *log)
514 mutex_init(&log->relay.lock);
515 INIT_WORK(&log->relay.flush_work, copy_debug_logs_work);
516 log->relay.started = false;
519 static int guc_log_relay_create(struct intel_guc_log *log)
521 struct intel_guc *guc = log_to_guc(log);
527 lockdep_assert_held(&log->relay.lock);
528 GEM_BUG_ON(!log->vma);
531 * Keep the size of sub buffers same as shared log buffer
532 * but GuC log-events excludes the error-state-capture logs
534 subbuf_size = log->vma->size - intel_guc_log_section_size_capture(log);
559 log->relay.channel = guc_log_relay_chan;
564 static void guc_log_relay_destroy(struct intel_guc_log *log)
566 lockdep_assert_held(&log->relay.lock);
568 relay_close(log->relay.channel);
569 log->relay.channel = NULL;
572 static void guc_log_copy_debuglogs_for_relay(struct intel_guc_log *log)
574 struct intel_guc *guc = log_to_guc(log);
578 _guc_log_copy_debuglogs_for_relay(log);
588 static u32 __get_default_log_level(struct intel_guc_log *log)
590 struct intel_guc *guc = log_to_guc(log);
613 int intel_guc_log_create(struct intel_guc_log *log)
615 struct intel_guc *guc = log_to_guc(log);
621 GEM_BUG_ON(log->vma);
623 guc_log_size = intel_guc_log_size(log);
631 log->vma = vma;
636 vaddr = i915_gem_object_pin_map_unlocked(log->vma->obj, I915_MAP_WC);
639 i915_vma_unpin_and_release(&log->vma, 0);
642 log->buf_addr = vaddr;
644 log->level = __get_default_log_level(log);
646 log->level, str_enabled_disabled(log->level),
647 str_yes_no(GUC_LOG_LEVEL_IS_VERBOSE(log->level)),
648 GUC_LOG_LEVEL_TO_VERBOSITY(log->level));
653 guc_err(guc, "Failed to allocate or map log buffer %pe\n", ERR_PTR(ret));
657 void intel_guc_log_destroy(struct intel_guc_log *log)
659 log->buf_addr = NULL;
660 i915_vma_unpin_and_release(&log->vma, I915_VMA_RELEASE_MAP);
663 int intel_guc_log_set_level(struct intel_guc_log *log, u32 level)
665 struct intel_guc *guc = log_to_guc(log);
671 GEM_BUG_ON(!log->vma);
674 * GuC is recognizing log levels starting from 0 to max, we're using 0
682 if (log->level == level)
695 log->level = level;
703 bool intel_guc_log_relay_created(const struct intel_guc_log *log)
705 return log->buf_addr;
708 int intel_guc_log_relay_open(struct intel_guc_log *log)
712 if (!log->vma)
715 mutex_lock(&log->relay.lock);
717 if (intel_guc_log_relay_created(log)) {
723 * We require SSE 4.1 for fast reads from the GuC log buffer and
732 ret = guc_log_relay_create(log);
736 ret = guc_log_relay_map(log);
740 mutex_unlock(&log->relay.lock);
745 guc_log_relay_destroy(log);
747 mutex_unlock(&log->relay.lock);
752 int intel_guc_log_relay_start(struct intel_guc_log *log)
754 if (log->relay.started)
762 queue_work(system_highpri_wq, &log->relay.flush_work);
764 log->relay.started = true;
769 void intel_guc_log_relay_flush(struct intel_guc_log *log)
771 struct intel_guc *guc = log_to_guc(log);
774 if (!log->relay.started)
781 flush_work(&log->relay.flush_work);
786 /* GuC would have updated log buffer by now, so copy it */
787 guc_log_copy_debuglogs_for_relay(log);
791 * Stops the relay log. Called from intel_guc_log_relay_close(), so no
795 static void guc_log_relay_stop(struct intel_guc_log *log)
797 struct intel_guc *guc = log_to_guc(log);
800 if (!log->relay.started)
805 flush_work(&log->relay.flush_work);
807 log->relay.started = false;
810 void intel_guc_log_relay_close(struct intel_guc_log *log)
812 guc_log_relay_stop(log);
814 mutex_lock(&log->relay.lock);
815 GEM_BUG_ON(!intel_guc_log_relay_created(log));
816 guc_log_relay_unmap(log);
817 guc_log_relay_destroy(log);
818 mutex_unlock(&log->relay.lock);
821 void intel_guc_log_handle_flush_event(struct intel_guc_log *log)
823 if (log->relay.started)
824 queue_work(system_highpri_wq, &log->relay.flush_work);
845 * intel_guc_log_info - dump information about GuC log relay
846 * @log: the GuC log
849 * Pretty printer for GuC log info
851 void intel_guc_log_info(struct intel_guc_log *log, struct drm_printer *p)
855 if (!intel_guc_log_relay_created(log)) {
856 drm_puts(p, "GuC log relay not created\n");
862 drm_printf(p, "\tRelay full count: %u\n", log->relay.full_count);
867 log->stats[type].flush,
868 log->stats[type].sampled_overflow);
873 * intel_guc_log_dump - dump the contents of the GuC log
874 * @log: the GuC log
876 * @dump_load_err: dump the log saved on GuC load error
878 * Pretty printer for the GuC log
880 int intel_guc_log_dump(struct intel_guc_log *log, struct drm_printer *p,
883 struct intel_guc *guc = log_to_guc(log);
895 else if (guc->log.vma)
896 obj = guc->log.vma->obj;
909 guc_dbg(guc, "Failed to pin log object: %pe\n", map);
910 drm_puts(p, "(log data unaccessible)\n");