projects/linux·blob master · refs

492 lines · 14.1 KiB

1/* SPDX-License-Identifier: GPL-2.0 */
2#undef TRACE_SYSTEM
3#define TRACE_SYSTEM dma
4
5#if !defined(_TRACE_DMA_H) || defined(TRACE_HEADER_MULTI_READ)
6#define _TRACE_DMA_H
7
8#include <linux/tracepoint.h>
9#include <linux/dma-direction.h>
10#include <linux/dma-mapping.h>
11#include <trace/events/mmflags.h>
12
13TRACE_DEFINE_ENUM(DMA_BIDIRECTIONAL);
14TRACE_DEFINE_ENUM(DMA_TO_DEVICE);
15TRACE_DEFINE_ENUM(DMA_FROM_DEVICE);
16TRACE_DEFINE_ENUM(DMA_NONE);
17
18#define decode_dma_data_direction(dir) \
19 __print_symbolic(dir, \
20 { DMA_BIDIRECTIONAL, "BIDIRECTIONAL" }, \
21 { DMA_TO_DEVICE, "TO_DEVICE" }, \
22 { DMA_FROM_DEVICE, "FROM_DEVICE" }, \
23 { DMA_NONE, "NONE" })
24
25#define decode_dma_attrs(attrs) \
26 __print_flags(attrs, "|", \
27 { DMA_ATTR_WEAK_ORDERING, "WEAK_ORDERING" }, \
28 { DMA_ATTR_WRITE_COMBINE, "WRITE_COMBINE" }, \
29 { DMA_ATTR_NO_KERNEL_MAPPING, "NO_KERNEL_MAPPING" }, \
30 { DMA_ATTR_SKIP_CPU_SYNC, "SKIP_CPU_SYNC" }, \
31 { DMA_ATTR_FORCE_CONTIGUOUS, "FORCE_CONTIGUOUS" }, \
32 { DMA_ATTR_ALLOC_SINGLE_PAGES, "ALLOC_SINGLE_PAGES" }, \
33 { DMA_ATTR_NO_WARN, "NO_WARN" }, \
34 { DMA_ATTR_PRIVILEGED, "PRIVILEGED" }, \
35 { DMA_ATTR_MMIO, "MMIO" }, \
36 { DMA_ATTR_DEBUGGING_IGNORE_CACHELINES, "CACHELINES_OVERLAP" }, \
37 { DMA_ATTR_REQUIRE_COHERENT, "REQUIRE_COHERENT" }, \
38 { DMA_ATTR_CC_SHARED, "CC_SHARED" }, \
39 { __DMA_ATTR_ALLOC_CC_SHARED, "ALLOC_CC_SHARED" })
40
41DECLARE_EVENT_CLASS(dma_map,
42 TP_PROTO(struct device *dev, phys_addr_t phys_addr, dma_addr_t dma_addr,
43 size_t size, enum dma_data_direction dir, unsigned long attrs),
44 TP_ARGS(dev, phys_addr, dma_addr, size, dir, attrs),
45
46 TP_STRUCT__entry(
47 __string(device, dev_name(dev))
48 __field(u64, phys_addr)
49 __field(u64, dma_addr)
50 __field(size_t, size)
51 __field(enum dma_data_direction, dir)
52 __field(unsigned long, attrs)
53 ),
54
55 TP_fast_assign(
56 __assign_str(device);
57 __entry->phys_addr = phys_addr;
58 __entry->dma_addr = dma_addr;
59 __entry->size = size;
60 __entry->dir = dir;
61 __entry->attrs = attrs;
62 ),
63
64 TP_printk("%s dir=%s dma_addr=%llx size=%zu phys_addr=%llx attrs=%s",
65 __get_str(device),
66 decode_dma_data_direction(__entry->dir),
67 __entry->dma_addr,
68 __entry->size,
69 __entry->phys_addr,
70 decode_dma_attrs(__entry->attrs))
71);
72
73#define DEFINE_MAP_EVENT(name) \
74DEFINE_EVENT(dma_map, name, \
75 TP_PROTO(struct device *dev, phys_addr_t phys_addr, dma_addr_t dma_addr, \
76 size_t size, enum dma_data_direction dir, unsigned long attrs), \
77 TP_ARGS(dev, phys_addr, dma_addr, size, dir, attrs))
78
79DEFINE_MAP_EVENT(dma_map_phys);
80
81DECLARE_EVENT_CLASS(dma_unmap,
82 TP_PROTO(struct device *dev, dma_addr_t addr, size_t size,
83 enum dma_data_direction dir, unsigned long attrs),
84 TP_ARGS(dev, addr, size, dir, attrs),
85
86 TP_STRUCT__entry(
87 __string(device, dev_name(dev))
88 __field(u64, addr)
89 __field(size_t, size)
90 __field(enum dma_data_direction, dir)
91 __field(unsigned long, attrs)
92 ),
93
94 TP_fast_assign(
95 __assign_str(device);
96 __entry->addr = addr;
97 __entry->size = size;
98 __entry->dir = dir;
99 __entry->attrs = attrs;
100 ),
101
102 TP_printk("%s dir=%s dma_addr=%llx size=%zu attrs=%s",
103 __get_str(device),
104 decode_dma_data_direction(__entry->dir),
105 __entry->addr,
106 __entry->size,
107 decode_dma_attrs(__entry->attrs))
108);
109
110#define DEFINE_UNMAP_EVENT(name) \
111DEFINE_EVENT(dma_unmap, name, \
112 TP_PROTO(struct device *dev, dma_addr_t addr, size_t size, \
113 enum dma_data_direction dir, unsigned long attrs), \
114 TP_ARGS(dev, addr, size, dir, attrs))
115
116DEFINE_UNMAP_EVENT(dma_unmap_phys);
117
118DECLARE_EVENT_CLASS(dma_alloc_class,
119 TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr,
120 size_t size, enum dma_data_direction dir, gfp_t flags,
121 unsigned long attrs),
122 TP_ARGS(dev, virt_addr, dma_addr, size, dir, flags, attrs),
123
124 TP_STRUCT__entry(
125 __string(device, dev_name(dev))
126 __field(void *, virt_addr)
127 __field(u64, dma_addr)
128 __field(size_t, size)
129 __field(gfp_t, flags)
130 __field(enum dma_data_direction, dir)
131 __field(unsigned long, attrs)
132 ),
133
134 TP_fast_assign(
135 __assign_str(device);
136 __entry->virt_addr = virt_addr;
137 __entry->dma_addr = virt_addr ? dma_addr : 0;
138 __entry->size = size;
139 __entry->flags = flags;
140 __entry->dir = dir;
141 __entry->attrs = attrs;
142 ),
143
144 TP_printk("%s dir=%s dma_addr=%llx size=%zu virt_addr=%p flags=%s attrs=%s",
145 __get_str(device),
146 decode_dma_data_direction(__entry->dir),
147 __entry->dma_addr,
148 __entry->size,
149 __entry->virt_addr,
150 show_gfp_flags(__entry->flags),
151 decode_dma_attrs(__entry->attrs))
152);
153
154#define DEFINE_ALLOC_EVENT(name) \
155DEFINE_EVENT(dma_alloc_class, name, \
156 TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr, \
157 size_t size, enum dma_data_direction dir, gfp_t flags, \
158 unsigned long attrs), \
159 TP_ARGS(dev, virt_addr, dma_addr, size, dir, flags, attrs))
160
161DEFINE_ALLOC_EVENT(dma_alloc);
162DEFINE_ALLOC_EVENT(dma_alloc_pages);
163DEFINE_ALLOC_EVENT(dma_alloc_sgt_err);
164
165TRACE_EVENT(dma_alloc_sgt,
166 TP_PROTO(struct device *dev, struct sg_table *sgt, size_t size,
167 enum dma_data_direction dir, gfp_t flags, unsigned long attrs),
168 TP_ARGS(dev, sgt, size, dir, flags, attrs),
169
170 TP_STRUCT__entry(
171 __string(device, dev_name(dev))
172 __dynamic_array(u64, phys_addrs, sgt->orig_nents)
173 __field(u64, dma_addr)
174 __field(size_t, size)
175 __field(enum dma_data_direction, dir)
176 __field(gfp_t, flags)
177 __field(unsigned long, attrs)
178 ),
179
180 TP_fast_assign(
181 struct scatterlist *sg;
182 int i;
183
184 __assign_str(device);
185 for_each_sg(sgt->sgl, sg, sgt->orig_nents, i)
186 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg);
187 __entry->dma_addr = sg_dma_address(sgt->sgl);
188 __entry->size = size;
189 __entry->dir = dir;
190 __entry->flags = flags;
191 __entry->attrs = attrs;
192 ),
193
194 TP_printk("%s dir=%s dma_addr=%llx size=%zu phys_addrs=%s flags=%s attrs=%s",
195 __get_str(device),
196 decode_dma_data_direction(__entry->dir),
197 __entry->dma_addr,
198 __entry->size,
199 __print_array(__get_dynamic_array(phys_addrs),
200 __get_dynamic_array_len(phys_addrs) /
201 sizeof(u64), sizeof(u64)),
202 show_gfp_flags(__entry->flags),
203 decode_dma_attrs(__entry->attrs))
204);
205
206DECLARE_EVENT_CLASS(dma_free_class,
207 TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr,
208 size_t size, enum dma_data_direction dir, unsigned long attrs),
209 TP_ARGS(dev, virt_addr, dma_addr, size, dir, attrs),
210
211 TP_STRUCT__entry(
212 __string(device, dev_name(dev))
213 __field(void *, virt_addr)
214 __field(u64, dma_addr)
215 __field(size_t, size)
216 __field(enum dma_data_direction, dir)
217 __field(unsigned long, attrs)
218 ),
219
220 TP_fast_assign(
221 __assign_str(device);
222 __entry->virt_addr = virt_addr;
223 __entry->dma_addr = dma_addr;
224 __entry->size = size;
225 __entry->dir = dir;
226 __entry->attrs = attrs;
227 ),
228
229 TP_printk("%s dir=%s dma_addr=%llx size=%zu virt_addr=%p attrs=%s",
230 __get_str(device),
231 decode_dma_data_direction(__entry->dir),
232 __entry->dma_addr,
233 __entry->size,
234 __entry->virt_addr,
235 decode_dma_attrs(__entry->attrs))
236);
237
238#define DEFINE_FREE_EVENT(name) \
239DEFINE_EVENT(dma_free_class, name, \
240 TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr, \
241 size_t size, enum dma_data_direction dir, unsigned long attrs), \
242 TP_ARGS(dev, virt_addr, dma_addr, size, dir, attrs))
243
244DEFINE_FREE_EVENT(dma_free);
245DEFINE_FREE_EVENT(dma_free_pages);
246
247TRACE_EVENT(dma_free_sgt,
248 TP_PROTO(struct device *dev, struct sg_table *sgt, size_t size,
249 enum dma_data_direction dir),
250 TP_ARGS(dev, sgt, size, dir),
251
252 TP_STRUCT__entry(
253 __string(device, dev_name(dev))
254 __dynamic_array(u64, phys_addrs, sgt->orig_nents)
255 __field(u64, dma_addr)
256 __field(size_t, size)
257 __field(enum dma_data_direction, dir)
258 ),
259
260 TP_fast_assign(
261 struct scatterlist *sg;
262 int i;
263
264 __assign_str(device);
265 for_each_sg(sgt->sgl, sg, sgt->orig_nents, i)
266 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg);
267 __entry->dma_addr = sg_dma_address(sgt->sgl);
268 __entry->size = size;
269 __entry->dir = dir;
270 ),
271
272 TP_printk("%s dir=%s dma_addr=%llx size=%zu phys_addrs=%s",
273 __get_str(device),
274 decode_dma_data_direction(__entry->dir),
275 __entry->dma_addr,
276 __entry->size,
277 __print_array(__get_dynamic_array(phys_addrs),
278 __get_dynamic_array_len(phys_addrs) /
279 sizeof(u64), sizeof(u64)))
280);
281
282#define DMA_TRACE_MAX_ENTRIES 128
283
284TRACE_EVENT(dma_map_sg,
285 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,
286 int ents, enum dma_data_direction dir, unsigned long attrs),
287 TP_ARGS(dev, sgl, nents, ents, dir, attrs),
288
289 TP_STRUCT__entry(
290 __string(device, dev_name(dev))
291 __field(int, full_nents)
292 __field(int, full_ents)
293 __field(bool, truncated)
294 __dynamic_array(u64, phys_addrs, min(nents, DMA_TRACE_MAX_ENTRIES))
295 __dynamic_array(u64, dma_addrs, min(ents, DMA_TRACE_MAX_ENTRIES))
296 __dynamic_array(unsigned int, lengths, min(ents, DMA_TRACE_MAX_ENTRIES))
297 __field(enum dma_data_direction, dir)
298 __field(unsigned long, attrs)
299 ),
300
301 TP_fast_assign(
302 struct scatterlist *sg;
303 int i;
304 int traced_nents = min_t(int, nents, DMA_TRACE_MAX_ENTRIES);
305 int traced_ents = min_t(int, ents, DMA_TRACE_MAX_ENTRIES);
306
307 __assign_str(device);
308 __entry->full_nents = nents;
309 __entry->full_ents = ents;
310 __entry->truncated = (nents > DMA_TRACE_MAX_ENTRIES) || (ents > DMA_TRACE_MAX_ENTRIES);
311 for_each_sg(sgl, sg, traced_nents, i)
312 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg);
313 for_each_sg(sgl, sg, traced_ents, i) {
314 ((u64 *)__get_dynamic_array(dma_addrs))[i] =
315 sg_dma_address(sg);
316 ((unsigned int *)__get_dynamic_array(lengths))[i] =
317 sg_dma_len(sg);
318 }
319 __entry->dir = dir;
320 __entry->attrs = attrs;
321 ),
322
323 TP_printk("%s dir=%s nents=%d/%d ents=%d/%d%s dma_addrs=%s sizes=%s phys_addrs=%s attrs=%s",
324 __get_str(device),
325 decode_dma_data_direction(__entry->dir),
326 min_t(int, __entry->full_nents, DMA_TRACE_MAX_ENTRIES), __entry->full_nents,
327 min_t(int, __entry->full_ents, DMA_TRACE_MAX_ENTRIES), __entry->full_ents,
328 __entry->truncated ? " [TRUNCATED]" : "",
329 __print_array(__get_dynamic_array(dma_addrs),
330 __get_dynamic_array_len(dma_addrs) /
331 sizeof(u64), sizeof(u64)),
332 __print_array(__get_dynamic_array(lengths),
333 __get_dynamic_array_len(lengths) /
334 sizeof(unsigned int), sizeof(unsigned int)),
335 __print_array(__get_dynamic_array(phys_addrs),
336 __get_dynamic_array_len(phys_addrs) /
337 sizeof(u64), sizeof(u64)),
338 decode_dma_attrs(__entry->attrs))
339);
340
341TRACE_EVENT(dma_map_sg_err,
342 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,
343 int err, enum dma_data_direction dir, unsigned long attrs),
344 TP_ARGS(dev, sgl, nents, err, dir, attrs),
345
346 TP_STRUCT__entry(
347 __string(device, dev_name(dev))
348 __dynamic_array(u64, phys_addrs, nents)
349 __field(int, err)
350 __field(enum dma_data_direction, dir)
351 __field(unsigned long, attrs)
352 ),
353
354 TP_fast_assign(
355 struct scatterlist *sg;
356 int i;
357
358 __assign_str(device);
359 for_each_sg(sgl, sg, nents, i)
360 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg);
361 __entry->err = err;
362 __entry->dir = dir;
363 __entry->attrs = attrs;
364 ),
365
366 TP_printk("%s dir=%s dma_addrs=%s err=%d attrs=%s",
367 __get_str(device),
368 decode_dma_data_direction(__entry->dir),
369 __print_array(__get_dynamic_array(phys_addrs),
370 __get_dynamic_array_len(phys_addrs) /
371 sizeof(u64), sizeof(u64)),
372 __entry->err,
373 decode_dma_attrs(__entry->attrs))
374);
375
376TRACE_EVENT(dma_unmap_sg,
377 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,
378 enum dma_data_direction dir, unsigned long attrs),
379 TP_ARGS(dev, sgl, nents, dir, attrs),
380
381 TP_STRUCT__entry(
382 __string(device, dev_name(dev))
383 __dynamic_array(u64, addrs, nents)
384 __field(enum dma_data_direction, dir)
385 __field(unsigned long, attrs)
386 ),
387
388 TP_fast_assign(
389 struct scatterlist *sg;
390 int i;
391
392 __assign_str(device);
393 for_each_sg(sgl, sg, nents, i)
394 ((u64 *)__get_dynamic_array(addrs))[i] = sg_phys(sg);
395 __entry->dir = dir;
396 __entry->attrs = attrs;
397 ),
398
399 TP_printk("%s dir=%s phys_addrs=%s attrs=%s",
400 __get_str(device),
401 decode_dma_data_direction(__entry->dir),
402 __print_array(__get_dynamic_array(addrs),
403 __get_dynamic_array_len(addrs) /
404 sizeof(u64), sizeof(u64)),
405 decode_dma_attrs(__entry->attrs))
406);
407
408DECLARE_EVENT_CLASS(dma_sync_single,
409 TP_PROTO(struct device *dev, dma_addr_t dma_addr, size_t size,
410 enum dma_data_direction dir),
411 TP_ARGS(dev, dma_addr, size, dir),
412
413 TP_STRUCT__entry(
414 __string(device, dev_name(dev))
415 __field(u64, dma_addr)
416 __field(size_t, size)
417 __field(enum dma_data_direction, dir)
418 ),
419
420 TP_fast_assign(
421 __assign_str(device);
422 __entry->dma_addr = dma_addr;
423 __entry->size = size;
424 __entry->dir = dir;
425 ),
426
427 TP_printk("%s dir=%s dma_addr=%llx size=%zu",
428 __get_str(device),
429 decode_dma_data_direction(__entry->dir),
430 __entry->dma_addr,
431 __entry->size)
432);
433
434#define DEFINE_SYNC_SINGLE_EVENT(name) \
435DEFINE_EVENT(dma_sync_single, name, \
436 TP_PROTO(struct device *dev, dma_addr_t dma_addr, size_t size, \
437 enum dma_data_direction dir), \
438 TP_ARGS(dev, dma_addr, size, dir))
439
440DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_cpu);
441DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_device);
442
443DECLARE_EVENT_CLASS(dma_sync_sg,
444 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,
445 enum dma_data_direction dir),
446 TP_ARGS(dev, sgl, nents, dir),
447
448 TP_STRUCT__entry(
449 __string(device, dev_name(dev))
450 __dynamic_array(u64, dma_addrs, nents)
451 __dynamic_array(unsigned int, lengths, nents)
452 __field(enum dma_data_direction, dir)
453 ),
454
455 TP_fast_assign(
456 struct scatterlist *sg;
457 int i;
458
459 __assign_str(device);
460 for_each_sg(sgl, sg, nents, i) {
461 ((u64 *)__get_dynamic_array(dma_addrs))[i] =
462 sg_dma_address(sg);
463 ((unsigned int *)__get_dynamic_array(lengths))[i] =
464 sg_dma_len(sg);
465 }
466 __entry->dir = dir;
467 ),
468
469 TP_printk("%s dir=%s dma_addrs=%s sizes=%s",
470 __get_str(device),
471 decode_dma_data_direction(__entry->dir),
472 __print_array(__get_dynamic_array(dma_addrs),
473 __get_dynamic_array_len(dma_addrs) /
474 sizeof(u64), sizeof(u64)),
475 __print_array(__get_dynamic_array(lengths),
476 __get_dynamic_array_len(lengths) /
477 sizeof(unsigned int), sizeof(unsigned int)))
478);
479
480#define DEFINE_SYNC_SG_EVENT(name) \
481DEFINE_EVENT(dma_sync_sg, name, \
482 TP_PROTO(struct device *dev, struct scatterlist *sg, int nents, \
483 enum dma_data_direction dir), \
484 TP_ARGS(dev, sg, nents, dir))
485
486DEFINE_SYNC_SG_EVENT(dma_sync_sg_for_cpu);
487DEFINE_SYNC_SG_EVENT(dma_sync_sg_for_device);
488
489#endif /* _TRACE_DMA_H */
490
491/* This part must be outside protection */
492#include <trace/define_trace.h>