1
2
3
4
5
6#include <linux/debugfs.h>
7
8#include "gt/intel_gt.h"
9#include "i915_drv.h"
10#include "i915_memcpy.h"
11#include "intel_guc_log.h"
12
13static void guc_log_capture_logs(struct intel_guc_log *log);
14
15
16
17
18
19
20
21
22
23
24static int guc_action_flush_log_complete(struct intel_guc *guc)
25{
26 u32 action[] = {
27 INTEL_GUC_ACTION_LOG_BUFFER_FILE_FLUSH_COMPLETE
28 };
29
30 return intel_guc_send(guc, action, ARRAY_SIZE(action));
31}
32
33static int guc_action_flush_log(struct intel_guc *guc)
34{
35 u32 action[] = {
36 INTEL_GUC_ACTION_FORCE_LOG_BUFFER_FLUSH,
37 0
38 };
39
40 return intel_guc_send(guc, action, ARRAY_SIZE(action));
41}
42
43static int guc_action_control_log(struct intel_guc *guc, bool enable,
44 bool default_logging, u32 verbosity)
45{
46 u32 action[] = {
47 INTEL_GUC_ACTION_UK_LOG_ENABLE_LOGGING,
48 (enable ? GUC_LOG_CONTROL_LOGGING_ENABLED : 0) |
49 (verbosity << GUC_LOG_CONTROL_VERBOSITY_SHIFT) |
50 (default_logging ? GUC_LOG_CONTROL_DEFAULT_LOGGING : 0)
51 };
52
53 GEM_BUG_ON(verbosity > GUC_LOG_VERBOSITY_MAX);
54
55 return intel_guc_send(guc, action, ARRAY_SIZE(action));
56}
57
58static void guc_log_enable_flush_events(struct intel_guc_log *log)
59{
60 intel_guc_enable_msg(log_to_guc(log),
61 INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
62 INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED);
63}
64
65static void guc_log_disable_flush_events(struct intel_guc_log *log)
66{
67 intel_guc_disable_msg(log_to_guc(log),
68 INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
69 INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED);
70}
71
72
73
74
75
76static int subbuf_start_callback(struct rchan_buf *buf,
77 void *subbuf,
78 void *prev_subbuf,
79 size_t prev_padding)
80{
81
82
83
84
85
86
87
88
89
90
91 if (relay_buf_full(buf))
92 return 0;
93
94 return 1;
95}
96
97
98
99
100static struct dentry *create_buf_file_callback(const char *filename,
101 struct dentry *parent,
102 umode_t mode,
103 struct rchan_buf *buf,
104 int *is_global)
105{
106 struct dentry *buf_file;
107
108
109
110
111
112
113
114 *is_global = 1;
115
116 if (!parent)
117 return NULL;
118
119 buf_file = debugfs_create_file(filename, mode,
120 parent, buf, &relay_file_operations);
121 if (IS_ERR(buf_file))
122 return NULL;
123
124 return buf_file;
125}
126
127
128
129
130static int remove_buf_file_callback(struct dentry *dentry)
131{
132 debugfs_remove(dentry);
133 return 0;
134}
135
136
137static const struct rchan_callbacks relay_callbacks = {
138 .subbuf_start = subbuf_start_callback,
139 .create_buf_file = create_buf_file_callback,
140 .remove_buf_file = remove_buf_file_callback,
141};
142
143static void guc_move_to_next_buf(struct intel_guc_log *log)
144{
145
146
147
148
149 smp_wmb();
150
151
152 relay_reserve(log->relay.channel, log->vma->obj->base.size);
153
154
155 relay_flush(log->relay.channel);
156}
157
158static void *guc_get_write_buffer(struct intel_guc_log *log)
159{
160
161
162
163
164
165
166
167
168
169 return relay_reserve(log->relay.channel, 0);
170}
171
172static bool guc_check_log_buf_overflow(struct intel_guc_log *log,
173 enum guc_log_buffer_type type,
174 unsigned int full_cnt)
175{
176 unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
177 bool overflow = false;
178
179 if (full_cnt != prev_full_cnt) {
180 overflow = true;
181
182 log->stats[type].overflow = full_cnt;
183 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
184
185 if (full_cnt < prev_full_cnt) {
186
187 log->stats[type].sampled_overflow += 16;
188 }
189
190 dev_notice_ratelimited(guc_to_gt(log_to_guc(log))->i915->drm.dev,
191 "GuC log buffer overflow\n");
192 }
193
194 return overflow;
195}
196
197static unsigned int guc_get_log_buffer_size(enum guc_log_buffer_type type)
198{
199 switch (type) {
200 case GUC_DEBUG_LOG_BUFFER:
201 return DEBUG_BUFFER_SIZE;
202 case GUC_CRASH_DUMP_LOG_BUFFER:
203 return CRASH_BUFFER_SIZE;
204 default:
205 MISSING_CASE(type);
206 }
207
208 return 0;
209}
210
211static void guc_read_update_log_buffer(struct intel_guc_log *log)
212{
213 unsigned int buffer_size, read_offset, write_offset, bytes_to_copy, full_cnt;
214 struct guc_log_buffer_state *log_buf_state, *log_buf_snapshot_state;
215 struct guc_log_buffer_state log_buf_state_local;
216 enum guc_log_buffer_type type;
217 void *src_data, *dst_data;
218 bool new_overflow;
219
220 mutex_lock(&log->relay.lock);
221
222 if (WARN_ON(!intel_guc_log_relay_created(log)))
223 goto out_unlock;
224
225
226 log_buf_state = src_data = log->relay.buf_addr;
227
228
229 log_buf_snapshot_state = dst_data = guc_get_write_buffer(log);
230
231 if (unlikely(!log_buf_snapshot_state)) {
232
233
234
235
236 DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
237 log->relay.full_count++;
238
239 goto out_unlock;
240 }
241
242
243 src_data += PAGE_SIZE;
244 dst_data += PAGE_SIZE;
245
246 for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
247
248
249
250
251
252 memcpy(&log_buf_state_local, log_buf_state,
253 sizeof(struct guc_log_buffer_state));
254 buffer_size = guc_get_log_buffer_size(type);
255 read_offset = log_buf_state_local.read_ptr;
256 write_offset = log_buf_state_local.sampled_write_ptr;
257 full_cnt = log_buf_state_local.buffer_full_cnt;
258
259
260 log->stats[type].flush += log_buf_state_local.flush_to_file;
261 new_overflow = guc_check_log_buf_overflow(log, type, full_cnt);
262
263
264 log_buf_state->read_ptr = write_offset;
265 log_buf_state->flush_to_file = 0;
266 log_buf_state++;
267
268
269 memcpy(log_buf_snapshot_state, &log_buf_state_local,
270 sizeof(struct guc_log_buffer_state));
271
272
273
274
275
276
277
278 log_buf_snapshot_state->write_ptr = write_offset;
279 log_buf_snapshot_state++;
280
281
282 if (unlikely(new_overflow)) {
283
284 read_offset = 0;
285 write_offset = buffer_size;
286 } else if (unlikely((read_offset > buffer_size) ||
287 (write_offset > buffer_size))) {
288 DRM_ERROR("invalid log buffer state\n");
289
290 read_offset = 0;
291 write_offset = buffer_size;
292 }
293
294
295 if (read_offset > write_offset) {
296 i915_memcpy_from_wc(dst_data, src_data, write_offset);
297 bytes_to_copy = buffer_size - read_offset;
298 } else {
299 bytes_to_copy = write_offset - read_offset;
300 }
301 i915_memcpy_from_wc(dst_data + read_offset,
302 src_data + read_offset, bytes_to_copy);
303
304 src_data += buffer_size;
305 dst_data += buffer_size;
306 }
307
308 guc_move_to_next_buf(log);
309
310out_unlock:
311 mutex_unlock(&log->relay.lock);
312}
313
314static void capture_logs_work(struct work_struct *work)
315{
316 struct intel_guc_log *log =
317 container_of(work, struct intel_guc_log, relay.flush_work);
318
319 guc_log_capture_logs(log);
320}
321
322static int guc_log_map(struct intel_guc_log *log)
323{
324 void *vaddr;
325
326 lockdep_assert_held(&log->relay.lock);
327
328 if (!log->vma)
329 return -ENODEV;
330
331
332
333
334
335
336 vaddr = i915_gem_object_pin_map_unlocked(log->vma->obj, I915_MAP_WC);
337 if (IS_ERR(vaddr))
338 return PTR_ERR(vaddr);
339
340 log->relay.buf_addr = vaddr;
341
342 return 0;
343}
344
345static void guc_log_unmap(struct intel_guc_log *log)
346{
347 lockdep_assert_held(&log->relay.lock);
348
349 i915_gem_object_unpin_map(log->vma->obj);
350 log->relay.buf_addr = NULL;
351}
352
353void intel_guc_log_init_early(struct intel_guc_log *log)
354{
355 mutex_init(&log->relay.lock);
356 INIT_WORK(&log->relay.flush_work, capture_logs_work);
357 log->relay.started = false;
358}
359
360static int guc_log_relay_create(struct intel_guc_log *log)
361{
362 struct intel_guc *guc = log_to_guc(log);
363 struct drm_i915_private *dev_priv = guc_to_gt(guc)->i915;
364 struct rchan *guc_log_relay_chan;
365 size_t n_subbufs, subbuf_size;
366 int ret;
367
368 lockdep_assert_held(&log->relay.lock);
369 GEM_BUG_ON(!log->vma);
370
371
372 subbuf_size = log->vma->size;
373
374
375
376
377
378
379
380 n_subbufs = 8;
381
382 guc_log_relay_chan = relay_open("guc_log",
383 dev_priv->drm.primary->debugfs_root,
384 subbuf_size, n_subbufs,
385 &relay_callbacks, dev_priv);
386 if (!guc_log_relay_chan) {
387 DRM_ERROR("Couldn't create relay chan for GuC logging\n");
388
389 ret = -ENOMEM;
390 return ret;
391 }
392
393 GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
394 log->relay.channel = guc_log_relay_chan;
395
396 return 0;
397}
398
399static void guc_log_relay_destroy(struct intel_guc_log *log)
400{
401 lockdep_assert_held(&log->relay.lock);
402
403 relay_close(log->relay.channel);
404 log->relay.channel = NULL;
405}
406
407static void guc_log_capture_logs(struct intel_guc_log *log)
408{
409 struct intel_guc *guc = log_to_guc(log);
410 struct drm_i915_private *dev_priv = guc_to_gt(guc)->i915;
411 intel_wakeref_t wakeref;
412
413 guc_read_update_log_buffer(log);
414
415
416
417
418
419 with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)
420 guc_action_flush_log_complete(guc);
421}
422
423static u32 __get_default_log_level(struct intel_guc_log *log)
424{
425 struct intel_guc *guc = log_to_guc(log);
426 struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
427
428
429 if (i915->params.guc_log_level < 0) {
430 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
431 IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ?
432 GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_NON_VERBOSE;
433 }
434
435 if (i915->params.guc_log_level > GUC_LOG_LEVEL_MAX) {
436 DRM_WARN("Incompatible option detected: %s=%d, %s!\n",
437 "guc_log_level", i915->params.guc_log_level,
438 "verbosity too high");
439 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
440 IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ?
441 GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_DISABLED;
442 }
443
444 GEM_BUG_ON(i915->params.guc_log_level < GUC_LOG_LEVEL_DISABLED);
445 GEM_BUG_ON(i915->params.guc_log_level > GUC_LOG_LEVEL_MAX);
446 return i915->params.guc_log_level;
447}
448
449int intel_guc_log_create(struct intel_guc_log *log)
450{
451 struct intel_guc *guc = log_to_guc(log);
452 struct i915_vma *vma;
453 u32 guc_log_size;
454 int ret;
455
456 GEM_BUG_ON(log->vma);
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473 guc_log_size = PAGE_SIZE + CRASH_BUFFER_SIZE + DEBUG_BUFFER_SIZE;
474
475 vma = intel_guc_allocate_vma(guc, guc_log_size);
476 if (IS_ERR(vma)) {
477 ret = PTR_ERR(vma);
478 goto err;
479 }
480
481 log->vma = vma;
482
483 log->level = __get_default_log_level(log);
484 DRM_DEBUG_DRIVER("guc_log_level=%d (%s, verbose:%s, verbosity:%d)\n",
485 log->level, enableddisabled(log->level),
486 yesno(GUC_LOG_LEVEL_IS_VERBOSE(log->level)),
487 GUC_LOG_LEVEL_TO_VERBOSITY(log->level));
488
489 return 0;
490
491err:
492 DRM_ERROR("Failed to allocate GuC log buffer. %d\n", ret);
493 return ret;
494}
495
496void intel_guc_log_destroy(struct intel_guc_log *log)
497{
498 i915_vma_unpin_and_release(&log->vma, 0);
499}
500
501int intel_guc_log_set_level(struct intel_guc_log *log, u32 level)
502{
503 struct intel_guc *guc = log_to_guc(log);
504 struct drm_i915_private *dev_priv = guc_to_gt(guc)->i915;
505 intel_wakeref_t wakeref;
506 int ret = 0;
507
508 BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
509 GEM_BUG_ON(!log->vma);
510
511
512
513
514
515 if (level < GUC_LOG_LEVEL_DISABLED || level > GUC_LOG_LEVEL_MAX)
516 return -EINVAL;
517
518 mutex_lock(&dev_priv->drm.struct_mutex);
519
520 if (log->level == level)
521 goto out_unlock;
522
523 with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)
524 ret = guc_action_control_log(guc,
525 GUC_LOG_LEVEL_IS_VERBOSE(level),
526 GUC_LOG_LEVEL_IS_ENABLED(level),
527 GUC_LOG_LEVEL_TO_VERBOSITY(level));
528 if (ret) {
529 DRM_DEBUG_DRIVER("guc_log_control action failed %d\n", ret);
530 goto out_unlock;
531 }
532
533 log->level = level;
534
535out_unlock:
536 mutex_unlock(&dev_priv->drm.struct_mutex);
537
538 return ret;
539}
540
541bool intel_guc_log_relay_created(const struct intel_guc_log *log)
542{
543 return log->relay.buf_addr;
544}
545
546int intel_guc_log_relay_open(struct intel_guc_log *log)
547{
548 int ret;
549
550 if (!log->vma)
551 return -ENODEV;
552
553 mutex_lock(&log->relay.lock);
554
555 if (intel_guc_log_relay_created(log)) {
556 ret = -EEXIST;
557 goto out_unlock;
558 }
559
560
561
562
563
564
565 if (!i915_has_memcpy_from_wc()) {
566 ret = -ENXIO;
567 goto out_unlock;
568 }
569
570 ret = guc_log_relay_create(log);
571 if (ret)
572 goto out_unlock;
573
574 ret = guc_log_map(log);
575 if (ret)
576 goto out_relay;
577
578 mutex_unlock(&log->relay.lock);
579
580 return 0;
581
582out_relay:
583 guc_log_relay_destroy(log);
584out_unlock:
585 mutex_unlock(&log->relay.lock);
586
587 return ret;
588}
589
590int intel_guc_log_relay_start(struct intel_guc_log *log)
591{
592 if (log->relay.started)
593 return -EEXIST;
594
595 guc_log_enable_flush_events(log);
596
597
598
599
600
601
602 queue_work(system_highpri_wq, &log->relay.flush_work);
603
604 log->relay.started = true;
605
606 return 0;
607}
608
609void intel_guc_log_relay_flush(struct intel_guc_log *log)
610{
611 struct intel_guc *guc = log_to_guc(log);
612 intel_wakeref_t wakeref;
613
614 if (!log->relay.started)
615 return;
616
617
618
619
620
621 flush_work(&log->relay.flush_work);
622
623 with_intel_runtime_pm(guc_to_gt(guc)->uncore->rpm, wakeref)
624 guc_action_flush_log(guc);
625
626
627 guc_log_capture_logs(log);
628}
629
630
631
632
633
634
635static void guc_log_relay_stop(struct intel_guc_log *log)
636{
637 struct intel_guc *guc = log_to_guc(log);
638 struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
639
640 if (!log->relay.started)
641 return;
642
643 guc_log_disable_flush_events(log);
644 intel_synchronize_irq(i915);
645
646 flush_work(&log->relay.flush_work);
647
648 log->relay.started = false;
649}
650
651void intel_guc_log_relay_close(struct intel_guc_log *log)
652{
653 guc_log_relay_stop(log);
654
655 mutex_lock(&log->relay.lock);
656 GEM_BUG_ON(!intel_guc_log_relay_created(log));
657 guc_log_unmap(log);
658 guc_log_relay_destroy(log);
659 mutex_unlock(&log->relay.lock);
660}
661
662void intel_guc_log_handle_flush_event(struct intel_guc_log *log)
663{
664 queue_work(system_highpri_wq, &log->relay.flush_work);
665}
666
667static const char *
668stringify_guc_log_type(enum guc_log_buffer_type type)
669{
670 switch (type) {
671 case GUC_DEBUG_LOG_BUFFER:
672 return "DEBUG";
673 case GUC_CRASH_DUMP_LOG_BUFFER:
674 return "CRASH";
675 default:
676 MISSING_CASE(type);
677 }
678
679 return "";
680}
681
682
683
684
685
686
687
688
689void intel_guc_log_info(struct intel_guc_log *log, struct drm_printer *p)
690{
691 enum guc_log_buffer_type type;
692
693 if (!intel_guc_log_relay_created(log)) {
694 drm_puts(p, "GuC log relay not created\n");
695 return;
696 }
697
698 drm_puts(p, "GuC logging stats:\n");
699
700 drm_printf(p, "\tRelay full count: %u\n", log->relay.full_count);
701
702 for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
703 drm_printf(p, "\t%s:\tflush count %10u, overflow count %10u\n",
704 stringify_guc_log_type(type),
705 log->stats[type].flush,
706 log->stats[type].sampled_overflow);
707 }
708}
709
710
711
712
713
714
715
716
717
718int intel_guc_log_dump(struct intel_guc_log *log, struct drm_printer *p,
719 bool dump_load_err)
720{
721 struct intel_guc *guc = log_to_guc(log);
722 struct intel_uc *uc = container_of(guc, struct intel_uc, guc);
723 struct drm_i915_gem_object *obj = NULL;
724 u32 *map;
725 int i = 0;
726
727 if (!intel_guc_is_supported(guc))
728 return -ENODEV;
729
730 if (dump_load_err)
731 obj = uc->load_err_log;
732 else if (guc->log.vma)
733 obj = guc->log.vma->obj;
734
735 if (!obj)
736 return 0;
737
738 map = i915_gem_object_pin_map_unlocked(obj, I915_MAP_WC);
739 if (IS_ERR(map)) {
740 DRM_DEBUG("Failed to pin object\n");
741 drm_puts(p, "(log data unaccessible)\n");
742 return PTR_ERR(map);
743 }
744
745 for (i = 0; i < obj->base.size / sizeof(u32); i += 4)
746 drm_printf(p, "0x%08x 0x%08x 0x%08x 0x%08x\n",
747 *(map + i), *(map + i + 1),
748 *(map + i + 2), *(map + i + 3));
749
750 drm_puts(p, "\n");
751
752 i915_gem_object_unpin_map(obj);
753
754 return 0;
755}
756