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 { 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 41 DECLARE_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) \ 74 DEFINE_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 79 DEFINE_MAP_EVENT(dma_map_phys); 80 81 DECLARE_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) \ 111 DEFINE_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 116 DEFINE_UNMAP_EVENT(dma_unmap_phys); 117 118 DECLARE_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 = dma_addr; 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) \ 155 DEFINE_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 161 DEFINE_ALLOC_EVENT(dma_alloc); 162 DEFINE_ALLOC_EVENT(dma_alloc_pages); 163 DEFINE_ALLOC_EVENT(dma_alloc_sgt_err); 164 165 TRACE_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 206 DECLARE_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) \ 239 DEFINE_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 244 DEFINE_FREE_EVENT(dma_free); 245 DEFINE_FREE_EVENT(dma_free_pages); 246 247 TRACE_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 284 TRACE_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 341 TRACE_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 376 TRACE_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 408 DECLARE_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) \ 435 DEFINE_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 440 DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_cpu); 441 DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_device); 442 443 DECLARE_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) \ 481 DEFINE_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 486 DEFINE_SYNC_SG_EVENT(dma_sync_sg_for_cpu); 487 DEFINE_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> 493