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->attrs = attrs; 137 ), 138 139 TP_printk("%s dir=%s dma_addr=%llx size=%zu virt_addr=%p flags=%s attrs=%s", 140 __get_str(device), 141 decode_dma_data_direction(__entry->dir), 142 __entry->dma_addr, 143 __entry->size, 144 __entry->virt_addr, 145 show_gfp_flags(__entry->flags), 146 decode_dma_attrs(__entry->attrs)) 147 ); 148 149 #define DEFINE_ALLOC_EVENT(name) \ 150 DEFINE_EVENT(dma_alloc_class, name, \ 151 TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr, \ 152 size_t size, enum dma_data_direction dir, gfp_t flags, \ 153 unsigned long attrs), \ 154 TP_ARGS(dev, virt_addr, dma_addr, size, dir, flags, attrs)) 155 156 DEFINE_ALLOC_EVENT(dma_alloc); 157 DEFINE_ALLOC_EVENT(dma_alloc_pages); 158 DEFINE_ALLOC_EVENT(dma_alloc_sgt_err); 159 160 TRACE_EVENT(dma_alloc_sgt, 161 TP_PROTO(struct device *dev, struct sg_table *sgt, size_t size, 162 enum dma_data_direction dir, gfp_t flags, unsigned long attrs), 163 TP_ARGS(dev, sgt, size, dir, flags, attrs), 164 165 TP_STRUCT__entry( 166 __string(device, dev_name(dev)) 167 __dynamic_array(u64, phys_addrs, sgt->orig_nents) 168 __field(u64, dma_addr) 169 __field(size_t, size) 170 __field(enum dma_data_direction, dir) 171 __field(gfp_t, flags) 172 __field(unsigned long, attrs) 173 ), 174 175 TP_fast_assign( 176 struct scatterlist *sg; 177 int i; 178 179 __assign_str(device); 180 for_each_sg(sgt->sgl, sg, sgt->orig_nents, i) 181 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg); 182 __entry->dma_addr = sg_dma_address(sgt->sgl); 183 __entry->size = size; 184 __entry->dir = dir; 185 __entry->flags = flags; 186 __entry->attrs = attrs; 187 ), 188 189 TP_printk("%s dir=%s dma_addr=%llx size=%zu phys_addrs=%s flags=%s attrs=%s", 190 __get_str(device), 191 decode_dma_data_direction(__entry->dir), 192 __entry->dma_addr, 193 __entry->size, 194 __print_array(__get_dynamic_array(phys_addrs), 195 __get_dynamic_array_len(phys_addrs) / 196 sizeof(u64), sizeof(u64)), 197 show_gfp_flags(__entry->flags), 198 decode_dma_attrs(__entry->attrs)) 199 ); 200 201 DECLARE_EVENT_CLASS(dma_free_class, 202 TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr, 203 size_t size, enum dma_data_direction dir, unsigned long attrs), 204 TP_ARGS(dev, virt_addr, dma_addr, size, dir, attrs), 205 206 TP_STRUCT__entry( 207 __string(device, dev_name(dev)) 208 __field(void *, virt_addr) 209 __field(u64, dma_addr) 210 __field(size_t, size) 211 __field(enum dma_data_direction, dir) 212 __field(unsigned long, attrs) 213 ), 214 215 TP_fast_assign( 216 __assign_str(device); 217 __entry->virt_addr = virt_addr; 218 __entry->dma_addr = dma_addr; 219 __entry->size = size; 220 __entry->dir = dir; 221 __entry->attrs = attrs; 222 ), 223 224 TP_printk("%s dir=%s dma_addr=%llx size=%zu virt_addr=%p attrs=%s", 225 __get_str(device), 226 decode_dma_data_direction(__entry->dir), 227 __entry->dma_addr, 228 __entry->size, 229 __entry->virt_addr, 230 decode_dma_attrs(__entry->attrs)) 231 ); 232 233 #define DEFINE_FREE_EVENT(name) \ 234 DEFINE_EVENT(dma_free_class, name, \ 235 TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr, \ 236 size_t size, enum dma_data_direction dir, unsigned long attrs), \ 237 TP_ARGS(dev, virt_addr, dma_addr, size, dir, attrs)) 238 239 DEFINE_FREE_EVENT(dma_free); 240 DEFINE_FREE_EVENT(dma_free_pages); 241 242 TRACE_EVENT(dma_free_sgt, 243 TP_PROTO(struct device *dev, struct sg_table *sgt, size_t size, 244 enum dma_data_direction dir), 245 TP_ARGS(dev, sgt, size, dir), 246 247 TP_STRUCT__entry( 248 __string(device, dev_name(dev)) 249 __dynamic_array(u64, phys_addrs, sgt->orig_nents) 250 __field(u64, dma_addr) 251 __field(size_t, size) 252 __field(enum dma_data_direction, dir) 253 ), 254 255 TP_fast_assign( 256 struct scatterlist *sg; 257 int i; 258 259 __assign_str(device); 260 for_each_sg(sgt->sgl, sg, sgt->orig_nents, i) 261 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg); 262 __entry->dma_addr = sg_dma_address(sgt->sgl); 263 __entry->size = size; 264 __entry->dir = dir; 265 ), 266 267 TP_printk("%s dir=%s dma_addr=%llx size=%zu phys_addrs=%s", 268 __get_str(device), 269 decode_dma_data_direction(__entry->dir), 270 __entry->dma_addr, 271 __entry->size, 272 __print_array(__get_dynamic_array(phys_addrs), 273 __get_dynamic_array_len(phys_addrs) / 274 sizeof(u64), sizeof(u64))) 275 ); 276 277 TRACE_EVENT(dma_map_sg, 278 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents, 279 int ents, enum dma_data_direction dir, unsigned long attrs), 280 TP_ARGS(dev, sgl, nents, ents, dir, attrs), 281 282 TP_STRUCT__entry( 283 __string(device, dev_name(dev)) 284 __dynamic_array(u64, phys_addrs, nents) 285 __dynamic_array(u64, dma_addrs, ents) 286 __dynamic_array(unsigned int, lengths, ents) 287 __field(enum dma_data_direction, dir) 288 __field(unsigned long, attrs) 289 ), 290 291 TP_fast_assign( 292 struct scatterlist *sg; 293 int i; 294 295 __assign_str(device); 296 for_each_sg(sgl, sg, nents, i) 297 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg); 298 for_each_sg(sgl, sg, ents, i) { 299 ((u64 *)__get_dynamic_array(dma_addrs))[i] = 300 sg_dma_address(sg); 301 ((unsigned int *)__get_dynamic_array(lengths))[i] = 302 sg_dma_len(sg); 303 } 304 __entry->dir = dir; 305 __entry->attrs = attrs; 306 ), 307 308 TP_printk("%s dir=%s dma_addrs=%s sizes=%s phys_addrs=%s attrs=%s", 309 __get_str(device), 310 decode_dma_data_direction(__entry->dir), 311 __print_array(__get_dynamic_array(dma_addrs), 312 __get_dynamic_array_len(dma_addrs) / 313 sizeof(u64), sizeof(u64)), 314 __print_array(__get_dynamic_array(lengths), 315 __get_dynamic_array_len(lengths) / 316 sizeof(unsigned int), sizeof(unsigned int)), 317 __print_array(__get_dynamic_array(phys_addrs), 318 __get_dynamic_array_len(phys_addrs) / 319 sizeof(u64), sizeof(u64)), 320 decode_dma_attrs(__entry->attrs)) 321 ); 322 323 TRACE_EVENT(dma_map_sg_err, 324 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents, 325 int err, enum dma_data_direction dir, unsigned long attrs), 326 TP_ARGS(dev, sgl, nents, err, dir, attrs), 327 328 TP_STRUCT__entry( 329 __string(device, dev_name(dev)) 330 __dynamic_array(u64, phys_addrs, nents) 331 __field(int, err) 332 __field(enum dma_data_direction, dir) 333 __field(unsigned long, attrs) 334 ), 335 336 TP_fast_assign( 337 struct scatterlist *sg; 338 int i; 339 340 __assign_str(device); 341 for_each_sg(sgl, sg, nents, i) 342 ((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg); 343 __entry->err = err; 344 __entry->dir = dir; 345 __entry->attrs = attrs; 346 ), 347 348 TP_printk("%s dir=%s dma_addrs=%s err=%d attrs=%s", 349 __get_str(device), 350 decode_dma_data_direction(__entry->dir), 351 __print_array(__get_dynamic_array(phys_addrs), 352 __get_dynamic_array_len(phys_addrs) / 353 sizeof(u64), sizeof(u64)), 354 __entry->err, 355 decode_dma_attrs(__entry->attrs)) 356 ); 357 358 TRACE_EVENT(dma_unmap_sg, 359 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents, 360 enum dma_data_direction dir, unsigned long attrs), 361 TP_ARGS(dev, sgl, nents, dir, attrs), 362 363 TP_STRUCT__entry( 364 __string(device, dev_name(dev)) 365 __dynamic_array(u64, addrs, nents) 366 __field(enum dma_data_direction, dir) 367 __field(unsigned long, attrs) 368 ), 369 370 TP_fast_assign( 371 struct scatterlist *sg; 372 int i; 373 374 __assign_str(device); 375 for_each_sg(sgl, sg, nents, i) 376 ((u64 *)__get_dynamic_array(addrs))[i] = sg_phys(sg); 377 __entry->dir = dir; 378 __entry->attrs = attrs; 379 ), 380 381 TP_printk("%s dir=%s phys_addrs=%s attrs=%s", 382 __get_str(device), 383 decode_dma_data_direction(__entry->dir), 384 __print_array(__get_dynamic_array(addrs), 385 __get_dynamic_array_len(addrs) / 386 sizeof(u64), sizeof(u64)), 387 decode_dma_attrs(__entry->attrs)) 388 ); 389 390 DECLARE_EVENT_CLASS(dma_sync_single, 391 TP_PROTO(struct device *dev, dma_addr_t dma_addr, size_t size, 392 enum dma_data_direction dir), 393 TP_ARGS(dev, dma_addr, size, dir), 394 395 TP_STRUCT__entry( 396 __string(device, dev_name(dev)) 397 __field(u64, dma_addr) 398 __field(size_t, size) 399 __field(enum dma_data_direction, dir) 400 ), 401 402 TP_fast_assign( 403 __assign_str(device); 404 __entry->dma_addr = dma_addr; 405 __entry->size = size; 406 __entry->dir = dir; 407 ), 408 409 TP_printk("%s dir=%s dma_addr=%llx size=%zu", 410 __get_str(device), 411 decode_dma_data_direction(__entry->dir), 412 __entry->dma_addr, 413 __entry->size) 414 ); 415 416 #define DEFINE_SYNC_SINGLE_EVENT(name) \ 417 DEFINE_EVENT(dma_sync_single, name, \ 418 TP_PROTO(struct device *dev, dma_addr_t dma_addr, size_t size, \ 419 enum dma_data_direction dir), \ 420 TP_ARGS(dev, dma_addr, size, dir)) 421 422 DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_cpu); 423 DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_device); 424 425 DECLARE_EVENT_CLASS(dma_sync_sg, 426 TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents, 427 enum dma_data_direction dir), 428 TP_ARGS(dev, sgl, nents, dir), 429 430 TP_STRUCT__entry( 431 __string(device, dev_name(dev)) 432 __dynamic_array(u64, dma_addrs, nents) 433 __dynamic_array(unsigned int, lengths, nents) 434 __field(enum dma_data_direction, dir) 435 ), 436 437 TP_fast_assign( 438 struct scatterlist *sg; 439 int i; 440 441 __assign_str(device); 442 for_each_sg(sgl, sg, nents, i) { 443 ((u64 *)__get_dynamic_array(dma_addrs))[i] = 444 sg_dma_address(sg); 445 ((unsigned int *)__get_dynamic_array(lengths))[i] = 446 sg_dma_len(sg); 447 } 448 __entry->dir = dir; 449 ), 450 451 TP_printk("%s dir=%s dma_addrs=%s sizes=%s", 452 __get_str(device), 453 decode_dma_data_direction(__entry->dir), 454 __print_array(__get_dynamic_array(dma_addrs), 455 __get_dynamic_array_len(dma_addrs) / 456 sizeof(u64), sizeof(u64)), 457 __print_array(__get_dynamic_array(lengths), 458 __get_dynamic_array_len(lengths) / 459 sizeof(unsigned int), sizeof(unsigned int))) 460 ); 461 462 #define DEFINE_SYNC_SG_EVENT(name) \ 463 DEFINE_EVENT(dma_sync_sg, name, \ 464 TP_PROTO(struct device *dev, struct scatterlist *sg, int nents, \ 465 enum dma_data_direction dir), \ 466 TP_ARGS(dev, sg, nents, dir)) 467 468 DEFINE_SYNC_SG_EVENT(dma_sync_sg_for_cpu); 469 DEFINE_SYNC_SG_EVENT(dma_sync_sg_for_device); 470 471 #endif /* _TRACE_DMA_H */ 472 473 /* This part must be outside protection */ 474 #include <trace/define_trace.h> 475