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