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