Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
drm/xe/trace: Print device_id in xe_trace events
In multi-gpu environments it is important to know the device
gt events belongs to. The tracing information includes the device_id
to indicate the device the event is associated with.
v2: Use variable sized variant to display dev name(Gustavo)
v3: Pass single argument to __assign_str to fix kunit error
v4: Remove unused sting_helper library include
Suggested-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Cc: Lucas De Marchi <lucas.demarchi@intel.com>
Reviewed-by: Gustavo Sousa <gustavo.sousa@intel.com>
Signed-off-by: Radhakrishna Sripada <radhakrishna.sripada@intel.com>
Signed-off-by: Matt Roper <matthew.d.roper@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240607182943.3572524-6-radhakrishna.sripada@intel.com
authored by
Radhakrishna Sripada
and committed by
Matt Roper
501c4255
3cba2f1d
+59
-40
+15
-12
drivers/gpu/drm/xe/xe_gt_tlb_invalidation.c
+15
-12
drivers/gpu/drm/xe/xe_gt_tlb_invalidation.c
···
22
22
{
23
23
struct xe_gt *gt = container_of(work, struct xe_gt,
24
24
tlb_invalidation.fence_tdr.work);
25
+
struct xe_device *xe = gt_to_xe(gt);
25
26
struct xe_gt_tlb_invalidation_fence *fence, *next;
26
27
27
28
spin_lock_irq(>->tlb_invalidation.pending_lock);
···
34
33
if (msecs_to_jiffies(since_inval_ms) < TLB_TIMEOUT)
35
34
break;
36
35
37
-
trace_xe_gt_tlb_invalidation_fence_timeout(fence);
36
+
trace_xe_gt_tlb_invalidation_fence_timeout(xe, fence);
38
37
xe_gt_err(gt, "TLB invalidation fence timeout, seqno=%d recv=%d",
39
38
fence->seqno, gt->tlb_invalidation.seqno_recv);
40
39
···
72
71
}
73
72
74
73
static void
75
-
__invalidation_fence_signal(struct xe_gt_tlb_invalidation_fence *fence)
74
+
__invalidation_fence_signal(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence)
76
75
{
77
-
trace_xe_gt_tlb_invalidation_fence_signal(fence);
76
+
trace_xe_gt_tlb_invalidation_fence_signal(xe, fence);
78
77
dma_fence_signal(&fence->base);
79
78
dma_fence_put(&fence->base);
80
79
}
81
80
82
81
static void
83
-
invalidation_fence_signal(struct xe_gt_tlb_invalidation_fence *fence)
82
+
invalidation_fence_signal(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence)
84
83
{
85
84
list_del(&fence->link);
86
-
__invalidation_fence_signal(fence);
85
+
__invalidation_fence_signal(xe, fence);
87
86
}
88
87
89
88
/**
···
122
121
123
122
list_for_each_entry_safe(fence, next,
124
123
>->tlb_invalidation.pending_fences, link)
125
-
invalidation_fence_signal(fence);
124
+
invalidation_fence_signal(gt_to_xe(gt), fence);
126
125
spin_unlock_irq(>->tlb_invalidation.pending_lock);
127
126
mutex_unlock(>->uc.guc.ct.lock);
128
127
}
···
145
144
u32 *action, int len)
146
145
{
147
146
struct xe_gt *gt = guc_to_gt(guc);
147
+
struct xe_device *xe = gt_to_xe(gt);
148
148
int seqno;
149
149
int ret;
150
150
···
159
157
seqno = gt->tlb_invalidation.seqno;
160
158
if (fence) {
161
159
fence->seqno = seqno;
162
-
trace_xe_gt_tlb_invalidation_fence_send(fence);
160
+
trace_xe_gt_tlb_invalidation_fence_send(xe, fence);
163
161
}
164
162
action[1] = seqno;
165
163
ret = xe_guc_ct_send_locked(&guc->ct, action, len,
···
173
171
* we can just go ahead and signal the fence here.
174
172
*/
175
173
if (tlb_invalidation_seqno_past(gt, seqno)) {
176
-
__invalidation_fence_signal(fence);
174
+
__invalidation_fence_signal(xe, fence);
177
175
} else {
178
176
fence->invalidation_time = ktime_get();
179
177
list_add_tail(&fence->link,
···
186
184
}
187
185
spin_unlock_irq(>->tlb_invalidation.pending_lock);
188
186
} else if (ret < 0 && fence) {
189
-
__invalidation_fence_signal(fence);
187
+
__invalidation_fence_signal(xe, fence);
190
188
}
191
189
if (!ret) {
192
190
gt->tlb_invalidation.seqno = (gt->tlb_invalidation.seqno + 1) %
···
296
294
/* Execlists not supported */
297
295
if (gt_to_xe(gt)->info.force_execlist) {
298
296
if (fence)
299
-
__invalidation_fence_signal(fence);
297
+
__invalidation_fence_signal(xe, fence);
300
298
301
299
return 0;
302
300
}
···
434
432
int xe_guc_tlb_invalidation_done_handler(struct xe_guc *guc, u32 *msg, u32 len)
435
433
{
436
434
struct xe_gt *gt = guc_to_gt(guc);
435
+
struct xe_device *xe = gt_to_xe(gt);
437
436
struct xe_gt_tlb_invalidation_fence *fence, *next;
438
437
unsigned long flags;
439
438
···
471
468
472
469
list_for_each_entry_safe(fence, next,
473
470
>->tlb_invalidation.pending_fences, link) {
474
-
trace_xe_gt_tlb_invalidation_fence_recv(fence);
471
+
trace_xe_gt_tlb_invalidation_fence_recv(xe, fence);
475
472
476
473
if (!tlb_invalidation_seqno_past(gt, fence->seqno))
477
474
break;
478
475
479
-
invalidation_fence_signal(fence);
476
+
invalidation_fence_signal(xe, fence);
480
477
}
481
478
482
479
if (!list_empty(>->tlb_invalidation.pending_fences))
+5
-3
drivers/gpu/drm/xe/xe_pt.c
+5
-3
drivers/gpu/drm/xe/xe_pt.c
···
1137
1137
{
1138
1138
struct invalidation_fence *ifence =
1139
1139
container_of(cb, struct invalidation_fence, cb);
1140
+
struct xe_device *xe = gt_to_xe(ifence->gt);
1140
1141
1141
-
trace_xe_gt_tlb_invalidation_fence_cb(&ifence->base);
1142
+
trace_xe_gt_tlb_invalidation_fence_cb(xe, &ifence->base);
1142
1143
if (!ifence->fence->error) {
1143
1144
queue_work(system_wq, &ifence->work);
1144
1145
} else {
···
1154
1153
{
1155
1154
struct invalidation_fence *ifence =
1156
1155
container_of(w, struct invalidation_fence, work);
1156
+
struct xe_device *xe = gt_to_xe(ifence->gt);
1157
1157
1158
-
trace_xe_gt_tlb_invalidation_fence_work_func(&ifence->base);
1158
+
trace_xe_gt_tlb_invalidation_fence_work_func(xe, &ifence->base);
1159
1159
xe_gt_tlb_invalidation_range(ifence->gt, &ifence->base, ifence->start,
1160
1160
ifence->end, ifence->asid);
1161
1161
}
···
1168
1166
{
1169
1167
int ret;
1170
1168
1171
-
trace_xe_gt_tlb_invalidation_fence_create(&ifence->base);
1169
+
trace_xe_gt_tlb_invalidation_fence_create(gt_to_xe(gt), &ifence->base);
1172
1170
1173
1171
spin_lock_irq(>->tlb_invalidation.lock);
1174
1172
dma_fence_init(&ifence->base.base, &invalidation_fence_ops,
+39
-25
drivers/gpu/drm/xe/xe_trace.h
+39
-25
drivers/gpu/drm/xe/xe_trace.h
···
20
20
#include "xe_sched_job.h"
21
21
#include "xe_vm.h"
22
22
23
+
#define __dev_name_xe(xe) dev_name((xe)->drm.dev)
24
+
#define __dev_name_gt(gt) __dev_name_xe(gt_to_xe((gt)))
25
+
#define __dev_name_eq(q) __dev_name_gt((q)->gt)
26
+
23
27
DECLARE_EVENT_CLASS(xe_gt_tlb_invalidation_fence,
24
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
25
-
TP_ARGS(fence),
28
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
29
+
TP_ARGS(xe, fence),
26
30
27
31
TP_STRUCT__entry(
32
+
__string(dev, __dev_name_xe(xe))
28
33
__field(struct xe_gt_tlb_invalidation_fence *, fence)
29
34
__field(int, seqno)
30
35
),
31
36
32
37
TP_fast_assign(
38
+
__assign_str(dev);
33
39
__entry->fence = fence;
34
40
__entry->seqno = fence->seqno;
35
41
),
36
42
37
-
TP_printk("fence=%p, seqno=%d",
38
-
__entry->fence, __entry->seqno)
43
+
TP_printk("dev=%s, fence=%p, seqno=%d",
44
+
__get_str(dev), __entry->fence, __entry->seqno)
39
45
);
40
46
41
47
DEFINE_EVENT(xe_gt_tlb_invalidation_fence, xe_gt_tlb_invalidation_fence_create,
42
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
43
-
TP_ARGS(fence)
48
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
49
+
TP_ARGS(xe, fence)
44
50
);
45
51
46
52
DEFINE_EVENT(xe_gt_tlb_invalidation_fence,
47
53
xe_gt_tlb_invalidation_fence_work_func,
48
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
49
-
TP_ARGS(fence)
54
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
55
+
TP_ARGS(xe, fence)
50
56
);
51
57
52
58
DEFINE_EVENT(xe_gt_tlb_invalidation_fence, xe_gt_tlb_invalidation_fence_cb,
53
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
54
-
TP_ARGS(fence)
59
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
60
+
TP_ARGS(xe, fence)
55
61
);
56
62
57
63
DEFINE_EVENT(xe_gt_tlb_invalidation_fence, xe_gt_tlb_invalidation_fence_send,
58
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
59
-
TP_ARGS(fence)
64
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
65
+
TP_ARGS(xe, fence)
60
66
);
61
67
62
68
DEFINE_EVENT(xe_gt_tlb_invalidation_fence, xe_gt_tlb_invalidation_fence_recv,
63
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
64
-
TP_ARGS(fence)
69
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
70
+
TP_ARGS(xe, fence)
65
71
);
66
72
67
73
DEFINE_EVENT(xe_gt_tlb_invalidation_fence, xe_gt_tlb_invalidation_fence_signal,
68
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
69
-
TP_ARGS(fence)
74
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
75
+
TP_ARGS(xe, fence)
70
76
);
71
77
72
78
DEFINE_EVENT(xe_gt_tlb_invalidation_fence, xe_gt_tlb_invalidation_fence_timeout,
73
-
TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
74
-
TP_ARGS(fence)
79
+
TP_PROTO(struct xe_device *xe, struct xe_gt_tlb_invalidation_fence *fence),
80
+
TP_ARGS(xe, fence)
75
81
);
76
82
77
83
DECLARE_EVENT_CLASS(xe_exec_queue,
···
85
79
TP_ARGS(q),
86
80
87
81
TP_STRUCT__entry(
82
+
__string(dev, __dev_name_eq(q))
88
83
__field(enum xe_engine_class, class)
89
84
__field(u32, logical_mask)
90
85
__field(u8, gt_id)
···
96
89
),
97
90
98
91
TP_fast_assign(
92
+
__assign_str(dev);
99
93
__entry->class = q->class;
100
94
__entry->logical_mask = q->logical_mask;
101
95
__entry->gt_id = q->gt->info.id;
···
106
98
__entry->flags = q->flags;
107
99
),
108
100
109
-
TP_printk("%d:0x%x, gt=%d, width=%d, guc_id=%d, guc_state=0x%x, flags=0x%x",
110
-
__entry->class, __entry->logical_mask,
101
+
TP_printk("dev=%s, %d:0x%x, gt=%d, width=%d, guc_id=%d, guc_state=0x%x, flags=0x%x",
102
+
__get_str(dev), __entry->class, __entry->logical_mask,
111
103
__entry->gt_id, __entry->width, __entry->guc_id,
112
104
__entry->guc_state, __entry->flags)
113
105
);
···
207
199
TP_ARGS(job),
208
200
209
201
TP_STRUCT__entry(
202
+
__string(dev, __dev_name_eq(job->q))
210
203
__field(u32, seqno)
211
204
__field(u32, lrc_seqno)
212
205
__field(u16, guc_id)
···
219
210
),
220
211
221
212
TP_fast_assign(
213
+
__assign_str(dev);
222
214
__entry->seqno = xe_sched_job_seqno(job);
223
215
__entry->lrc_seqno = xe_sched_job_lrc_seqno(job);
224
216
__entry->guc_id = job->q->guc->id;
···
231
221
__entry->batch_addr = (u64)job->ptrs[0].batch_addr;
232
222
),
233
223
234
-
TP_printk("fence=%p, seqno=%u, lrc_seqno=%u, guc_id=%d, batch_addr=0x%012llx, guc_state=0x%x, flags=0x%x, error=%d",
235
-
__entry->fence, __entry->seqno,
224
+
TP_printk("dev=%s, fence=%p, seqno=%u, lrc_seqno=%u, guc_id=%d, batch_addr=0x%012llx, guc_state=0x%x, flags=0x%x, error=%d",
225
+
__get_str(dev), __entry->fence, __entry->seqno,
236
226
__entry->lrc_seqno, __entry->guc_id,
237
227
__entry->batch_addr, __entry->guc_state,
238
228
__entry->flags, __entry->error)
···
278
268
TP_ARGS(msg),
279
269
280
270
TP_STRUCT__entry(
271
+
__string(dev, __dev_name_eq(((struct xe_exec_queue *)msg->private_data)))
281
272
__field(u32, opcode)
282
273
__field(u16, guc_id)
283
274
),
284
275
285
276
TP_fast_assign(
277
+
__assign_str(dev);
286
278
__entry->opcode = msg->opcode;
287
279
__entry->guc_id =
288
280
((struct xe_exec_queue *)msg->private_data)->guc->id;
289
281
),
290
282
291
-
TP_printk("guc_id=%d, opcode=%u", __entry->guc_id,
283
+
TP_printk("dev=%s, guc_id=%d, opcode=%u", __get_str(dev), __entry->guc_id,
292
284
__entry->opcode)
293
285
);
294
286
···
309
297
TP_ARGS(fence),
310
298
311
299
TP_STRUCT__entry(
300
+
__string(dev, __dev_name_gt(fence->ctx->gt))
312
301
__field(u64, ctx)
313
302
__field(u32, seqno)
314
303
__field(struct xe_hw_fence *, fence)
315
304
),
316
305
317
306
TP_fast_assign(
307
+
__assign_str(dev);
318
308
__entry->ctx = fence->dma.context;
319
309
__entry->seqno = fence->dma.seqno;
320
310
__entry->fence = fence;
321
311
),
322
312
323
-
TP_printk("ctx=0x%016llx, fence=%p, seqno=%u",
324
-
__entry->ctx, __entry->fence, __entry->seqno)
313
+
TP_printk("dev=%s, ctx=0x%016llx, fence=%p, seqno=%u",
314
+
__get_str(dev), __entry->ctx, __entry->fence, __entry->seqno)
325
315
);
326
316
327
317
DEFINE_EVENT(xe_hw_fence, xe_hw_fence_create,