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