1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2009, Christoph Hellwig 4 * All Rights Reserved. 5 * 6 * NOTE: none of these tracepoints shall be considered a stable kernel ABI 7 * as they can change at any time. 8 * 9 * Current conventions for printing numbers measuring specific units: 10 * 11 * agno: allocation group number 12 * 13 * agino: per-AG inode number 14 * ino: filesystem inode number 15 * 16 * agbno: per-AG block number in fs blocks 17 * rgbno: per-rtgroup block number in fs blocks 18 * startblock: physical block number for file mappings. This is either a 19 * segmented fsblock for data device mappings, or a rfsblock 20 * for realtime device mappings 21 * fsbcount: number of blocks in an extent, in fs blocks 22 * 23 * gbno: generic allocation group block number. This is an agbno for 24 * space in a per-AG or a rgbno for space in a realtime group. 25 * 26 * daddr: physical block number in 512b blocks 27 * bbcount: number of blocks in a physical extent, in 512b blocks 28 * 29 * rtx: physical rt extent number for extent mappings 30 * rtxcount: number of rt extents in an extent mapping 31 * 32 * owner: reverse-mapping owner, usually inodes 33 * 34 * fileoff: file offset, in fs blocks 35 * pos: file offset, in bytes 36 * bytecount: number of bytes 37 * 38 * dablk: directory or xattr block offset, in filesystem blocks 39 * 40 * disize: ondisk file size, in bytes 41 * isize: incore file size, in bytes 42 * 43 * forkoff: inode fork offset, in bytes 44 * 45 * ireccount: number of inode records 46 * 47 * Numbers describing space allocations (blocks, extents, inodes) should be 48 * formatted in hexadecimal. 49 */ 50 #undef TRACE_SYSTEM 51 #define TRACE_SYSTEM xfs 52 53 #if !defined(_TRACE_XFS_H) || defined(TRACE_HEADER_MULTI_READ) 54 #define _TRACE_XFS_H 55 56 #include <linux/tracepoint.h> 57 58 struct xfs_agf; 59 struct xfs_ail; 60 struct xfs_alloc_arg; 61 struct xfs_attr_list_context; 62 struct xfs_buf_log_item; 63 struct xfs_da_args; 64 struct xfs_da_node_entry; 65 struct xfs_dquot; 66 struct xfs_log_item; 67 struct xlog; 68 struct xlog_ticket; 69 struct xlog_recover; 70 struct xlog_recover_item; 71 struct xlog_rec_header; 72 struct xlog_in_core; 73 struct xfs_buf_log_format; 74 struct xfs_inode_log_format; 75 struct xfs_bmbt_irec; 76 struct xfs_btree_cur; 77 struct xfs_defer_op_type; 78 struct xfs_refcount_irec; 79 struct xfs_fsmap; 80 struct xfs_fsmap_irec; 81 struct xfs_group; 82 struct xfs_rmap_irec; 83 struct xfs_icreate_log; 84 struct xfs_iunlink_item; 85 struct xfs_owner_info; 86 struct xfs_trans_res; 87 struct xfs_inobt_rec_incore; 88 union xfs_btree_ptr; 89 struct xfs_dqtrx; 90 struct xfs_icwalk; 91 struct xfs_perag; 92 struct xfbtree; 93 struct xfs_btree_ops; 94 struct xfs_bmap_intent; 95 struct xfs_exchmaps_intent; 96 struct xfs_exchmaps_req; 97 struct xfs_exchrange; 98 struct xfs_getparents; 99 struct xfs_parent_irec; 100 struct xfs_attrlist_cursor_kern; 101 struct xfs_extent_free_item; 102 struct xfs_rmap_intent; 103 struct xfs_refcount_intent; 104 struct xfs_metadir_update; 105 struct xfs_rtgroup; 106 struct xfs_open_zone; 107 struct xfs_healthmon_event; 108 struct xfs_healthmon; 109 struct fserror_event; 110 111 #define XFS_ATTR_FILTER_FLAGS \ 112 { XFS_ATTR_ROOT, "ROOT" }, \ 113 { XFS_ATTR_SECURE, "SECURE" }, \ 114 { XFS_ATTR_INCOMPLETE, "INCOMPLETE" }, \ 115 { XFS_ATTR_PARENT, "PARENT" } 116 117 DECLARE_EVENT_CLASS(xfs_attr_list_class, 118 TP_PROTO(struct xfs_attr_list_context *ctx), 119 TP_ARGS(ctx), 120 TP_STRUCT__entry( 121 __field(dev_t, dev) 122 __field(xfs_ino_t, ino) 123 __field(u32, hashval) 124 __field(u32, blkno) 125 __field(u32, offset) 126 __field(void *, buffer) 127 __field(int, bufsize) 128 __field(int, count) 129 __field(int, firstu) 130 __field(int, dupcnt) 131 __field(unsigned int, attr_filter) 132 ), 133 TP_fast_assign( 134 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; 135 __entry->ino = ctx->dp->i_ino; 136 __entry->hashval = ctx->cursor.hashval; 137 __entry->blkno = ctx->cursor.blkno; 138 __entry->offset = ctx->cursor.offset; 139 __entry->buffer = ctx->buffer; 140 __entry->bufsize = ctx->bufsize; 141 __entry->count = ctx->count; 142 __entry->firstu = ctx->firstu; 143 __entry->attr_filter = ctx->attr_filter; 144 ), 145 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " 146 "buffer %p size %u count %u firstu %u filter %s", 147 MAJOR(__entry->dev), MINOR(__entry->dev), 148 __entry->ino, 149 __entry->hashval, 150 __entry->blkno, 151 __entry->offset, 152 __entry->dupcnt, 153 __entry->buffer, 154 __entry->bufsize, 155 __entry->count, 156 __entry->firstu, 157 __print_flags(__entry->attr_filter, "|", 158 XFS_ATTR_FILTER_FLAGS) 159 ) 160 ) 161 162 #define DEFINE_ATTR_LIST_EVENT(name) \ 163 DEFINE_EVENT(xfs_attr_list_class, name, \ 164 TP_PROTO(struct xfs_attr_list_context *ctx), \ 165 TP_ARGS(ctx)) 166 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf); 167 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all); 168 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf); 169 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf_end); 170 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_full); 171 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_add); 172 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_wrong_blk); 173 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_notfound); 174 DEFINE_ATTR_LIST_EVENT(xfs_attr_leaf_list); 175 DEFINE_ATTR_LIST_EVENT(xfs_attr_node_list); 176 177 TRACE_EVENT(xfs_calc_atomic_write_unit_max, 178 TP_PROTO(struct xfs_mount *mp, enum xfs_group_type type, 179 unsigned int max_write, unsigned int max_ioend, 180 unsigned int max_gsize, unsigned int awu_max), 181 TP_ARGS(mp, type, max_write, max_ioend, max_gsize, awu_max), 182 TP_STRUCT__entry( 183 __field(dev_t, dev) 184 __field(enum xfs_group_type, type) 185 __field(unsigned int, max_write) 186 __field(unsigned int, max_ioend) 187 __field(unsigned int, max_gsize) 188 __field(unsigned int, awu_max) 189 ), 190 TP_fast_assign( 191 __entry->dev = mp->m_super->s_dev; 192 __entry->type = type; 193 __entry->max_write = max_write; 194 __entry->max_ioend = max_ioend; 195 __entry->max_gsize = max_gsize; 196 __entry->awu_max = awu_max; 197 ), 198 TP_printk("dev %d:%d %s max_write %u max_ioend %u max_gsize %u awu_max %u", 199 MAJOR(__entry->dev), MINOR(__entry->dev), 200 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 201 __entry->max_write, 202 __entry->max_ioend, 203 __entry->max_gsize, 204 __entry->awu_max) 205 ); 206 207 TRACE_EVENT(xfs_calc_max_atomic_write_fsblocks, 208 TP_PROTO(struct xfs_mount *mp, unsigned int per_intent, 209 unsigned int step_size, unsigned int logres, 210 unsigned int blockcount), 211 TP_ARGS(mp, per_intent, step_size, logres, blockcount), 212 TP_STRUCT__entry( 213 __field(dev_t, dev) 214 __field(unsigned int, per_intent) 215 __field(unsigned int, step_size) 216 __field(unsigned int, logres) 217 __field(unsigned int, blockcount) 218 ), 219 TP_fast_assign( 220 __entry->dev = mp->m_super->s_dev; 221 __entry->per_intent = per_intent; 222 __entry->step_size = step_size; 223 __entry->logres = logres; 224 __entry->blockcount = blockcount; 225 ), 226 TP_printk("dev %d:%d per_intent %u step_size %u logres %u blockcount %u", 227 MAJOR(__entry->dev), MINOR(__entry->dev), 228 __entry->per_intent, 229 __entry->step_size, 230 __entry->logres, 231 __entry->blockcount) 232 ); 233 234 TRACE_EVENT(xfs_calc_max_atomic_write_log_geometry, 235 TP_PROTO(struct xfs_mount *mp, unsigned int per_intent, 236 unsigned int step_size, unsigned int blockcount, 237 unsigned int min_logblocks, unsigned int logres), 238 TP_ARGS(mp, per_intent, step_size, blockcount, min_logblocks, logres), 239 TP_STRUCT__entry( 240 __field(dev_t, dev) 241 __field(unsigned int, per_intent) 242 __field(unsigned int, step_size) 243 __field(unsigned int, blockcount) 244 __field(unsigned int, min_logblocks) 245 __field(unsigned int, cur_logblocks) 246 __field(unsigned int, logres) 247 ), 248 TP_fast_assign( 249 __entry->dev = mp->m_super->s_dev; 250 __entry->per_intent = per_intent; 251 __entry->step_size = step_size; 252 __entry->blockcount = blockcount; 253 __entry->min_logblocks = min_logblocks; 254 __entry->cur_logblocks = mp->m_sb.sb_logblocks; 255 __entry->logres = logres; 256 ), 257 TP_printk("dev %d:%d per_intent %u step_size %u blockcount %u min_logblocks %u logblocks %u logres %u", 258 MAJOR(__entry->dev), MINOR(__entry->dev), 259 __entry->per_intent, 260 __entry->step_size, 261 __entry->blockcount, 262 __entry->min_logblocks, 263 __entry->cur_logblocks, 264 __entry->logres) 265 ); 266 267 TRACE_EVENT(xlog_intent_recovery_failed, 268 TP_PROTO(struct xfs_mount *mp, const struct xfs_defer_op_type *ops, 269 int error), 270 TP_ARGS(mp, ops, error), 271 TP_STRUCT__entry( 272 __field(dev_t, dev) 273 __string(name, ops->name) 274 __field(int, error) 275 ), 276 TP_fast_assign( 277 __entry->dev = mp->m_super->s_dev; 278 __assign_str(name); 279 __entry->error = error; 280 ), 281 TP_printk("dev %d:%d optype %s error %d", 282 MAJOR(__entry->dev), MINOR(__entry->dev), 283 __get_str(name), 284 __entry->error) 285 ); 286 287 DECLARE_EVENT_CLASS(xfs_perag_class, 288 TP_PROTO(const struct xfs_perag *pag, unsigned long caller_ip), 289 TP_ARGS(pag, caller_ip), 290 TP_STRUCT__entry( 291 __field(dev_t, dev) 292 __field(xfs_agnumber_t, agno) 293 __field(int, refcount) 294 __field(int, active_refcount) 295 __field(unsigned long, caller_ip) 296 ), 297 TP_fast_assign( 298 __entry->dev = pag_mount(pag)->m_super->s_dev; 299 __entry->agno = pag_agno(pag); 300 __entry->refcount = atomic_read(&pag->pag_group.xg_ref); 301 __entry->active_refcount = 302 atomic_read(&pag->pag_group.xg_active_ref); 303 __entry->caller_ip = caller_ip; 304 ), 305 TP_printk("dev %d:%d agno 0x%x passive refs %d active refs %d caller %pS", 306 MAJOR(__entry->dev), MINOR(__entry->dev), 307 __entry->agno, 308 __entry->refcount, 309 __entry->active_refcount, 310 (char *)__entry->caller_ip) 311 ); 312 313 #define DEFINE_PERAG_REF_EVENT(name) \ 314 DEFINE_EVENT(xfs_perag_class, name, \ 315 TP_PROTO(const struct xfs_perag *pag, unsigned long caller_ip), \ 316 TP_ARGS(pag, caller_ip)) 317 DEFINE_PERAG_REF_EVENT(xfs_perag_set_inode_tag); 318 DEFINE_PERAG_REF_EVENT(xfs_perag_clear_inode_tag); 319 DEFINE_PERAG_REF_EVENT(xfs_reclaim_inodes_count); 320 321 TRACE_DEFINE_ENUM(XG_TYPE_AG); 322 TRACE_DEFINE_ENUM(XG_TYPE_RTG); 323 324 DECLARE_EVENT_CLASS(xfs_group_class, 325 TP_PROTO(struct xfs_group *xg, unsigned long caller_ip), 326 TP_ARGS(xg, caller_ip), 327 TP_STRUCT__entry( 328 __field(dev_t, dev) 329 __field(enum xfs_group_type, type) 330 __field(xfs_agnumber_t, agno) 331 __field(int, refcount) 332 __field(int, active_refcount) 333 __field(unsigned long, caller_ip) 334 ), 335 TP_fast_assign( 336 __entry->dev = xg->xg_mount->m_super->s_dev; 337 __entry->type = xg->xg_type; 338 __entry->agno = xg->xg_gno; 339 __entry->refcount = atomic_read(&xg->xg_ref); 340 __entry->active_refcount = atomic_read(&xg->xg_active_ref); 341 __entry->caller_ip = caller_ip; 342 ), 343 TP_printk("dev %d:%d %sno 0x%x passive refs %d active refs %d caller %pS", 344 MAJOR(__entry->dev), MINOR(__entry->dev), 345 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 346 __entry->agno, 347 __entry->refcount, 348 __entry->active_refcount, 349 (char *)__entry->caller_ip) 350 ); 351 352 #define DEFINE_GROUP_REF_EVENT(name) \ 353 DEFINE_EVENT(xfs_group_class, name, \ 354 TP_PROTO(struct xfs_group *xg, unsigned long caller_ip), \ 355 TP_ARGS(xg, caller_ip)) 356 DEFINE_GROUP_REF_EVENT(xfs_group_get); 357 DEFINE_GROUP_REF_EVENT(xfs_group_hold); 358 DEFINE_GROUP_REF_EVENT(xfs_group_put); 359 DEFINE_GROUP_REF_EVENT(xfs_group_grab); 360 DEFINE_GROUP_REF_EVENT(xfs_group_grab_next_tag); 361 DEFINE_GROUP_REF_EVENT(xfs_group_rele); 362 363 #ifdef CONFIG_XFS_RT 364 DECLARE_EVENT_CLASS(xfs_zone_class, 365 TP_PROTO(struct xfs_rtgroup *rtg), 366 TP_ARGS(rtg), 367 TP_STRUCT__entry( 368 __field(dev_t, dev) 369 __field(xfs_rgnumber_t, rgno) 370 __field(xfs_rgblock_t, used) 371 __field(unsigned int, nr_open) 372 ), 373 TP_fast_assign( 374 struct xfs_mount *mp = rtg_mount(rtg); 375 376 __entry->dev = mp->m_super->s_dev; 377 __entry->rgno = rtg_rgno(rtg); 378 __entry->used = rtg_rmap(rtg)->i_used_blocks; 379 __entry->nr_open = mp->m_zone_info->zi_nr_open_zones; 380 ), 381 TP_printk("dev %d:%d rgno 0x%x used 0x%x nr_open %u", 382 MAJOR(__entry->dev), MINOR(__entry->dev), 383 __entry->rgno, 384 __entry->used, 385 __entry->nr_open) 386 ); 387 388 #define DEFINE_ZONE_EVENT(name) \ 389 DEFINE_EVENT(xfs_zone_class, name, \ 390 TP_PROTO(struct xfs_rtgroup *rtg), \ 391 TP_ARGS(rtg)) 392 DEFINE_ZONE_EVENT(xfs_zone_emptied); 393 DEFINE_ZONE_EVENT(xfs_zone_full); 394 DEFINE_ZONE_EVENT(xfs_zone_opened); 395 DEFINE_ZONE_EVENT(xfs_zone_reset); 396 DEFINE_ZONE_EVENT(xfs_zone_gc_target_opened); 397 DEFINE_ZONE_EVENT(xfs_zone_gc_target_stolen); 398 399 TRACE_EVENT(xfs_zone_free_blocks, 400 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rgblock_t rgbno, 401 xfs_extlen_t len), 402 TP_ARGS(rtg, rgbno, len), 403 TP_STRUCT__entry( 404 __field(dev_t, dev) 405 __field(xfs_rgnumber_t, rgno) 406 __field(xfs_rgblock_t, used) 407 __field(xfs_rgblock_t, rgbno) 408 __field(xfs_extlen_t, len) 409 ), 410 TP_fast_assign( 411 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 412 __entry->rgno = rtg_rgno(rtg); 413 __entry->used = rtg_rmap(rtg)->i_used_blocks; 414 __entry->rgbno = rgbno; 415 __entry->len = len; 416 ), 417 TP_printk("dev %d:%d rgno 0x%x used 0x%x rgbno 0x%x len 0x%x", 418 MAJOR(__entry->dev), MINOR(__entry->dev), 419 __entry->rgno, 420 __entry->used, 421 __entry->rgbno, 422 __entry->len) 423 ); 424 425 DECLARE_EVENT_CLASS(xfs_zone_alloc_class, 426 TP_PROTO(struct xfs_open_zone *oz, xfs_rgblock_t rgbno, 427 xfs_extlen_t len), 428 TP_ARGS(oz, rgbno, len), 429 TP_STRUCT__entry( 430 __field(dev_t, dev) 431 __field(xfs_rgnumber_t, rgno) 432 __field(xfs_rgblock_t, used) 433 __field(xfs_rgblock_t, allocated) 434 __field(xfs_rgblock_t, written) 435 __field(xfs_rgblock_t, rgbno) 436 __field(xfs_extlen_t, len) 437 ), 438 TP_fast_assign( 439 __entry->dev = rtg_mount(oz->oz_rtg)->m_super->s_dev; 440 __entry->rgno = rtg_rgno(oz->oz_rtg); 441 __entry->used = rtg_rmap(oz->oz_rtg)->i_used_blocks; 442 __entry->allocated = oz->oz_allocated; 443 __entry->written = oz->oz_written; 444 __entry->rgbno = rgbno; 445 __entry->len = len; 446 ), 447 TP_printk("dev %d:%d rgno 0x%x used 0x%x alloced 0x%x written 0x%x rgbno 0x%x len 0x%x", 448 MAJOR(__entry->dev), MINOR(__entry->dev), 449 __entry->rgno, 450 __entry->used, 451 __entry->allocated, 452 __entry->written, 453 __entry->rgbno, 454 __entry->len) 455 ); 456 457 #define DEFINE_ZONE_ALLOC_EVENT(name) \ 458 DEFINE_EVENT(xfs_zone_alloc_class, name, \ 459 TP_PROTO(struct xfs_open_zone *oz, xfs_rgblock_t rgbno, \ 460 xfs_extlen_t len), \ 461 TP_ARGS(oz, rgbno, len)) 462 DEFINE_ZONE_ALLOC_EVENT(xfs_zone_record_blocks); 463 DEFINE_ZONE_ALLOC_EVENT(xfs_zone_skip_blocks); 464 DEFINE_ZONE_ALLOC_EVENT(xfs_zone_alloc_blocks); 465 DEFINE_ZONE_ALLOC_EVENT(xfs_zone_spurious_open); 466 467 TRACE_EVENT(xfs_zone_gc_select_victim, 468 TP_PROTO(struct xfs_rtgroup *rtg, unsigned int bucket), 469 TP_ARGS(rtg, bucket), 470 TP_STRUCT__entry( 471 __field(dev_t, dev) 472 __field(xfs_rgnumber_t, rgno) 473 __field(xfs_rgblock_t, used) 474 __field(unsigned int, bucket) 475 ), 476 TP_fast_assign( 477 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 478 __entry->rgno = rtg_rgno(rtg); 479 __entry->used = rtg_rmap(rtg)->i_used_blocks; 480 __entry->bucket = bucket; 481 ), 482 TP_printk("dev %d:%d rgno 0x%x used 0x%x bucket %u", 483 MAJOR(__entry->dev), MINOR(__entry->dev), 484 __entry->rgno, 485 __entry->used, 486 __entry->bucket) 487 ); 488 489 TRACE_EVENT(xfs_zones_mount, 490 TP_PROTO(struct xfs_mount *mp), 491 TP_ARGS(mp), 492 TP_STRUCT__entry( 493 __field(dev_t, dev) 494 __field(xfs_rgnumber_t, rgcount) 495 __field(uint32_t, blocks) 496 __field(unsigned int, max_open_zones) 497 ), 498 TP_fast_assign( 499 __entry->dev = mp->m_super->s_dev; 500 __entry->rgcount = mp->m_sb.sb_rgcount; 501 __entry->blocks = mp->m_groups[XG_TYPE_RTG].blocks; 502 __entry->max_open_zones = mp->m_max_open_zones; 503 ), 504 TP_printk("dev %d:%d zoned %u blocks_per_zone %u, max_open %u", 505 MAJOR(__entry->dev), MINOR(__entry->dev), 506 __entry->rgcount, 507 __entry->blocks, 508 __entry->max_open_zones) 509 ); 510 #endif /* CONFIG_XFS_RT */ 511 512 TRACE_EVENT(xfs_inodegc_worker, 513 TP_PROTO(struct xfs_mount *mp, unsigned int shrinker_hits), 514 TP_ARGS(mp, shrinker_hits), 515 TP_STRUCT__entry( 516 __field(dev_t, dev) 517 __field(unsigned int, shrinker_hits) 518 ), 519 TP_fast_assign( 520 __entry->dev = mp->m_super->s_dev; 521 __entry->shrinker_hits = shrinker_hits; 522 ), 523 TP_printk("dev %d:%d shrinker_hits %u", 524 MAJOR(__entry->dev), MINOR(__entry->dev), 525 __entry->shrinker_hits) 526 ); 527 528 DECLARE_EVENT_CLASS(xfs_fs_class, 529 TP_PROTO(struct xfs_mount *mp, void *caller_ip), 530 TP_ARGS(mp, caller_ip), 531 TP_STRUCT__entry( 532 __field(dev_t, dev) 533 __field(unsigned long long, mflags) 534 __field(unsigned long, opstate) 535 __field(unsigned long, sbflags) 536 __field(void *, caller_ip) 537 ), 538 TP_fast_assign( 539 if (mp) { 540 __entry->dev = mp->m_super->s_dev; 541 __entry->mflags = mp->m_features; 542 __entry->opstate = mp->m_opstate; 543 __entry->sbflags = mp->m_super->s_flags; 544 } 545 __entry->caller_ip = caller_ip; 546 ), 547 TP_printk("dev %d:%d m_features 0x%llx opstate (%s) s_flags 0x%lx caller %pS", 548 MAJOR(__entry->dev), MINOR(__entry->dev), 549 __entry->mflags, 550 __print_flags(__entry->opstate, "|", XFS_OPSTATE_STRINGS), 551 __entry->sbflags, 552 __entry->caller_ip) 553 ); 554 555 #define DEFINE_FS_EVENT(name) \ 556 DEFINE_EVENT(xfs_fs_class, name, \ 557 TP_PROTO(struct xfs_mount *mp, void *caller_ip), \ 558 TP_ARGS(mp, caller_ip)) 559 DEFINE_FS_EVENT(xfs_inodegc_flush); 560 DEFINE_FS_EVENT(xfs_inodegc_push); 561 DEFINE_FS_EVENT(xfs_inodegc_start); 562 DEFINE_FS_EVENT(xfs_inodegc_stop); 563 DEFINE_FS_EVENT(xfs_inodegc_queue); 564 DEFINE_FS_EVENT(xfs_inodegc_throttle); 565 DEFINE_FS_EVENT(xfs_fs_sync_fs); 566 DEFINE_FS_EVENT(xfs_blockgc_start); 567 DEFINE_FS_EVENT(xfs_blockgc_stop); 568 DEFINE_FS_EVENT(xfs_blockgc_worker); 569 DEFINE_FS_EVENT(xfs_blockgc_flush_all); 570 571 TRACE_EVENT(xfs_inodegc_shrinker_scan, 572 TP_PROTO(struct xfs_mount *mp, struct shrink_control *sc, 573 void *caller_ip), 574 TP_ARGS(mp, sc, caller_ip), 575 TP_STRUCT__entry( 576 __field(dev_t, dev) 577 __field(unsigned long, nr_to_scan) 578 __field(void *, caller_ip) 579 ), 580 TP_fast_assign( 581 __entry->dev = mp->m_super->s_dev; 582 __entry->nr_to_scan = sc->nr_to_scan; 583 __entry->caller_ip = caller_ip; 584 ), 585 TP_printk("dev %d:%d nr_to_scan %lu caller %pS", 586 MAJOR(__entry->dev), MINOR(__entry->dev), 587 __entry->nr_to_scan, 588 __entry->caller_ip) 589 ); 590 591 DECLARE_EVENT_CLASS(xfs_ag_class, 592 TP_PROTO(const struct xfs_perag *pag), 593 TP_ARGS(pag), 594 TP_STRUCT__entry( 595 __field(dev_t, dev) 596 __field(xfs_agnumber_t, agno) 597 ), 598 TP_fast_assign( 599 __entry->dev = pag_mount(pag)->m_super->s_dev; 600 __entry->agno = pag_agno(pag); 601 ), 602 TP_printk("dev %d:%d agno 0x%x", 603 MAJOR(__entry->dev), MINOR(__entry->dev), 604 __entry->agno) 605 ); 606 #define DEFINE_AG_EVENT(name) \ 607 DEFINE_EVENT(xfs_ag_class, name, \ 608 TP_PROTO(const struct xfs_perag *pag), \ 609 TP_ARGS(pag)) 610 611 DEFINE_AG_EVENT(xfs_read_agf); 612 DEFINE_AG_EVENT(xfs_alloc_read_agf); 613 DEFINE_AG_EVENT(xfs_read_agi); 614 DEFINE_AG_EVENT(xfs_ialloc_read_agi); 615 616 TRACE_EVENT(xfs_attr_list_node_descend, 617 TP_PROTO(struct xfs_attr_list_context *ctx, 618 struct xfs_da_node_entry *btree), 619 TP_ARGS(ctx, btree), 620 TP_STRUCT__entry( 621 __field(dev_t, dev) 622 __field(xfs_ino_t, ino) 623 __field(u32, hashval) 624 __field(u32, blkno) 625 __field(u32, offset) 626 __field(void *, buffer) 627 __field(int, bufsize) 628 __field(int, count) 629 __field(int, firstu) 630 __field(int, dupcnt) 631 __field(unsigned int, attr_filter) 632 __field(u32, bt_hashval) 633 __field(u32, bt_before) 634 ), 635 TP_fast_assign( 636 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; 637 __entry->ino = ctx->dp->i_ino; 638 __entry->hashval = ctx->cursor.hashval; 639 __entry->blkno = ctx->cursor.blkno; 640 __entry->offset = ctx->cursor.offset; 641 __entry->buffer = ctx->buffer; 642 __entry->bufsize = ctx->bufsize; 643 __entry->count = ctx->count; 644 __entry->firstu = ctx->firstu; 645 __entry->attr_filter = ctx->attr_filter; 646 __entry->bt_hashval = be32_to_cpu(btree->hashval); 647 __entry->bt_before = be32_to_cpu(btree->before); 648 ), 649 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " 650 "buffer %p size %u count %u firstu %u filter %s " 651 "node hashval %u, node before %u", 652 MAJOR(__entry->dev), MINOR(__entry->dev), 653 __entry->ino, 654 __entry->hashval, 655 __entry->blkno, 656 __entry->offset, 657 __entry->dupcnt, 658 __entry->buffer, 659 __entry->bufsize, 660 __entry->count, 661 __entry->firstu, 662 __print_flags(__entry->attr_filter, "|", 663 XFS_ATTR_FILTER_FLAGS), 664 __entry->bt_hashval, 665 __entry->bt_before) 666 ); 667 668 DECLARE_EVENT_CLASS(xfs_bmap_class, 669 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state, 670 unsigned long caller_ip), 671 TP_ARGS(ip, cur, state, caller_ip), 672 TP_STRUCT__entry( 673 __field(dev_t, dev) 674 __field(xfs_ino_t, ino) 675 __field(void *, leaf) 676 __field(int, pos) 677 __field(xfs_fileoff_t, startoff) 678 __field(xfs_fsblock_t, startblock) 679 __field(xfs_filblks_t, blockcount) 680 __field(xfs_exntst_t, state) 681 __field(int, bmap_state) 682 __field(unsigned long, caller_ip) 683 ), 684 TP_fast_assign( 685 struct xfs_ifork *ifp; 686 struct xfs_bmbt_irec r; 687 688 ifp = xfs_iext_state_to_fork(ip, state); 689 xfs_iext_get_extent(ifp, cur, &r); 690 __entry->dev = VFS_I(ip)->i_sb->s_dev; 691 __entry->ino = ip->i_ino; 692 __entry->leaf = cur->leaf; 693 __entry->pos = cur->pos; 694 __entry->startoff = r.br_startoff; 695 __entry->startblock = r.br_startblock; 696 __entry->blockcount = r.br_blockcount; 697 __entry->state = r.br_state; 698 __entry->bmap_state = state; 699 __entry->caller_ip = caller_ip; 700 ), 701 TP_printk("dev %d:%d ino 0x%llx state %s cur %p/%d " 702 "fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx flag %d caller %pS", 703 MAJOR(__entry->dev), MINOR(__entry->dev), 704 __entry->ino, 705 __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS), 706 __entry->leaf, 707 __entry->pos, 708 __entry->startoff, 709 (int64_t)__entry->startblock, 710 __entry->blockcount, 711 __entry->state, 712 (char *)__entry->caller_ip) 713 ) 714 715 #define DEFINE_BMAP_EVENT(name) \ 716 DEFINE_EVENT(xfs_bmap_class, name, \ 717 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state, \ 718 unsigned long caller_ip), \ 719 TP_ARGS(ip, cur, state, caller_ip)) 720 DEFINE_BMAP_EVENT(xfs_iext_insert); 721 DEFINE_BMAP_EVENT(xfs_iext_remove); 722 DEFINE_BMAP_EVENT(xfs_bmap_pre_update); 723 DEFINE_BMAP_EVENT(xfs_bmap_post_update); 724 DEFINE_BMAP_EVENT(xfs_read_extent); 725 DEFINE_BMAP_EVENT(xfs_write_extent); 726 727 DECLARE_EVENT_CLASS(xfs_buf_class, 728 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), 729 TP_ARGS(bp, caller_ip), 730 TP_STRUCT__entry( 731 __field(dev_t, dev) 732 __field(xfs_daddr_t, bno) 733 __field(int, nblks) 734 __field(int, hold) 735 __field(int, pincount) 736 __field(unsigned, lockval) 737 __field(unsigned, flags) 738 __field(unsigned long, caller_ip) 739 __field(const void *, buf_ops) 740 ), 741 TP_fast_assign( 742 __entry->dev = bp->b_target->bt_dev; 743 __entry->bno = xfs_buf_daddr(bp); 744 __entry->nblks = bp->b_length; 745 __entry->hold = bp->b_lockref.count; 746 __entry->pincount = atomic_read(&bp->b_pin_count); 747 __entry->lockval = bp->b_sema.count; 748 __entry->flags = bp->b_flags; 749 __entry->caller_ip = caller_ip; 750 __entry->buf_ops = bp->b_ops; 751 ), 752 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 753 "lock %d flags %s bufops %pS caller %pS", 754 MAJOR(__entry->dev), MINOR(__entry->dev), 755 (unsigned long long)__entry->bno, 756 __entry->nblks, 757 __entry->hold, 758 __entry->pincount, 759 __entry->lockval, 760 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 761 __entry->buf_ops, 762 (void *)__entry->caller_ip) 763 ) 764 765 #define DEFINE_BUF_EVENT(name) \ 766 DEFINE_EVENT(xfs_buf_class, name, \ 767 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \ 768 TP_ARGS(bp, caller_ip)) 769 DEFINE_BUF_EVENT(xfs_buf_init); 770 DEFINE_BUF_EVENT(xfs_buf_free); 771 DEFINE_BUF_EVENT(xfs_buf_hold); 772 DEFINE_BUF_EVENT(xfs_buf_rele); 773 DEFINE_BUF_EVENT(xfs_buf_iodone); 774 DEFINE_BUF_EVENT(xfs_buf_submit); 775 DEFINE_BUF_EVENT(xfs_buf_lock); 776 DEFINE_BUF_EVENT(xfs_buf_lock_done); 777 DEFINE_BUF_EVENT(xfs_buf_trylock_fail); 778 DEFINE_BUF_EVENT(xfs_buf_trylock); 779 DEFINE_BUF_EVENT(xfs_buf_unlock); 780 DEFINE_BUF_EVENT(xfs_buf_iowait); 781 DEFINE_BUF_EVENT(xfs_buf_iowait_done); 782 DEFINE_BUF_EVENT(xfs_buf_delwri_queue); 783 DEFINE_BUF_EVENT(xfs_buf_delwri_queued); 784 DEFINE_BUF_EVENT(xfs_buf_delwri_split); 785 DEFINE_BUF_EVENT(xfs_buf_get_uncached); 786 DEFINE_BUF_EVENT(xfs_buf_item_relse); 787 DEFINE_BUF_EVENT(xfs_buf_iodone_async); 788 DEFINE_BUF_EVENT(xfs_buf_error_relse); 789 DEFINE_BUF_EVENT(xfs_buf_drain_buftarg); 790 DEFINE_BUF_EVENT(xfs_trans_read_buf_shut); 791 DEFINE_BUF_EVENT(xfs_buf_backing_folio); 792 DEFINE_BUF_EVENT(xfs_buf_backing_kmem); 793 DEFINE_BUF_EVENT(xfs_buf_backing_vmalloc); 794 DEFINE_BUF_EVENT(xfs_buf_backing_fallback); 795 796 /* not really buffer traces, but the buf provides useful information */ 797 DEFINE_BUF_EVENT(xfs_btree_corrupt); 798 DEFINE_BUF_EVENT(xfs_reset_dqcounts); 799 800 /* pass flags explicitly */ 801 DECLARE_EVENT_CLASS(xfs_buf_flags_class, 802 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), 803 TP_ARGS(bp, flags, caller_ip), 804 TP_STRUCT__entry( 805 __field(dev_t, dev) 806 __field(xfs_daddr_t, bno) 807 __field(unsigned int, length) 808 __field(int, hold) 809 __field(int, pincount) 810 __field(unsigned, lockval) 811 __field(unsigned, flags) 812 __field(unsigned long, caller_ip) 813 ), 814 TP_fast_assign( 815 __entry->dev = bp->b_target->bt_dev; 816 __entry->bno = xfs_buf_daddr(bp); 817 __entry->length = bp->b_length; 818 __entry->flags = flags; 819 __entry->hold = bp->b_lockref.count; 820 __entry->pincount = atomic_read(&bp->b_pin_count); 821 __entry->lockval = bp->b_sema.count; 822 __entry->caller_ip = caller_ip; 823 ), 824 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 825 "lock %d flags %s caller %pS", 826 MAJOR(__entry->dev), MINOR(__entry->dev), 827 (unsigned long long)__entry->bno, 828 __entry->length, 829 __entry->hold, 830 __entry->pincount, 831 __entry->lockval, 832 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 833 (void *)__entry->caller_ip) 834 ) 835 836 #define DEFINE_BUF_FLAGS_EVENT(name) \ 837 DEFINE_EVENT(xfs_buf_flags_class, name, \ 838 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \ 839 TP_ARGS(bp, flags, caller_ip)) 840 DEFINE_BUF_FLAGS_EVENT(xfs_buf_find); 841 DEFINE_BUF_FLAGS_EVENT(xfs_buf_get); 842 DEFINE_BUF_FLAGS_EVENT(xfs_buf_read); 843 DEFINE_BUF_FLAGS_EVENT(xfs_buf_readahead); 844 845 TRACE_EVENT(xfs_buf_ioerror, 846 TP_PROTO(struct xfs_buf *bp, int error, xfs_failaddr_t caller_ip), 847 TP_ARGS(bp, error, caller_ip), 848 TP_STRUCT__entry( 849 __field(dev_t, dev) 850 __field(xfs_daddr_t, bno) 851 __field(unsigned int, length) 852 __field(unsigned, flags) 853 __field(int, hold) 854 __field(int, pincount) 855 __field(unsigned, lockval) 856 __field(int, error) 857 __field(xfs_failaddr_t, caller_ip) 858 ), 859 TP_fast_assign( 860 __entry->dev = bp->b_target->bt_dev; 861 __entry->bno = xfs_buf_daddr(bp); 862 __entry->length = bp->b_length; 863 __entry->hold = bp->b_lockref.count; 864 __entry->pincount = atomic_read(&bp->b_pin_count); 865 __entry->lockval = bp->b_sema.count; 866 __entry->error = error; 867 __entry->flags = bp->b_flags; 868 __entry->caller_ip = caller_ip; 869 ), 870 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 871 "lock %d error %d flags %s caller %pS", 872 MAJOR(__entry->dev), MINOR(__entry->dev), 873 (unsigned long long)__entry->bno, 874 __entry->length, 875 __entry->hold, 876 __entry->pincount, 877 __entry->lockval, 878 __entry->error, 879 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 880 (void *)__entry->caller_ip) 881 ); 882 883 DECLARE_EVENT_CLASS(xfs_buf_item_class, 884 TP_PROTO(struct xfs_buf_log_item *bip), 885 TP_ARGS(bip), 886 TP_STRUCT__entry( 887 __field(dev_t, dev) 888 __field(xfs_daddr_t, buf_bno) 889 __field(unsigned int, buf_len) 890 __field(int, buf_hold) 891 __field(int, buf_pincount) 892 __field(int, buf_lockval) 893 __field(unsigned, buf_flags) 894 __field(unsigned, bli_recur) 895 __field(int, bli_refcount) 896 __field(unsigned, bli_flags) 897 __field(unsigned long, li_flags) 898 ), 899 TP_fast_assign( 900 __entry->dev = bip->bli_buf->b_target->bt_dev; 901 __entry->bli_flags = bip->bli_flags; 902 __entry->bli_recur = bip->bli_recur; 903 __entry->bli_refcount = atomic_read(&bip->bli_refcount); 904 __entry->buf_bno = xfs_buf_daddr(bip->bli_buf); 905 __entry->buf_len = bip->bli_buf->b_length; 906 __entry->buf_flags = bip->bli_buf->b_flags; 907 __entry->buf_hold = bip->bli_buf->b_lockref.count; 908 __entry->buf_pincount = atomic_read(&bip->bli_buf->b_pin_count); 909 __entry->buf_lockval = bip->bli_buf->b_sema.count; 910 __entry->li_flags = bip->bli_item.li_flags; 911 ), 912 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 913 "lock %d flags %s recur %d refcount %d bliflags %s " 914 "liflags %s", 915 MAJOR(__entry->dev), MINOR(__entry->dev), 916 (unsigned long long)__entry->buf_bno, 917 __entry->buf_len, 918 __entry->buf_hold, 919 __entry->buf_pincount, 920 __entry->buf_lockval, 921 __print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS), 922 __entry->bli_recur, 923 __entry->bli_refcount, 924 __print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS), 925 __print_flags(__entry->li_flags, "|", XFS_LI_FLAGS)) 926 ) 927 928 #define DEFINE_BUF_ITEM_EVENT(name) \ 929 DEFINE_EVENT(xfs_buf_item_class, name, \ 930 TP_PROTO(struct xfs_buf_log_item *bip), \ 931 TP_ARGS(bip)) 932 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size); 933 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_ordered); 934 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale); 935 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format); 936 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_stale); 937 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_ordered); 938 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_pin); 939 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin); 940 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin_stale); 941 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_release); 942 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_committed); 943 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_push); 944 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf); 945 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf_recur); 946 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb); 947 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb_recur); 948 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf); 949 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf_recur); 950 DEFINE_BUF_ITEM_EVENT(xfs_trans_log_buf); 951 DEFINE_BUF_ITEM_EVENT(xfs_trans_brelse); 952 DEFINE_BUF_ITEM_EVENT(xfs_trans_bdetach); 953 DEFINE_BUF_ITEM_EVENT(xfs_trans_bjoin); 954 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold); 955 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release); 956 DEFINE_BUF_ITEM_EVENT(xfs_trans_binval); 957 958 DECLARE_EVENT_CLASS(xfs_filestream_class, 959 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino), 960 TP_ARGS(pag, ino), 961 TP_STRUCT__entry( 962 __field(dev_t, dev) 963 __field(xfs_ino_t, ino) 964 __field(xfs_agnumber_t, agno) 965 __field(int, streams) 966 ), 967 TP_fast_assign( 968 __entry->dev = pag_mount(pag)->m_super->s_dev; 969 __entry->ino = ino; 970 __entry->agno = pag_agno(pag); 971 __entry->streams = atomic_read(&pag->pagf_fstrms); 972 ), 973 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d", 974 MAJOR(__entry->dev), MINOR(__entry->dev), 975 __entry->ino, 976 __entry->agno, 977 __entry->streams) 978 ) 979 #define DEFINE_FILESTREAM_EVENT(name) \ 980 DEFINE_EVENT(xfs_filestream_class, name, \ 981 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino), \ 982 TP_ARGS(pag, ino)) 983 DEFINE_FILESTREAM_EVENT(xfs_filestream_free); 984 DEFINE_FILESTREAM_EVENT(xfs_filestream_lookup); 985 DEFINE_FILESTREAM_EVENT(xfs_filestream_scan); 986 987 TRACE_EVENT(xfs_filestream_pick, 988 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino), 989 TP_ARGS(pag, ino), 990 TP_STRUCT__entry( 991 __field(dev_t, dev) 992 __field(xfs_ino_t, ino) 993 __field(xfs_agnumber_t, agno) 994 __field(int, streams) 995 __field(xfs_extlen_t, free) 996 ), 997 TP_fast_assign( 998 __entry->dev = pag_mount(pag)->m_super->s_dev; 999 __entry->ino = ino; 1000 __entry->agno = pag_agno(pag); 1001 __entry->streams = atomic_read(&pag->pagf_fstrms); 1002 __entry->free = pag->pagf_freeblks; 1003 ), 1004 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d free %d", 1005 MAJOR(__entry->dev), MINOR(__entry->dev), 1006 __entry->ino, 1007 __entry->agno, 1008 __entry->streams, 1009 __entry->free) 1010 ); 1011 1012 DECLARE_EVENT_CLASS(xfs_lock_class, 1013 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, 1014 unsigned long caller_ip), 1015 TP_ARGS(ip, lock_flags, caller_ip), 1016 TP_STRUCT__entry( 1017 __field(dev_t, dev) 1018 __field(xfs_ino_t, ino) 1019 __field(int, lock_flags) 1020 __field(unsigned long, caller_ip) 1021 ), 1022 TP_fast_assign( 1023 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1024 __entry->ino = ip->i_ino; 1025 __entry->lock_flags = lock_flags; 1026 __entry->caller_ip = caller_ip; 1027 ), 1028 TP_printk("dev %d:%d ino 0x%llx flags %s caller %pS", 1029 MAJOR(__entry->dev), MINOR(__entry->dev), 1030 __entry->ino, 1031 __print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS), 1032 (void *)__entry->caller_ip) 1033 ) 1034 1035 #define DEFINE_LOCK_EVENT(name) \ 1036 DEFINE_EVENT(xfs_lock_class, name, \ 1037 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \ 1038 unsigned long caller_ip), \ 1039 TP_ARGS(ip, lock_flags, caller_ip)) 1040 DEFINE_LOCK_EVENT(xfs_ilock); 1041 DEFINE_LOCK_EVENT(xfs_ilock_nowait); 1042 DEFINE_LOCK_EVENT(xfs_ilock_demote); 1043 DEFINE_LOCK_EVENT(xfs_iunlock); 1044 1045 DECLARE_EVENT_CLASS(xfs_inode_class, 1046 TP_PROTO(struct xfs_inode *ip), 1047 TP_ARGS(ip), 1048 TP_STRUCT__entry( 1049 __field(dev_t, dev) 1050 __field(xfs_ino_t, ino) 1051 __field(unsigned long, iflags) 1052 ), 1053 TP_fast_assign( 1054 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1055 __entry->ino = ip->i_ino; 1056 __entry->iflags = ip->i_flags; 1057 ), 1058 TP_printk("dev %d:%d ino 0x%llx iflags 0x%lx", 1059 MAJOR(__entry->dev), MINOR(__entry->dev), 1060 __entry->ino, 1061 __entry->iflags) 1062 ) 1063 1064 #define DEFINE_INODE_EVENT(name) \ 1065 DEFINE_EVENT(xfs_inode_class, name, \ 1066 TP_PROTO(struct xfs_inode *ip), \ 1067 TP_ARGS(ip)) 1068 DEFINE_INODE_EVENT(xfs_iget_skip); 1069 DEFINE_INODE_EVENT(xfs_iget_recycle); 1070 DEFINE_INODE_EVENT(xfs_iget_recycle_fail); 1071 DEFINE_INODE_EVENT(xfs_iget_hit); 1072 DEFINE_INODE_EVENT(xfs_iget_miss); 1073 1074 DEFINE_INODE_EVENT(xfs_getattr); 1075 DEFINE_INODE_EVENT(xfs_setattr); 1076 DEFINE_INODE_EVENT(xfs_readlink); 1077 DEFINE_INODE_EVENT(xfs_inactive_symlink); 1078 DEFINE_INODE_EVENT(xfs_alloc_file_space); 1079 DEFINE_INODE_EVENT(xfs_free_file_space); 1080 DEFINE_INODE_EVENT(xfs_zero_file_space); 1081 DEFINE_INODE_EVENT(xfs_collapse_file_space); 1082 DEFINE_INODE_EVENT(xfs_insert_file_space); 1083 DEFINE_INODE_EVENT(xfs_readdir); 1084 #ifdef CONFIG_XFS_POSIX_ACL 1085 DEFINE_INODE_EVENT(xfs_get_acl); 1086 #endif 1087 DEFINE_INODE_EVENT(xfs_vm_bmap); 1088 DEFINE_INODE_EVENT(xfs_file_ioctl); 1089 #ifdef CONFIG_COMPAT 1090 DEFINE_INODE_EVENT(xfs_file_compat_ioctl); 1091 #endif 1092 DEFINE_INODE_EVENT(xfs_ioctl_setattr); 1093 DEFINE_INODE_EVENT(xfs_dir_fsync); 1094 DEFINE_INODE_EVENT(xfs_file_fsync); 1095 DEFINE_INODE_EVENT(xfs_destroy_inode); 1096 DEFINE_INODE_EVENT(xfs_update_time); 1097 1098 DEFINE_INODE_EVENT(xfs_dquot_dqalloc); 1099 DEFINE_INODE_EVENT(xfs_dquot_dqdetach); 1100 1101 DEFINE_INODE_EVENT(xfs_inode_set_eofblocks_tag); 1102 DEFINE_INODE_EVENT(xfs_inode_clear_eofblocks_tag); 1103 DEFINE_INODE_EVENT(xfs_inode_free_eofblocks_invalid); 1104 DEFINE_INODE_EVENT(xfs_inode_set_cowblocks_tag); 1105 DEFINE_INODE_EVENT(xfs_inode_clear_cowblocks_tag); 1106 DEFINE_INODE_EVENT(xfs_inode_free_cowblocks_invalid); 1107 DEFINE_INODE_EVENT(xfs_inode_set_reclaimable); 1108 DEFINE_INODE_EVENT(xfs_inode_reclaiming); 1109 DEFINE_INODE_EVENT(xfs_inode_set_need_inactive); 1110 DEFINE_INODE_EVENT(xfs_inode_inactivating); 1111 1112 /* 1113 * ftrace's __print_symbolic requires that all enum values be wrapped in the 1114 * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace 1115 * ring buffer. Somehow this was only worth mentioning in the ftrace sample 1116 * code. 1117 */ 1118 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED); 1119 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW); 1120 1121 DECLARE_EVENT_CLASS(xfs_fault_class, 1122 TP_PROTO(struct xfs_inode *ip, unsigned int order), 1123 TP_ARGS(ip, order), 1124 TP_STRUCT__entry( 1125 __field(dev_t, dev) 1126 __field(xfs_ino_t, ino) 1127 __field(unsigned int, order) 1128 ), 1129 TP_fast_assign( 1130 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1131 __entry->ino = ip->i_ino; 1132 __entry->order = order; 1133 ), 1134 TP_printk("dev %d:%d ino 0x%llx order %u", 1135 MAJOR(__entry->dev), MINOR(__entry->dev), 1136 __entry->ino, 1137 __entry->order) 1138 ) 1139 1140 #define DEFINE_FAULT_EVENT(name) \ 1141 DEFINE_EVENT(xfs_fault_class, name, \ 1142 TP_PROTO(struct xfs_inode *ip, unsigned int order), \ 1143 TP_ARGS(ip, order)) 1144 DEFINE_FAULT_EVENT(xfs_read_fault); 1145 DEFINE_FAULT_EVENT(xfs_write_fault); 1146 1147 DECLARE_EVENT_CLASS(xfs_iref_class, 1148 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), 1149 TP_ARGS(ip, caller_ip), 1150 TP_STRUCT__entry( 1151 __field(dev_t, dev) 1152 __field(xfs_ino_t, ino) 1153 __field(int, count) 1154 __field(int, pincount) 1155 __field(unsigned long, iflags) 1156 __field(unsigned long, caller_ip) 1157 ), 1158 TP_fast_assign( 1159 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1160 __entry->ino = ip->i_ino; 1161 __entry->count = icount_read(VFS_I(ip)); 1162 __entry->pincount = atomic_read(&ip->i_pincount); 1163 __entry->iflags = ip->i_flags; 1164 __entry->caller_ip = caller_ip; 1165 ), 1166 TP_printk("dev %d:%d ino 0x%llx count %d pincount %d iflags 0x%lx caller %pS", 1167 MAJOR(__entry->dev), MINOR(__entry->dev), 1168 __entry->ino, 1169 __entry->count, 1170 __entry->pincount, 1171 __entry->iflags, 1172 (char *)__entry->caller_ip) 1173 ) 1174 1175 TRACE_EVENT(xfs_iomap_prealloc_size, 1176 TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t blocks, int shift, 1177 unsigned int writeio_blocks), 1178 TP_ARGS(ip, blocks, shift, writeio_blocks), 1179 TP_STRUCT__entry( 1180 __field(dev_t, dev) 1181 __field(xfs_ino_t, ino) 1182 __field(xfs_fsblock_t, blocks) 1183 __field(int, shift) 1184 __field(unsigned int, writeio_blocks) 1185 ), 1186 TP_fast_assign( 1187 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1188 __entry->ino = ip->i_ino; 1189 __entry->blocks = blocks; 1190 __entry->shift = shift; 1191 __entry->writeio_blocks = writeio_blocks; 1192 ), 1193 TP_printk("dev %d:%d ino 0x%llx prealloc blocks %llu shift %d " 1194 "m_allocsize_blocks %u", 1195 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, 1196 __entry->blocks, __entry->shift, __entry->writeio_blocks) 1197 ) 1198 1199 TRACE_EVENT(xfs_irec_merge_pre, 1200 TP_PROTO(const struct xfs_perag *pag, 1201 const struct xfs_inobt_rec_incore *rec, 1202 const struct xfs_inobt_rec_incore *nrec), 1203 TP_ARGS(pag, rec, nrec), 1204 TP_STRUCT__entry( 1205 __field(dev_t, dev) 1206 __field(xfs_agnumber_t, agno) 1207 __field(xfs_agino_t, agino) 1208 __field(uint16_t, holemask) 1209 __field(xfs_agino_t, nagino) 1210 __field(uint16_t, nholemask) 1211 ), 1212 TP_fast_assign( 1213 __entry->dev = pag_mount(pag)->m_super->s_dev; 1214 __entry->agno = pag_agno(pag); 1215 __entry->agino = rec->ir_startino; 1216 __entry->holemask = rec->ir_holemask; 1217 __entry->nagino = nrec->ir_startino; 1218 __entry->nholemask = nrec->ir_holemask; 1219 ), 1220 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x new_agino 0x%x new_holemask 0x%x", 1221 MAJOR(__entry->dev), MINOR(__entry->dev), 1222 __entry->agno, 1223 __entry->agino, 1224 __entry->holemask, 1225 __entry->nagino, 1226 __entry->nholemask) 1227 ) 1228 1229 TRACE_EVENT(xfs_irec_merge_post, 1230 TP_PROTO(const struct xfs_perag *pag, 1231 const struct xfs_inobt_rec_incore *nrec), 1232 TP_ARGS(pag, nrec), 1233 TP_STRUCT__entry( 1234 __field(dev_t, dev) 1235 __field(xfs_agnumber_t, agno) 1236 __field(xfs_agino_t, agino) 1237 __field(uint16_t, holemask) 1238 ), 1239 TP_fast_assign( 1240 __entry->dev = pag_mount(pag)->m_super->s_dev; 1241 __entry->agno = pag_agno(pag); 1242 __entry->agino = nrec->ir_startino; 1243 __entry->holemask = nrec->ir_holemask; 1244 ), 1245 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x", 1246 MAJOR(__entry->dev), 1247 MINOR(__entry->dev), 1248 __entry->agno, 1249 __entry->agino, 1250 __entry->holemask) 1251 ) 1252 1253 #define DEFINE_IREF_EVENT(name) \ 1254 DEFINE_EVENT(xfs_iref_class, name, \ 1255 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \ 1256 TP_ARGS(ip, caller_ip)) 1257 DEFINE_IREF_EVENT(xfs_irele); 1258 DEFINE_IREF_EVENT(xfs_inode_pin); 1259 DEFINE_IREF_EVENT(xfs_inode_unpin); 1260 DEFINE_IREF_EVENT(xfs_inode_unpin_nowait); 1261 DEFINE_IREF_EVENT(xfs_inode_push_pinned); 1262 DEFINE_IREF_EVENT(xfs_inode_push_stale); 1263 1264 DECLARE_EVENT_CLASS(xfs_namespace_class, 1265 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name), 1266 TP_ARGS(dp, name), 1267 TP_STRUCT__entry( 1268 __field(dev_t, dev) 1269 __field(xfs_ino_t, dp_ino) 1270 __field(int, namelen) 1271 __dynamic_array(char, name, name->len) 1272 ), 1273 TP_fast_assign( 1274 __entry->dev = VFS_I(dp)->i_sb->s_dev; 1275 __entry->dp_ino = dp->i_ino; 1276 __entry->namelen = name->len; 1277 memcpy(__get_str(name), name->name, name->len); 1278 ), 1279 TP_printk("dev %d:%d dp ino 0x%llx name %.*s", 1280 MAJOR(__entry->dev), MINOR(__entry->dev), 1281 __entry->dp_ino, 1282 __entry->namelen, 1283 __get_str(name)) 1284 ) 1285 1286 #define DEFINE_NAMESPACE_EVENT(name) \ 1287 DEFINE_EVENT(xfs_namespace_class, name, \ 1288 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name), \ 1289 TP_ARGS(dp, name)) 1290 DEFINE_NAMESPACE_EVENT(xfs_remove); 1291 DEFINE_NAMESPACE_EVENT(xfs_link); 1292 DEFINE_NAMESPACE_EVENT(xfs_lookup); 1293 DEFINE_NAMESPACE_EVENT(xfs_create); 1294 DEFINE_NAMESPACE_EVENT(xfs_symlink); 1295 1296 TRACE_EVENT(xfs_rename, 1297 TP_PROTO(struct xfs_inode *src_dp, struct xfs_inode *target_dp, 1298 struct xfs_name *src_name, struct xfs_name *target_name), 1299 TP_ARGS(src_dp, target_dp, src_name, target_name), 1300 TP_STRUCT__entry( 1301 __field(dev_t, dev) 1302 __field(xfs_ino_t, src_dp_ino) 1303 __field(xfs_ino_t, target_dp_ino) 1304 __field(int, src_namelen) 1305 __field(int, target_namelen) 1306 __dynamic_array(char, src_name, src_name->len) 1307 __dynamic_array(char, target_name, target_name->len) 1308 ), 1309 TP_fast_assign( 1310 __entry->dev = VFS_I(src_dp)->i_sb->s_dev; 1311 __entry->src_dp_ino = src_dp->i_ino; 1312 __entry->target_dp_ino = target_dp->i_ino; 1313 __entry->src_namelen = src_name->len; 1314 __entry->target_namelen = target_name->len; 1315 memcpy(__get_str(src_name), src_name->name, src_name->len); 1316 memcpy(__get_str(target_name), target_name->name, 1317 target_name->len); 1318 ), 1319 TP_printk("dev %d:%d src dp ino 0x%llx target dp ino 0x%llx" 1320 " src name %.*s target name %.*s", 1321 MAJOR(__entry->dev), MINOR(__entry->dev), 1322 __entry->src_dp_ino, 1323 __entry->target_dp_ino, 1324 __entry->src_namelen, 1325 __get_str(src_name), 1326 __entry->target_namelen, 1327 __get_str(target_name)) 1328 ) 1329 1330 DECLARE_EVENT_CLASS(xfs_dquot_class, 1331 TP_PROTO(struct xfs_dquot *dqp), 1332 TP_ARGS(dqp), 1333 TP_STRUCT__entry( 1334 __field(dev_t, dev) 1335 __field(u32, id) 1336 __field(xfs_dqtype_t, type) 1337 __field(unsigned, flags) 1338 __field(unsigned, nrefs) 1339 __field(unsigned long long, res_bcount) 1340 __field(unsigned long long, res_rtbcount) 1341 __field(unsigned long long, res_icount) 1342 1343 __field(unsigned long long, bcount) 1344 __field(unsigned long long, rtbcount) 1345 __field(unsigned long long, icount) 1346 1347 __field(unsigned long long, blk_hardlimit) 1348 __field(unsigned long long, blk_softlimit) 1349 __field(unsigned long long, rtb_hardlimit) 1350 __field(unsigned long long, rtb_softlimit) 1351 __field(unsigned long long, ino_hardlimit) 1352 __field(unsigned long long, ino_softlimit) 1353 ), 1354 TP_fast_assign( 1355 __entry->dev = dqp->q_mount->m_super->s_dev; 1356 __entry->id = dqp->q_id; 1357 __entry->type = dqp->q_type; 1358 __entry->flags = dqp->q_flags; 1359 __entry->nrefs = data_race(dqp->q_lockref.count); 1360 1361 __entry->res_bcount = dqp->q_blk.reserved; 1362 __entry->res_rtbcount = dqp->q_rtb.reserved; 1363 __entry->res_icount = dqp->q_ino.reserved; 1364 1365 __entry->bcount = dqp->q_blk.count; 1366 __entry->rtbcount = dqp->q_rtb.count; 1367 __entry->icount = dqp->q_ino.count; 1368 1369 __entry->blk_hardlimit = dqp->q_blk.hardlimit; 1370 __entry->blk_softlimit = dqp->q_blk.softlimit; 1371 __entry->rtb_hardlimit = dqp->q_rtb.hardlimit; 1372 __entry->rtb_softlimit = dqp->q_rtb.softlimit; 1373 __entry->ino_hardlimit = dqp->q_ino.hardlimit; 1374 __entry->ino_softlimit = dqp->q_ino.softlimit; 1375 ), 1376 TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u " 1377 "res_bc 0x%llx res_rtbc 0x%llx res_ic 0x%llx " 1378 "bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx " 1379 "rtbcnt 0x%llx rtbhardlimit 0x%llx rtbsoftlimit 0x%llx " 1380 "icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]", 1381 MAJOR(__entry->dev), MINOR(__entry->dev), 1382 __entry->id, 1383 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1384 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1385 __entry->nrefs, 1386 __entry->res_bcount, 1387 __entry->res_rtbcount, 1388 __entry->res_icount, 1389 __entry->bcount, 1390 __entry->blk_hardlimit, 1391 __entry->blk_softlimit, 1392 __entry->rtbcount, 1393 __entry->rtb_hardlimit, 1394 __entry->rtb_softlimit, 1395 __entry->icount, 1396 __entry->ino_hardlimit, 1397 __entry->ino_softlimit) 1398 ) 1399 1400 #define DEFINE_DQUOT_EVENT(name) \ 1401 DEFINE_EVENT(xfs_dquot_class, name, \ 1402 TP_PROTO(struct xfs_dquot *dqp), \ 1403 TP_ARGS(dqp)) 1404 DEFINE_DQUOT_EVENT(xfs_dqadjust); 1405 DEFINE_DQUOT_EVENT(xfs_dqreclaim_want); 1406 DEFINE_DQUOT_EVENT(xfs_dqreclaim_busy); 1407 DEFINE_DQUOT_EVENT(xfs_dqreclaim_done); 1408 DEFINE_DQUOT_EVENT(xfs_dqattach_get); 1409 DEFINE_DQUOT_EVENT(xfs_dqalloc); 1410 DEFINE_DQUOT_EVENT(xfs_dqtobp_read); 1411 DEFINE_DQUOT_EVENT(xfs_dqread); 1412 DEFINE_DQUOT_EVENT(xfs_dqread_fail); 1413 DEFINE_DQUOT_EVENT(xfs_dqget_hit); 1414 DEFINE_DQUOT_EVENT(xfs_dqget_miss); 1415 DEFINE_DQUOT_EVENT(xfs_dqget_freeing); 1416 DEFINE_DQUOT_EVENT(xfs_dqget_dup); 1417 DEFINE_DQUOT_EVENT(xfs_dqrele); 1418 DEFINE_DQUOT_EVENT(xfs_dqrele_free); 1419 DEFINE_DQUOT_EVENT(xfs_dqflush); 1420 DEFINE_DQUOT_EVENT(xfs_dqflush_force); 1421 DEFINE_DQUOT_EVENT(xfs_dqflush_done); 1422 DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_before); 1423 DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_after); 1424 1425 TRACE_EVENT(xfs_trans_mod_dquot, 1426 TP_PROTO(struct xfs_trans *tp, struct xfs_dquot *dqp, 1427 unsigned int field, int64_t delta), 1428 TP_ARGS(tp, dqp, field, delta), 1429 TP_STRUCT__entry( 1430 __field(dev_t, dev) 1431 __field(xfs_dqtype_t, type) 1432 __field(unsigned int, flags) 1433 __field(unsigned int, dqid) 1434 __field(unsigned int, field) 1435 __field(int64_t, delta) 1436 ), 1437 TP_fast_assign( 1438 __entry->dev = tp->t_mountp->m_super->s_dev; 1439 __entry->type = dqp->q_type; 1440 __entry->flags = dqp->q_flags; 1441 __entry->dqid = dqp->q_id; 1442 __entry->field = field; 1443 __entry->delta = delta; 1444 ), 1445 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s field %s delta %lld", 1446 MAJOR(__entry->dev), MINOR(__entry->dev), 1447 __entry->dqid, 1448 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1449 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1450 __print_flags(__entry->field, "|", XFS_QMOPT_FLAGS), 1451 __entry->delta) 1452 ); 1453 1454 DECLARE_EVENT_CLASS(xfs_dqtrx_class, 1455 TP_PROTO(struct xfs_dqtrx *qtrx), 1456 TP_ARGS(qtrx), 1457 TP_STRUCT__entry( 1458 __field(dev_t, dev) 1459 __field(xfs_dqtype_t, type) 1460 __field(unsigned int, flags) 1461 __field(u32, dqid) 1462 1463 __field(uint64_t, blk_res) 1464 __field(int64_t, bcount_delta) 1465 __field(int64_t, delbcnt_delta) 1466 1467 __field(uint64_t, rtblk_res) 1468 __field(uint64_t, rtblk_res_used) 1469 __field(int64_t, rtbcount_delta) 1470 __field(int64_t, delrtb_delta) 1471 1472 __field(uint64_t, ino_res) 1473 __field(uint64_t, ino_res_used) 1474 __field(int64_t, icount_delta) 1475 ), 1476 TP_fast_assign( 1477 __entry->dev = qtrx->qt_dquot->q_mount->m_super->s_dev; 1478 __entry->type = qtrx->qt_dquot->q_type; 1479 __entry->flags = qtrx->qt_dquot->q_flags; 1480 __entry->dqid = qtrx->qt_dquot->q_id; 1481 1482 __entry->blk_res = qtrx->qt_blk_res; 1483 __entry->bcount_delta = qtrx->qt_bcount_delta; 1484 __entry->delbcnt_delta = qtrx->qt_delbcnt_delta; 1485 1486 __entry->rtblk_res = qtrx->qt_rtblk_res; 1487 __entry->rtblk_res_used = qtrx->qt_rtblk_res_used; 1488 __entry->rtbcount_delta = qtrx->qt_rtbcount_delta; 1489 __entry->delrtb_delta = qtrx->qt_delrtb_delta; 1490 1491 __entry->ino_res = qtrx->qt_ino_res; 1492 __entry->ino_res_used = qtrx->qt_ino_res_used; 1493 __entry->icount_delta = qtrx->qt_icount_delta; 1494 ), 1495 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s " 1496 "blk_res %llu bcount_delta %lld delbcnt_delta %lld " 1497 "rtblk_res %llu rtblk_res_used %llu rtbcount_delta %lld delrtb_delta %lld " 1498 "ino_res %llu ino_res_used %llu icount_delta %lld", 1499 MAJOR(__entry->dev), MINOR(__entry->dev), 1500 __entry->dqid, 1501 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1502 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1503 1504 __entry->blk_res, 1505 __entry->bcount_delta, 1506 __entry->delbcnt_delta, 1507 1508 __entry->rtblk_res, 1509 __entry->rtblk_res_used, 1510 __entry->rtbcount_delta, 1511 __entry->delrtb_delta, 1512 1513 __entry->ino_res, 1514 __entry->ino_res_used, 1515 __entry->icount_delta) 1516 ) 1517 1518 #define DEFINE_DQTRX_EVENT(name) \ 1519 DEFINE_EVENT(xfs_dqtrx_class, name, \ 1520 TP_PROTO(struct xfs_dqtrx *qtrx), \ 1521 TP_ARGS(qtrx)) 1522 DEFINE_DQTRX_EVENT(xfs_trans_apply_dquot_deltas); 1523 DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_before); 1524 DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_after); 1525 1526 DECLARE_EVENT_CLASS(xfs_loggrant_class, 1527 TP_PROTO(struct xlog *log, struct xlog_ticket *tic), 1528 TP_ARGS(log, tic), 1529 TP_STRUCT__entry( 1530 __field(dev_t, dev) 1531 __field(unsigned long, tic) 1532 __field(char, ocnt) 1533 __field(char, cnt) 1534 __field(int, curr_res) 1535 __field(int, unit_res) 1536 __field(unsigned int, flags) 1537 __field(int, reserveq) 1538 __field(int, writeq) 1539 __field(uint64_t, grant_reserve_bytes) 1540 __field(uint64_t, grant_write_bytes) 1541 __field(uint64_t, tail_space) 1542 __field(int, curr_cycle) 1543 __field(int, curr_block) 1544 __field(xfs_lsn_t, tail_lsn) 1545 ), 1546 TP_fast_assign( 1547 __entry->dev = log->l_mp->m_super->s_dev; 1548 __entry->tic = (unsigned long)tic; 1549 __entry->ocnt = tic->t_ocnt; 1550 __entry->cnt = tic->t_cnt; 1551 __entry->curr_res = tic->t_curr_res; 1552 __entry->unit_res = tic->t_unit_res; 1553 __entry->flags = tic->t_flags; 1554 __entry->reserveq = list_empty(&log->l_reserve_head.waiters); 1555 __entry->writeq = list_empty(&log->l_write_head.waiters); 1556 __entry->tail_space = READ_ONCE(log->l_tail_space); 1557 __entry->grant_reserve_bytes = __entry->tail_space + 1558 atomic64_read(&log->l_reserve_head.grant); 1559 __entry->grant_write_bytes = __entry->tail_space + 1560 atomic64_read(&log->l_write_head.grant); 1561 __entry->curr_cycle = log->l_curr_cycle; 1562 __entry->curr_block = log->l_curr_block; 1563 __entry->tail_lsn = atomic64_read(&log->l_tail_lsn); 1564 ), 1565 TP_printk("dev %d:%d tic 0x%lx t_ocnt %u t_cnt %u t_curr_res %u " 1566 "t_unit_res %u t_flags %s reserveq %s writeq %s " 1567 "tail space %llu grant_reserve_bytes %llu " 1568 "grant_write_bytes %llu curr_cycle %d curr_block %d " 1569 "tail_cycle %d tail_block %d", 1570 MAJOR(__entry->dev), MINOR(__entry->dev), 1571 __entry->tic, 1572 __entry->ocnt, 1573 __entry->cnt, 1574 __entry->curr_res, 1575 __entry->unit_res, 1576 __print_flags(__entry->flags, "|", XLOG_TIC_FLAGS), 1577 __entry->reserveq ? "empty" : "active", 1578 __entry->writeq ? "empty" : "active", 1579 __entry->tail_space, 1580 __entry->grant_reserve_bytes, 1581 __entry->grant_write_bytes, 1582 __entry->curr_cycle, 1583 __entry->curr_block, 1584 CYCLE_LSN(__entry->tail_lsn), 1585 BLOCK_LSN(__entry->tail_lsn) 1586 ) 1587 ) 1588 1589 #define DEFINE_LOGGRANT_EVENT(name) \ 1590 DEFINE_EVENT(xfs_loggrant_class, name, \ 1591 TP_PROTO(struct xlog *log, struct xlog_ticket *tic), \ 1592 TP_ARGS(log, tic)) 1593 DEFINE_LOGGRANT_EVENT(xfs_log_umount_write); 1594 DEFINE_LOGGRANT_EVENT(xfs_log_grant_sleep); 1595 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake); 1596 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake_up); 1597 DEFINE_LOGGRANT_EVENT(xfs_log_reserve); 1598 DEFINE_LOGGRANT_EVENT(xfs_log_reserve_exit); 1599 DEFINE_LOGGRANT_EVENT(xfs_log_regrant); 1600 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_exit); 1601 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant); 1602 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_exit); 1603 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_sub); 1604 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant); 1605 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_sub); 1606 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_exit); 1607 DEFINE_LOGGRANT_EVENT(xfs_log_cil_wait); 1608 1609 DECLARE_EVENT_CLASS(xfs_log_item_class, 1610 TP_PROTO(struct xfs_log_item *lip), 1611 TP_ARGS(lip), 1612 TP_STRUCT__entry( 1613 __field(dev_t, dev) 1614 __field(void *, lip) 1615 __field(uint, type) 1616 __field(unsigned long, flags) 1617 __field(xfs_lsn_t, lsn) 1618 ), 1619 TP_fast_assign( 1620 __entry->dev = lip->li_log->l_mp->m_super->s_dev; 1621 __entry->lip = lip; 1622 __entry->type = lip->li_type; 1623 __entry->flags = lip->li_flags; 1624 __entry->lsn = lip->li_lsn; 1625 ), 1626 TP_printk("dev %d:%d lip %p lsn %d/%d type %s flags %s", 1627 MAJOR(__entry->dev), MINOR(__entry->dev), 1628 __entry->lip, 1629 CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn), 1630 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1631 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1632 ) 1633 1634 TRACE_EVENT(xfs_log_force, 1635 TP_PROTO(struct xfs_mount *mp, xfs_lsn_t lsn, unsigned long caller_ip), 1636 TP_ARGS(mp, lsn, caller_ip), 1637 TP_STRUCT__entry( 1638 __field(dev_t, dev) 1639 __field(xfs_lsn_t, lsn) 1640 __field(unsigned long, caller_ip) 1641 ), 1642 TP_fast_assign( 1643 __entry->dev = mp->m_super->s_dev; 1644 __entry->lsn = lsn; 1645 __entry->caller_ip = caller_ip; 1646 ), 1647 TP_printk("dev %d:%d lsn 0x%llx caller %pS", 1648 MAJOR(__entry->dev), MINOR(__entry->dev), 1649 __entry->lsn, (void *)__entry->caller_ip) 1650 ) 1651 1652 #define DEFINE_LOG_ITEM_EVENT(name) \ 1653 DEFINE_EVENT(xfs_log_item_class, name, \ 1654 TP_PROTO(struct xfs_log_item *lip), \ 1655 TP_ARGS(lip)) 1656 DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_mark); 1657 DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_skip); 1658 DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_unpin); 1659 DEFINE_LOG_ITEM_EVENT(xlog_ail_insert_abort); 1660 DEFINE_LOG_ITEM_EVENT(xfs_trans_free_abort); 1661 1662 DECLARE_EVENT_CLASS(xfs_ail_push_class, 1663 TP_PROTO(struct xfs_ail *ailp, uint type, unsigned long flags, xfs_lsn_t lsn), 1664 TP_ARGS(ailp, type, flags, lsn), 1665 TP_STRUCT__entry( 1666 __field(dev_t, dev) 1667 __field(uint, type) 1668 __field(unsigned long, flags) 1669 __field(xfs_lsn_t, lsn) 1670 ), 1671 TP_fast_assign( 1672 __entry->dev = ailp->ail_log->l_mp->m_super->s_dev; 1673 __entry->type = type; 1674 __entry->flags = flags; 1675 __entry->lsn = lsn; 1676 ), 1677 TP_printk("dev %d:%d lsn %d/%d type %s flags %s", 1678 MAJOR(__entry->dev), MINOR(__entry->dev), 1679 CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn), 1680 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1681 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1682 ) 1683 1684 #define DEFINE_AIL_PUSH_EVENT(name) \ 1685 DEFINE_EVENT(xfs_ail_push_class, name, \ 1686 TP_PROTO(struct xfs_ail *ailp, uint type, unsigned long flags, xfs_lsn_t lsn), \ 1687 TP_ARGS(ailp, type, flags, lsn)) 1688 DEFINE_AIL_PUSH_EVENT(xfs_ail_push); 1689 DEFINE_AIL_PUSH_EVENT(xfs_ail_pinned); 1690 DEFINE_AIL_PUSH_EVENT(xfs_ail_locked); 1691 DEFINE_AIL_PUSH_EVENT(xfs_ail_flushing); 1692 1693 DECLARE_EVENT_CLASS(xfs_ail_class, 1694 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), 1695 TP_ARGS(lip, old_lsn, new_lsn), 1696 TP_STRUCT__entry( 1697 __field(dev_t, dev) 1698 __field(void *, lip) 1699 __field(uint, type) 1700 __field(unsigned long, flags) 1701 __field(xfs_lsn_t, old_lsn) 1702 __field(xfs_lsn_t, new_lsn) 1703 ), 1704 TP_fast_assign( 1705 __entry->dev = lip->li_log->l_mp->m_super->s_dev; 1706 __entry->lip = lip; 1707 __entry->type = lip->li_type; 1708 __entry->flags = lip->li_flags; 1709 __entry->old_lsn = old_lsn; 1710 __entry->new_lsn = new_lsn; 1711 ), 1712 TP_printk("dev %d:%d lip %p old lsn %d/%d new lsn %d/%d type %s flags %s", 1713 MAJOR(__entry->dev), MINOR(__entry->dev), 1714 __entry->lip, 1715 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn), 1716 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn), 1717 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1718 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1719 ) 1720 1721 #define DEFINE_AIL_EVENT(name) \ 1722 DEFINE_EVENT(xfs_ail_class, name, \ 1723 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), \ 1724 TP_ARGS(lip, old_lsn, new_lsn)) 1725 DEFINE_AIL_EVENT(xfs_ail_insert); 1726 DEFINE_AIL_EVENT(xfs_ail_move); 1727 DEFINE_AIL_EVENT(xfs_ail_delete); 1728 1729 TRACE_EVENT(xfs_log_assign_tail_lsn, 1730 TP_PROTO(struct xlog *log, xfs_lsn_t new_lsn), 1731 TP_ARGS(log, new_lsn), 1732 TP_STRUCT__entry( 1733 __field(dev_t, dev) 1734 __field(xfs_lsn_t, new_lsn) 1735 __field(xfs_lsn_t, old_lsn) 1736 __field(xfs_lsn_t, head_lsn) 1737 ), 1738 TP_fast_assign( 1739 __entry->dev = log->l_mp->m_super->s_dev; 1740 __entry->new_lsn = new_lsn; 1741 __entry->old_lsn = atomic64_read(&log->l_tail_lsn); 1742 __entry->head_lsn = log->l_ailp->ail_head_lsn; 1743 ), 1744 TP_printk("dev %d:%d new tail lsn %d/%d, old lsn %d/%d, head lsn %d/%d", 1745 MAJOR(__entry->dev), MINOR(__entry->dev), 1746 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn), 1747 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn), 1748 CYCLE_LSN(__entry->head_lsn), BLOCK_LSN(__entry->head_lsn)) 1749 ) 1750 1751 DECLARE_EVENT_CLASS(xfs_file_class, 1752 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), 1753 TP_ARGS(iocb, iter), 1754 TP_STRUCT__entry( 1755 __field(dev_t, dev) 1756 __field(xfs_ino_t, ino) 1757 __field(xfs_fsize_t, size) 1758 __field(loff_t, offset) 1759 __field(size_t, count) 1760 ), 1761 TP_fast_assign( 1762 __entry->dev = file_inode(iocb->ki_filp)->i_sb->s_dev; 1763 __entry->ino = XFS_I(file_inode(iocb->ki_filp))->i_ino; 1764 __entry->size = XFS_I(file_inode(iocb->ki_filp))->i_disk_size; 1765 __entry->offset = iocb->ki_pos; 1766 __entry->count = iov_iter_count(iter); 1767 ), 1768 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx", 1769 MAJOR(__entry->dev), MINOR(__entry->dev), 1770 __entry->ino, 1771 __entry->size, 1772 __entry->offset, 1773 __entry->count) 1774 ) 1775 1776 #define DEFINE_RW_EVENT(name) \ 1777 DEFINE_EVENT(xfs_file_class, name, \ 1778 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), \ 1779 TP_ARGS(iocb, iter)) 1780 DEFINE_RW_EVENT(xfs_file_buffered_read); 1781 DEFINE_RW_EVENT(xfs_file_direct_read); 1782 DEFINE_RW_EVENT(xfs_file_dax_read); 1783 DEFINE_RW_EVENT(xfs_file_buffered_write); 1784 DEFINE_RW_EVENT(xfs_file_direct_write); 1785 DEFINE_RW_EVENT(xfs_file_dax_write); 1786 DEFINE_RW_EVENT(xfs_reflink_bounce_dio_write); 1787 1788 TRACE_EVENT(xfs_iomap_atomic_write_cow, 1789 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), 1790 TP_ARGS(ip, offset, count), 1791 TP_STRUCT__entry( 1792 __field(dev_t, dev) 1793 __field(xfs_ino_t, ino) 1794 __field(xfs_off_t, offset) 1795 __field(ssize_t, count) 1796 ), 1797 TP_fast_assign( 1798 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1799 __entry->ino = ip->i_ino; 1800 __entry->offset = offset; 1801 __entry->count = count; 1802 ), 1803 TP_printk("dev %d:%d ino 0x%llx pos 0x%llx bytecount 0x%zx", 1804 MAJOR(__entry->dev), MINOR(__entry->dev), 1805 __entry->ino, 1806 __entry->offset, 1807 __entry->count) 1808 ) 1809 1810 DECLARE_EVENT_CLASS(xfs_imap_class, 1811 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, 1812 int whichfork, struct xfs_bmbt_irec *irec), 1813 TP_ARGS(ip, offset, count, whichfork, irec), 1814 TP_STRUCT__entry( 1815 __field(dev_t, dev) 1816 __field(xfs_ino_t, ino) 1817 __field(loff_t, size) 1818 __field(loff_t, offset) 1819 __field(size_t, count) 1820 __field(int, whichfork) 1821 __field(xfs_fileoff_t, startoff) 1822 __field(xfs_fsblock_t, startblock) 1823 __field(xfs_filblks_t, blockcount) 1824 ), 1825 TP_fast_assign( 1826 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1827 __entry->ino = ip->i_ino; 1828 __entry->size = ip->i_disk_size; 1829 __entry->offset = offset; 1830 __entry->count = count; 1831 __entry->whichfork = whichfork; 1832 __entry->startoff = irec ? irec->br_startoff : 0; 1833 __entry->startblock = irec ? irec->br_startblock : 0; 1834 __entry->blockcount = irec ? irec->br_blockcount : 0; 1835 ), 1836 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx " 1837 "fork %s startoff 0x%llx startblock 0x%llx fsbcount 0x%llx", 1838 MAJOR(__entry->dev), MINOR(__entry->dev), 1839 __entry->ino, 1840 __entry->size, 1841 __entry->offset, 1842 __entry->count, 1843 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 1844 __entry->startoff, 1845 (int64_t)__entry->startblock, 1846 __entry->blockcount) 1847 ) 1848 1849 #define DEFINE_IMAP_EVENT(name) \ 1850 DEFINE_EVENT(xfs_imap_class, name, \ 1851 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, \ 1852 int whichfork, struct xfs_bmbt_irec *irec), \ 1853 TP_ARGS(ip, offset, count, whichfork, irec)) 1854 DEFINE_IMAP_EVENT(xfs_map_blocks_found); 1855 DEFINE_IMAP_EVENT(xfs_map_blocks_alloc); 1856 DEFINE_IMAP_EVENT(xfs_iomap_alloc); 1857 DEFINE_IMAP_EVENT(xfs_iomap_found); 1858 1859 DECLARE_EVENT_CLASS(xfs_simple_io_class, 1860 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), 1861 TP_ARGS(ip, offset, count), 1862 TP_STRUCT__entry( 1863 __field(dev_t, dev) 1864 __field(xfs_ino_t, ino) 1865 __field(loff_t, isize) 1866 __field(loff_t, disize) 1867 __field(loff_t, offset) 1868 __field(size_t, count) 1869 ), 1870 TP_fast_assign( 1871 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1872 __entry->ino = ip->i_ino; 1873 __entry->isize = VFS_I(ip)->i_size; 1874 __entry->disize = ip->i_disk_size; 1875 __entry->offset = offset; 1876 __entry->count = count; 1877 ), 1878 TP_printk("dev %d:%d ino 0x%llx isize 0x%llx disize 0x%llx " 1879 "pos 0x%llx bytecount 0x%zx", 1880 MAJOR(__entry->dev), MINOR(__entry->dev), 1881 __entry->ino, 1882 __entry->isize, 1883 __entry->disize, 1884 __entry->offset, 1885 __entry->count) 1886 ); 1887 1888 #define DEFINE_SIMPLE_IO_EVENT(name) \ 1889 DEFINE_EVENT(xfs_simple_io_class, name, \ 1890 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), \ 1891 TP_ARGS(ip, offset, count)) 1892 DEFINE_SIMPLE_IO_EVENT(xfs_delalloc_enospc); 1893 DEFINE_SIMPLE_IO_EVENT(xfs_unwritten_convert); 1894 DEFINE_SIMPLE_IO_EVENT(xfs_setfilesize); 1895 DEFINE_SIMPLE_IO_EVENT(xfs_zero_eof); 1896 DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write); 1897 DEFINE_SIMPLE_IO_EVENT(xfs_file_splice_read); 1898 DEFINE_SIMPLE_IO_EVENT(xfs_zoned_map_blocks); 1899 1900 DECLARE_EVENT_CLASS(xfs_itrunc_class, 1901 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), 1902 TP_ARGS(ip, new_size), 1903 TP_STRUCT__entry( 1904 __field(dev_t, dev) 1905 __field(xfs_ino_t, ino) 1906 __field(xfs_fsize_t, size) 1907 __field(xfs_fsize_t, new_size) 1908 ), 1909 TP_fast_assign( 1910 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1911 __entry->ino = ip->i_ino; 1912 __entry->size = ip->i_disk_size; 1913 __entry->new_size = new_size; 1914 ), 1915 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx new_size 0x%llx", 1916 MAJOR(__entry->dev), MINOR(__entry->dev), 1917 __entry->ino, 1918 __entry->size, 1919 __entry->new_size) 1920 ) 1921 1922 #define DEFINE_ITRUNC_EVENT(name) \ 1923 DEFINE_EVENT(xfs_itrunc_class, name, \ 1924 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \ 1925 TP_ARGS(ip, new_size)) 1926 DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_start); 1927 DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_end); 1928 1929 TRACE_EVENT(xfs_bunmap, 1930 TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t fileoff, xfs_filblks_t len, 1931 int flags, unsigned long caller_ip), 1932 TP_ARGS(ip, fileoff, len, flags, caller_ip), 1933 TP_STRUCT__entry( 1934 __field(dev_t, dev) 1935 __field(xfs_ino_t, ino) 1936 __field(xfs_fsize_t, size) 1937 __field(xfs_fileoff_t, fileoff) 1938 __field(xfs_filblks_t, len) 1939 __field(unsigned long, caller_ip) 1940 __field(int, flags) 1941 ), 1942 TP_fast_assign( 1943 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1944 __entry->ino = ip->i_ino; 1945 __entry->size = ip->i_disk_size; 1946 __entry->fileoff = fileoff; 1947 __entry->len = len; 1948 __entry->caller_ip = caller_ip; 1949 __entry->flags = flags; 1950 ), 1951 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx fileoff 0x%llx fsbcount 0x%llx " 1952 "flags %s caller %pS", 1953 MAJOR(__entry->dev), MINOR(__entry->dev), 1954 __entry->ino, 1955 __entry->size, 1956 __entry->fileoff, 1957 __entry->len, 1958 __print_flags(__entry->flags, "|", XFS_BMAPI_FLAGS), 1959 (void *)__entry->caller_ip) 1960 1961 ); 1962 1963 DECLARE_EVENT_CLASS(xfs_extent_busy_class, 1964 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 1965 xfs_extlen_t len), 1966 TP_ARGS(xg, agbno, len), 1967 TP_STRUCT__entry( 1968 __field(dev_t, dev) 1969 __field(enum xfs_group_type, type) 1970 __field(xfs_agnumber_t, agno) 1971 __field(xfs_agblock_t, agbno) 1972 __field(xfs_extlen_t, len) 1973 ), 1974 TP_fast_assign( 1975 __entry->dev = xg->xg_mount->m_super->s_dev; 1976 __entry->type = xg->xg_type; 1977 __entry->agno = xg->xg_gno; 1978 __entry->agbno = agbno; 1979 __entry->len = len; 1980 ), 1981 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x", 1982 MAJOR(__entry->dev), MINOR(__entry->dev), 1983 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 1984 __entry->agno, 1985 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 1986 __entry->agbno, 1987 __entry->len) 1988 ); 1989 #define DEFINE_BUSY_EVENT(name) \ 1990 DEFINE_EVENT(xfs_extent_busy_class, name, \ 1991 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, \ 1992 xfs_extlen_t len), \ 1993 TP_ARGS(xg, agbno, len)) 1994 DEFINE_BUSY_EVENT(xfs_extent_busy); 1995 DEFINE_BUSY_EVENT(xfs_extent_busy_force); 1996 DEFINE_BUSY_EVENT(xfs_extent_busy_reuse); 1997 DEFINE_BUSY_EVENT(xfs_extent_busy_clear); 1998 1999 TRACE_EVENT(xfs_extent_busy_trim, 2000 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 2001 xfs_extlen_t len, xfs_agblock_t tbno, xfs_extlen_t tlen), 2002 TP_ARGS(xg, agbno, len, tbno, tlen), 2003 TP_STRUCT__entry( 2004 __field(dev_t, dev) 2005 __field(enum xfs_group_type, type) 2006 __field(xfs_agnumber_t, agno) 2007 __field(xfs_agblock_t, agbno) 2008 __field(xfs_extlen_t, len) 2009 __field(xfs_agblock_t, tbno) 2010 __field(xfs_extlen_t, tlen) 2011 ), 2012 TP_fast_assign( 2013 __entry->dev = xg->xg_mount->m_super->s_dev; 2014 __entry->type = xg->xg_type; 2015 __entry->agno = xg->xg_gno; 2016 __entry->agbno = agbno; 2017 __entry->len = len; 2018 __entry->tbno = tbno; 2019 __entry->tlen = tlen; 2020 ), 2021 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x found_agbno 0x%x found_fsbcount 0x%x", 2022 MAJOR(__entry->dev), MINOR(__entry->dev), 2023 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2024 __entry->agno, 2025 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2026 __entry->agbno, 2027 __entry->len, 2028 __entry->tbno, 2029 __entry->tlen) 2030 ); 2031 2032 #ifdef CONFIG_XFS_RT 2033 TRACE_EVENT(xfs_rtalloc_extent_busy, 2034 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rtxnum_t start, 2035 xfs_rtxlen_t minlen, xfs_rtxlen_t maxlen, 2036 xfs_rtxlen_t len, xfs_rtxlen_t prod, xfs_rtxnum_t rtx, 2037 unsigned busy_gen), 2038 TP_ARGS(rtg, start, minlen, maxlen, len, prod, rtx, busy_gen), 2039 TP_STRUCT__entry( 2040 __field(dev_t, dev) 2041 __field(xfs_rgnumber_t, rgno) 2042 __field(xfs_rtxnum_t, start) 2043 __field(xfs_rtxlen_t, minlen) 2044 __field(xfs_rtxlen_t, maxlen) 2045 __field(xfs_rtxlen_t, mod) 2046 __field(xfs_rtxlen_t, prod) 2047 __field(xfs_rtxlen_t, len) 2048 __field(xfs_rtxnum_t, rtx) 2049 __field(unsigned, busy_gen) 2050 ), 2051 TP_fast_assign( 2052 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 2053 __entry->rgno = rtg_rgno(rtg); 2054 __entry->start = start; 2055 __entry->minlen = minlen; 2056 __entry->maxlen = maxlen; 2057 __entry->prod = prod; 2058 __entry->len = len; 2059 __entry->rtx = rtx; 2060 __entry->busy_gen = busy_gen; 2061 ), 2062 TP_printk("dev %d:%d rgno 0x%x startrtx 0x%llx minlen %u maxlen %u " 2063 "prod %u len %u rtx 0%llx busy_gen 0x%x", 2064 MAJOR(__entry->dev), MINOR(__entry->dev), 2065 __entry->rgno, 2066 __entry->start, 2067 __entry->minlen, 2068 __entry->maxlen, 2069 __entry->prod, 2070 __entry->len, 2071 __entry->rtx, 2072 __entry->busy_gen) 2073 ) 2074 2075 TRACE_EVENT(xfs_rtalloc_extent_busy_trim, 2076 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rtxnum_t old_rtx, 2077 xfs_rtxlen_t old_len, xfs_rtxnum_t new_rtx, 2078 xfs_rtxlen_t new_len), 2079 TP_ARGS(rtg, old_rtx, old_len, new_rtx, new_len), 2080 TP_STRUCT__entry( 2081 __field(dev_t, dev) 2082 __field(xfs_rgnumber_t, rgno) 2083 __field(xfs_rtxnum_t, old_rtx) 2084 __field(xfs_rtxnum_t, new_rtx) 2085 __field(xfs_rtxlen_t, old_len) 2086 __field(xfs_rtxlen_t, new_len) 2087 ), 2088 TP_fast_assign( 2089 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 2090 __entry->rgno = rtg_rgno(rtg); 2091 __entry->old_rtx = old_rtx; 2092 __entry->old_len = old_len; 2093 __entry->new_rtx = new_rtx; 2094 __entry->new_len = new_len; 2095 ), 2096 TP_printk("dev %d:%d rgno 0x%x rtx 0x%llx rtxcount 0x%x -> rtx 0x%llx rtxcount 0x%x", 2097 MAJOR(__entry->dev), MINOR(__entry->dev), 2098 __entry->rgno, 2099 __entry->old_rtx, 2100 __entry->old_len, 2101 __entry->new_rtx, 2102 __entry->new_len) 2103 ); 2104 #endif /* CONFIG_XFS_RT */ 2105 2106 DECLARE_EVENT_CLASS(xfs_agf_class, 2107 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags, 2108 unsigned long caller_ip), 2109 TP_ARGS(mp, agf, flags, caller_ip), 2110 TP_STRUCT__entry( 2111 __field(dev_t, dev) 2112 __field(xfs_agnumber_t, agno) 2113 __field(int, flags) 2114 __field(__u32, length) 2115 __field(__u32, bno_root) 2116 __field(__u32, cnt_root) 2117 __field(__u32, bno_level) 2118 __field(__u32, cnt_level) 2119 __field(__u32, flfirst) 2120 __field(__u32, fllast) 2121 __field(__u32, flcount) 2122 __field(__u32, freeblks) 2123 __field(__u32, longest) 2124 __field(unsigned long, caller_ip) 2125 ), 2126 TP_fast_assign( 2127 __entry->dev = mp->m_super->s_dev; 2128 __entry->agno = be32_to_cpu(agf->agf_seqno), 2129 __entry->flags = flags; 2130 __entry->length = be32_to_cpu(agf->agf_length), 2131 __entry->bno_root = be32_to_cpu(agf->agf_bno_root), 2132 __entry->cnt_root = be32_to_cpu(agf->agf_cnt_root), 2133 __entry->bno_level = be32_to_cpu(agf->agf_bno_level), 2134 __entry->cnt_level = be32_to_cpu(agf->agf_cnt_level), 2135 __entry->flfirst = be32_to_cpu(agf->agf_flfirst), 2136 __entry->fllast = be32_to_cpu(agf->agf_fllast), 2137 __entry->flcount = be32_to_cpu(agf->agf_flcount), 2138 __entry->freeblks = be32_to_cpu(agf->agf_freeblks), 2139 __entry->longest = be32_to_cpu(agf->agf_longest); 2140 __entry->caller_ip = caller_ip; 2141 ), 2142 TP_printk("dev %d:%d agno 0x%x flags %s length %u roots b %u c %u " 2143 "levels b %u c %u flfirst %u fllast %u flcount %u " 2144 "freeblks %u longest %u caller %pS", 2145 MAJOR(__entry->dev), MINOR(__entry->dev), 2146 __entry->agno, 2147 __print_flags(__entry->flags, "|", XFS_AGF_FLAGS), 2148 __entry->length, 2149 __entry->bno_root, 2150 __entry->cnt_root, 2151 __entry->bno_level, 2152 __entry->cnt_level, 2153 __entry->flfirst, 2154 __entry->fllast, 2155 __entry->flcount, 2156 __entry->freeblks, 2157 __entry->longest, 2158 (void *)__entry->caller_ip) 2159 ); 2160 #define DEFINE_AGF_EVENT(name) \ 2161 DEFINE_EVENT(xfs_agf_class, name, \ 2162 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags, \ 2163 unsigned long caller_ip), \ 2164 TP_ARGS(mp, agf, flags, caller_ip)) 2165 DEFINE_AGF_EVENT(xfs_agf); 2166 DEFINE_AGF_EVENT(xfs_agfl_reset); 2167 2168 TRACE_EVENT(xfs_free_extent, 2169 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t agbno, 2170 xfs_extlen_t len, enum xfs_ag_resv_type resv, int haveleft, 2171 int haveright), 2172 TP_ARGS(pag, agbno, len, resv, haveleft, haveright), 2173 TP_STRUCT__entry( 2174 __field(dev_t, dev) 2175 __field(xfs_agnumber_t, agno) 2176 __field(xfs_agblock_t, agbno) 2177 __field(xfs_extlen_t, len) 2178 __field(int, resv) 2179 __field(int, haveleft) 2180 __field(int, haveright) 2181 ), 2182 TP_fast_assign( 2183 __entry->dev = pag_mount(pag)->m_super->s_dev; 2184 __entry->agno = pag_agno(pag); 2185 __entry->agbno = agbno; 2186 __entry->len = len; 2187 __entry->resv = resv; 2188 __entry->haveleft = haveleft; 2189 __entry->haveright = haveright; 2190 ), 2191 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x resv %d %s", 2192 MAJOR(__entry->dev), MINOR(__entry->dev), 2193 __entry->agno, 2194 __entry->agbno, 2195 __entry->len, 2196 __entry->resv, 2197 __entry->haveleft ? 2198 (__entry->haveright ? "both" : "left") : 2199 (__entry->haveright ? "right" : "none")) 2200 2201 ); 2202 2203 DECLARE_EVENT_CLASS(xfs_alloc_class, 2204 TP_PROTO(struct xfs_alloc_arg *args), 2205 TP_ARGS(args), 2206 TP_STRUCT__entry( 2207 __field(dev_t, dev) 2208 __field(xfs_agnumber_t, agno) 2209 __field(xfs_agblock_t, agbno) 2210 __field(xfs_extlen_t, minlen) 2211 __field(xfs_extlen_t, maxlen) 2212 __field(xfs_extlen_t, mod) 2213 __field(xfs_extlen_t, prod) 2214 __field(xfs_extlen_t, minleft) 2215 __field(xfs_extlen_t, total) 2216 __field(xfs_extlen_t, alignment) 2217 __field(xfs_extlen_t, minalignslop) 2218 __field(xfs_extlen_t, len) 2219 __field(char, wasdel) 2220 __field(char, wasfromfl) 2221 __field(int, resv) 2222 __field(int, datatype) 2223 __field(xfs_agnumber_t, highest_agno) 2224 ), 2225 TP_fast_assign( 2226 __entry->dev = args->mp->m_super->s_dev; 2227 __entry->agno = args->agno; 2228 __entry->agbno = args->agbno; 2229 __entry->minlen = args->minlen; 2230 __entry->maxlen = args->maxlen; 2231 __entry->mod = args->mod; 2232 __entry->prod = args->prod; 2233 __entry->minleft = args->minleft; 2234 __entry->total = args->total; 2235 __entry->alignment = args->alignment; 2236 __entry->minalignslop = args->minalignslop; 2237 __entry->len = args->len; 2238 __entry->wasdel = args->wasdel; 2239 __entry->wasfromfl = args->wasfromfl; 2240 __entry->resv = args->resv; 2241 __entry->datatype = args->datatype; 2242 __entry->highest_agno = args->tp->t_highest_agno; 2243 ), 2244 TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u " 2245 "prod %u minleft %u total %u alignment %u minalignslop %u " 2246 "len %u wasdel %d wasfromfl %d resv %d " 2247 "datatype 0x%x highest_agno 0x%x", 2248 MAJOR(__entry->dev), MINOR(__entry->dev), 2249 __entry->agno, 2250 __entry->agbno, 2251 __entry->minlen, 2252 __entry->maxlen, 2253 __entry->mod, 2254 __entry->prod, 2255 __entry->minleft, 2256 __entry->total, 2257 __entry->alignment, 2258 __entry->minalignslop, 2259 __entry->len, 2260 __entry->wasdel, 2261 __entry->wasfromfl, 2262 __entry->resv, 2263 __entry->datatype, 2264 __entry->highest_agno) 2265 ) 2266 2267 #define DEFINE_ALLOC_EVENT(name) \ 2268 DEFINE_EVENT(xfs_alloc_class, name, \ 2269 TP_PROTO(struct xfs_alloc_arg *args), \ 2270 TP_ARGS(args)) 2271 DEFINE_ALLOC_EVENT(xfs_alloc_exact_done); 2272 DEFINE_ALLOC_EVENT(xfs_alloc_exact_notfound); 2273 DEFINE_ALLOC_EVENT(xfs_alloc_exact_error); 2274 DEFINE_ALLOC_EVENT(xfs_alloc_near_first); 2275 DEFINE_ALLOC_EVENT(xfs_alloc_cur); 2276 DEFINE_ALLOC_EVENT(xfs_alloc_cur_right); 2277 DEFINE_ALLOC_EVENT(xfs_alloc_cur_left); 2278 DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup); 2279 DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup_done); 2280 DEFINE_ALLOC_EVENT(xfs_alloc_near_noentry); 2281 DEFINE_ALLOC_EVENT(xfs_alloc_near_busy); 2282 DEFINE_ALLOC_EVENT(xfs_alloc_size_neither); 2283 DEFINE_ALLOC_EVENT(xfs_alloc_size_noentry); 2284 DEFINE_ALLOC_EVENT(xfs_alloc_size_nominleft); 2285 DEFINE_ALLOC_EVENT(xfs_alloc_size_done); 2286 DEFINE_ALLOC_EVENT(xfs_alloc_size_error); 2287 DEFINE_ALLOC_EVENT(xfs_alloc_size_busy); 2288 DEFINE_ALLOC_EVENT(xfs_alloc_small_freelist); 2289 DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough); 2290 DEFINE_ALLOC_EVENT(xfs_alloc_small_done); 2291 DEFINE_ALLOC_EVENT(xfs_alloc_small_error); 2292 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_badargs); 2293 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_skip_deadlock); 2294 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_nofix); 2295 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp); 2296 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed); 2297 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed); 2298 2299 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_this_ag); 2300 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_start_ag); 2301 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_first_ag); 2302 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_exact_bno); 2303 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_near_bno); 2304 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_finish); 2305 2306 TRACE_EVENT(xfs_alloc_cur_check, 2307 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t bno, 2308 xfs_extlen_t len, xfs_extlen_t diff, bool new), 2309 TP_ARGS(cur, bno, len, diff, new), 2310 TP_STRUCT__entry( 2311 __field(dev_t, dev) 2312 __string(name, cur->bc_ops->name) 2313 __field(xfs_agblock_t, bno) 2314 __field(xfs_extlen_t, len) 2315 __field(xfs_extlen_t, diff) 2316 __field(bool, new) 2317 ), 2318 TP_fast_assign( 2319 __entry->dev = cur->bc_mp->m_super->s_dev; 2320 __assign_str(name); 2321 __entry->bno = bno; 2322 __entry->len = len; 2323 __entry->diff = diff; 2324 __entry->new = new; 2325 ), 2326 TP_printk("dev %d:%d %sbt agbno 0x%x fsbcount 0x%x diff 0x%x new %d", 2327 MAJOR(__entry->dev), MINOR(__entry->dev), 2328 __get_str(name), 2329 __entry->bno, __entry->len, __entry->diff, __entry->new) 2330 ) 2331 2332 DECLARE_EVENT_CLASS(xfs_da_class, 2333 TP_PROTO(struct xfs_da_args *args), 2334 TP_ARGS(args), 2335 TP_STRUCT__entry( 2336 __field(dev_t, dev) 2337 __field(xfs_ino_t, ino) 2338 __dynamic_array(char, name, args->namelen) 2339 __field(int, namelen) 2340 __field(xfs_dahash_t, hashval) 2341 __field(xfs_ino_t, inumber) 2342 __field(uint32_t, op_flags) 2343 __field(xfs_ino_t, owner) 2344 ), 2345 TP_fast_assign( 2346 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2347 __entry->ino = args->dp->i_ino; 2348 if (args->namelen) 2349 memcpy(__get_str(name), args->name, args->namelen); 2350 __entry->namelen = args->namelen; 2351 __entry->hashval = args->hashval; 2352 __entry->inumber = args->inumber; 2353 __entry->op_flags = args->op_flags; 2354 __entry->owner = args->owner; 2355 ), 2356 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x " 2357 "inumber 0x%llx op_flags %s owner 0x%llx", 2358 MAJOR(__entry->dev), MINOR(__entry->dev), 2359 __entry->ino, 2360 __entry->namelen, 2361 __entry->namelen ? __get_str(name) : NULL, 2362 __entry->namelen, 2363 __entry->hashval, 2364 __entry->inumber, 2365 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2366 __entry->owner) 2367 ) 2368 2369 #define DEFINE_DIR2_EVENT(name) \ 2370 DEFINE_EVENT(xfs_da_class, name, \ 2371 TP_PROTO(struct xfs_da_args *args), \ 2372 TP_ARGS(args)) 2373 DEFINE_DIR2_EVENT(xfs_dir2_sf_addname); 2374 DEFINE_DIR2_EVENT(xfs_dir2_sf_create); 2375 DEFINE_DIR2_EVENT(xfs_dir2_sf_lookup); 2376 DEFINE_DIR2_EVENT(xfs_dir2_sf_replace); 2377 DEFINE_DIR2_EVENT(xfs_dir2_sf_removename); 2378 DEFINE_DIR2_EVENT(xfs_dir2_sf_toino4); 2379 DEFINE_DIR2_EVENT(xfs_dir2_sf_toino8); 2380 DEFINE_DIR2_EVENT(xfs_dir2_sf_to_block); 2381 DEFINE_DIR2_EVENT(xfs_dir2_block_addname); 2382 DEFINE_DIR2_EVENT(xfs_dir2_block_lookup); 2383 DEFINE_DIR2_EVENT(xfs_dir2_block_replace); 2384 DEFINE_DIR2_EVENT(xfs_dir2_block_removename); 2385 DEFINE_DIR2_EVENT(xfs_dir2_block_to_sf); 2386 DEFINE_DIR2_EVENT(xfs_dir2_block_to_leaf); 2387 DEFINE_DIR2_EVENT(xfs_dir2_leaf_addname); 2388 DEFINE_DIR2_EVENT(xfs_dir2_leaf_lookup); 2389 DEFINE_DIR2_EVENT(xfs_dir2_leaf_replace); 2390 DEFINE_DIR2_EVENT(xfs_dir2_leaf_removename); 2391 DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_block); 2392 DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_node); 2393 DEFINE_DIR2_EVENT(xfs_dir2_node_addname); 2394 DEFINE_DIR2_EVENT(xfs_dir2_node_lookup); 2395 DEFINE_DIR2_EVENT(xfs_dir2_node_replace); 2396 DEFINE_DIR2_EVENT(xfs_dir2_node_removename); 2397 DEFINE_DIR2_EVENT(xfs_dir2_node_to_leaf); 2398 2399 DECLARE_EVENT_CLASS(xfs_attr_class, 2400 TP_PROTO(struct xfs_da_args *args), 2401 TP_ARGS(args), 2402 TP_STRUCT__entry( 2403 __field(dev_t, dev) 2404 __field(xfs_ino_t, ino) 2405 __dynamic_array(char, name, args->namelen) 2406 __field(int, namelen) 2407 __field(int, valuelen) 2408 __field(xfs_dahash_t, hashval) 2409 __field(unsigned int, attr_filter) 2410 __field(uint32_t, op_flags) 2411 ), 2412 TP_fast_assign( 2413 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2414 __entry->ino = args->dp->i_ino; 2415 if (args->namelen) 2416 memcpy(__get_str(name), args->name, args->namelen); 2417 __entry->namelen = args->namelen; 2418 __entry->valuelen = args->valuelen; 2419 __entry->hashval = args->hashval; 2420 __entry->attr_filter = args->attr_filter; 2421 __entry->op_flags = args->op_flags; 2422 ), 2423 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d valuelen %d " 2424 "hashval 0x%x filter %s op_flags %s", 2425 MAJOR(__entry->dev), MINOR(__entry->dev), 2426 __entry->ino, 2427 __entry->namelen, 2428 __entry->namelen ? __get_str(name) : NULL, 2429 __entry->namelen, 2430 __entry->valuelen, 2431 __entry->hashval, 2432 __print_flags(__entry->attr_filter, "|", 2433 XFS_ATTR_FILTER_FLAGS), 2434 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS)) 2435 ) 2436 2437 #define DEFINE_ATTR_EVENT(name) \ 2438 DEFINE_EVENT(xfs_attr_class, name, \ 2439 TP_PROTO(struct xfs_da_args *args), \ 2440 TP_ARGS(args)) 2441 DEFINE_ATTR_EVENT(xfs_attr_sf_add); 2442 DEFINE_ATTR_EVENT(xfs_attr_sf_addname); 2443 DEFINE_ATTR_EVENT(xfs_attr_sf_create); 2444 DEFINE_ATTR_EVENT(xfs_attr_sf_lookup); 2445 DEFINE_ATTR_EVENT(xfs_attr_sf_remove); 2446 DEFINE_ATTR_EVENT(xfs_attr_sf_replace); 2447 DEFINE_ATTR_EVENT(xfs_attr_sf_to_leaf); 2448 2449 DEFINE_ATTR_EVENT(xfs_attr_leaf_add); 2450 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_old); 2451 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_new); 2452 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_work); 2453 DEFINE_ATTR_EVENT(xfs_attr_leaf_create); 2454 DEFINE_ATTR_EVENT(xfs_attr_leaf_compact); 2455 DEFINE_ATTR_EVENT(xfs_attr_leaf_get); 2456 DEFINE_ATTR_EVENT(xfs_attr_leaf_lookup); 2457 DEFINE_ATTR_EVENT(xfs_attr_leaf_replace); 2458 DEFINE_ATTR_EVENT(xfs_attr_leaf_remove); 2459 DEFINE_ATTR_EVENT(xfs_attr_leaf_removename); 2460 DEFINE_ATTR_EVENT(xfs_attr_leaf_split); 2461 DEFINE_ATTR_EVENT(xfs_attr_leaf_split_before); 2462 DEFINE_ATTR_EVENT(xfs_attr_leaf_split_after); 2463 DEFINE_ATTR_EVENT(xfs_attr_leaf_clearflag); 2464 DEFINE_ATTR_EVENT(xfs_attr_leaf_setflag); 2465 DEFINE_ATTR_EVENT(xfs_attr_leaf_flipflags); 2466 DEFINE_ATTR_EVENT(xfs_attr_leaf_to_sf); 2467 DEFINE_ATTR_EVENT(xfs_attr_leaf_to_node); 2468 DEFINE_ATTR_EVENT(xfs_attr_leaf_rebalance); 2469 DEFINE_ATTR_EVENT(xfs_attr_leaf_unbalance); 2470 DEFINE_ATTR_EVENT(xfs_attr_leaf_toosmall); 2471 2472 DEFINE_ATTR_EVENT(xfs_attr_node_addname); 2473 DEFINE_ATTR_EVENT(xfs_attr_node_get); 2474 DEFINE_ATTR_EVENT(xfs_attr_node_replace); 2475 2476 DEFINE_ATTR_EVENT(xfs_attr_rmtval_get); 2477 2478 #define DEFINE_DA_EVENT(name) \ 2479 DEFINE_EVENT(xfs_da_class, name, \ 2480 TP_PROTO(struct xfs_da_args *args), \ 2481 TP_ARGS(args)) 2482 DEFINE_DA_EVENT(xfs_da_split); 2483 DEFINE_DA_EVENT(xfs_da_join); 2484 DEFINE_DA_EVENT(xfs_da_link_before); 2485 DEFINE_DA_EVENT(xfs_da_link_after); 2486 DEFINE_DA_EVENT(xfs_da_unlink_back); 2487 DEFINE_DA_EVENT(xfs_da_unlink_forward); 2488 DEFINE_DA_EVENT(xfs_da_root_split); 2489 DEFINE_DA_EVENT(xfs_da_root_join); 2490 DEFINE_DA_EVENT(xfs_da_node_add); 2491 DEFINE_DA_EVENT(xfs_da_node_create); 2492 DEFINE_DA_EVENT(xfs_da_node_split); 2493 DEFINE_DA_EVENT(xfs_da_node_remove); 2494 DEFINE_DA_EVENT(xfs_da_node_rebalance); 2495 DEFINE_DA_EVENT(xfs_da_node_unbalance); 2496 DEFINE_DA_EVENT(xfs_da_node_toosmall); 2497 DEFINE_DA_EVENT(xfs_da_swap_lastblock); 2498 DEFINE_DA_EVENT(xfs_da_grow_inode); 2499 DEFINE_DA_EVENT(xfs_da_shrink_inode); 2500 DEFINE_DA_EVENT(xfs_da_fixhashpath); 2501 DEFINE_DA_EVENT(xfs_da_path_shift); 2502 2503 DECLARE_EVENT_CLASS(xfs_dir2_space_class, 2504 TP_PROTO(struct xfs_da_args *args, int idx), 2505 TP_ARGS(args, idx), 2506 TP_STRUCT__entry( 2507 __field(dev_t, dev) 2508 __field(xfs_ino_t, ino) 2509 __field(uint32_t, op_flags) 2510 __field(int, idx) 2511 ), 2512 TP_fast_assign( 2513 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2514 __entry->ino = args->dp->i_ino; 2515 __entry->op_flags = args->op_flags; 2516 __entry->idx = idx; 2517 ), 2518 TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d", 2519 MAJOR(__entry->dev), MINOR(__entry->dev), 2520 __entry->ino, 2521 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2522 __entry->idx) 2523 ) 2524 2525 #define DEFINE_DIR2_SPACE_EVENT(name) \ 2526 DEFINE_EVENT(xfs_dir2_space_class, name, \ 2527 TP_PROTO(struct xfs_da_args *args, int idx), \ 2528 TP_ARGS(args, idx)) 2529 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_add); 2530 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_remove); 2531 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_grow_inode); 2532 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_shrink_inode); 2533 2534 TRACE_EVENT(xfs_dir2_leafn_moveents, 2535 TP_PROTO(struct xfs_da_args *args, int src_idx, int dst_idx, int count), 2536 TP_ARGS(args, src_idx, dst_idx, count), 2537 TP_STRUCT__entry( 2538 __field(dev_t, dev) 2539 __field(xfs_ino_t, ino) 2540 __field(uint32_t, op_flags) 2541 __field(int, src_idx) 2542 __field(int, dst_idx) 2543 __field(int, count) 2544 ), 2545 TP_fast_assign( 2546 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2547 __entry->ino = args->dp->i_ino; 2548 __entry->op_flags = args->op_flags; 2549 __entry->src_idx = src_idx; 2550 __entry->dst_idx = dst_idx; 2551 __entry->count = count; 2552 ), 2553 TP_printk("dev %d:%d ino 0x%llx op_flags %s " 2554 "src_idx %d dst_idx %d count %d", 2555 MAJOR(__entry->dev), MINOR(__entry->dev), 2556 __entry->ino, 2557 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2558 __entry->src_idx, 2559 __entry->dst_idx, 2560 __entry->count) 2561 ); 2562 2563 #define XFS_SWAPEXT_INODES \ 2564 { 0, "target" }, \ 2565 { 1, "temp" } 2566 2567 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_DEV); 2568 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_LOCAL); 2569 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_EXTENTS); 2570 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_BTREE); 2571 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_UUID); 2572 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_META_BTREE); 2573 2574 DECLARE_EVENT_CLASS(xfs_swap_extent_class, 2575 TP_PROTO(struct xfs_inode *ip, int which), 2576 TP_ARGS(ip, which), 2577 TP_STRUCT__entry( 2578 __field(dev_t, dev) 2579 __field(int, which) 2580 __field(xfs_ino_t, ino) 2581 __field(int, format) 2582 __field(xfs_extnum_t, nex) 2583 __field(int, broot_size) 2584 __field(int, fork_off) 2585 ), 2586 TP_fast_assign( 2587 __entry->dev = VFS_I(ip)->i_sb->s_dev; 2588 __entry->which = which; 2589 __entry->ino = ip->i_ino; 2590 __entry->format = ip->i_df.if_format; 2591 __entry->nex = ip->i_df.if_nextents; 2592 __entry->broot_size = ip->i_df.if_broot_bytes; 2593 __entry->fork_off = xfs_inode_fork_boff(ip); 2594 ), 2595 TP_printk("dev %d:%d ino 0x%llx (%s), %s format, num_extents %llu, " 2596 "broot size %d, forkoff 0x%x", 2597 MAJOR(__entry->dev), MINOR(__entry->dev), 2598 __entry->ino, 2599 __print_symbolic(__entry->which, XFS_SWAPEXT_INODES), 2600 __print_symbolic(__entry->format, XFS_INODE_FORMAT_STR), 2601 __entry->nex, 2602 __entry->broot_size, 2603 __entry->fork_off) 2604 ) 2605 2606 #define DEFINE_SWAPEXT_EVENT(name) \ 2607 DEFINE_EVENT(xfs_swap_extent_class, name, \ 2608 TP_PROTO(struct xfs_inode *ip, int which), \ 2609 TP_ARGS(ip, which)) 2610 2611 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_before); 2612 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_after); 2613 2614 TRACE_EVENT(xfs_log_recover, 2615 TP_PROTO(struct xlog *log, xfs_daddr_t headblk, xfs_daddr_t tailblk), 2616 TP_ARGS(log, headblk, tailblk), 2617 TP_STRUCT__entry( 2618 __field(dev_t, dev) 2619 __field(xfs_daddr_t, headblk) 2620 __field(xfs_daddr_t, tailblk) 2621 ), 2622 TP_fast_assign( 2623 __entry->dev = log->l_mp->m_super->s_dev; 2624 __entry->headblk = headblk; 2625 __entry->tailblk = tailblk; 2626 ), 2627 TP_printk("dev %d:%d headblk 0x%llx tailblk 0x%llx", 2628 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->headblk, 2629 __entry->tailblk) 2630 ) 2631 2632 TRACE_EVENT(xfs_log_recover_record, 2633 TP_PROTO(struct xlog *log, struct xlog_rec_header *rhead, int pass), 2634 TP_ARGS(log, rhead, pass), 2635 TP_STRUCT__entry( 2636 __field(dev_t, dev) 2637 __field(xfs_lsn_t, lsn) 2638 __field(int, len) 2639 __field(int, num_logops) 2640 __field(int, pass) 2641 ), 2642 TP_fast_assign( 2643 __entry->dev = log->l_mp->m_super->s_dev; 2644 __entry->lsn = be64_to_cpu(rhead->h_lsn); 2645 __entry->len = be32_to_cpu(rhead->h_len); 2646 __entry->num_logops = be32_to_cpu(rhead->h_num_logops); 2647 __entry->pass = pass; 2648 ), 2649 TP_printk("dev %d:%d lsn 0x%llx len 0x%x num_logops 0x%x pass %d", 2650 MAJOR(__entry->dev), MINOR(__entry->dev), 2651 __entry->lsn, __entry->len, __entry->num_logops, 2652 __entry->pass) 2653 ) 2654 2655 DECLARE_EVENT_CLASS(xfs_log_recover_item_class, 2656 TP_PROTO(struct xlog *log, struct xlog_recover *trans, 2657 struct xlog_recover_item *item, int pass), 2658 TP_ARGS(log, trans, item, pass), 2659 TP_STRUCT__entry( 2660 __field(dev_t, dev) 2661 __field(unsigned long, item) 2662 __field(xlog_tid_t, tid) 2663 __field(xfs_lsn_t, lsn) 2664 __field(int, type) 2665 __field(int, pass) 2666 __field(int, count) 2667 __field(int, total) 2668 ), 2669 TP_fast_assign( 2670 __entry->dev = log->l_mp->m_super->s_dev; 2671 __entry->item = (unsigned long)item; 2672 __entry->tid = trans->r_log_tid; 2673 __entry->lsn = trans->r_lsn; 2674 __entry->type = ITEM_TYPE(item); 2675 __entry->pass = pass; 2676 __entry->count = item->ri_cnt; 2677 __entry->total = item->ri_total; 2678 ), 2679 TP_printk("dev %d:%d tid 0x%x lsn 0x%llx, pass %d, item %p, " 2680 "item type %s item region count/total %d/%d", 2681 MAJOR(__entry->dev), MINOR(__entry->dev), 2682 __entry->tid, 2683 __entry->lsn, 2684 __entry->pass, 2685 (void *)__entry->item, 2686 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 2687 __entry->count, 2688 __entry->total) 2689 ) 2690 2691 #define DEFINE_LOG_RECOVER_ITEM(name) \ 2692 DEFINE_EVENT(xfs_log_recover_item_class, name, \ 2693 TP_PROTO(struct xlog *log, struct xlog_recover *trans, \ 2694 struct xlog_recover_item *item, int pass), \ 2695 TP_ARGS(log, trans, item, pass)) 2696 2697 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add); 2698 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add_cont); 2699 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_head); 2700 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_tail); 2701 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_recover); 2702 2703 DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class, 2704 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), 2705 TP_ARGS(log, buf_f), 2706 TP_STRUCT__entry( 2707 __field(dev_t, dev) 2708 __field(int64_t, blkno) 2709 __field(unsigned short, len) 2710 __field(unsigned short, flags) 2711 __field(unsigned short, size) 2712 __field(unsigned int, map_size) 2713 ), 2714 TP_fast_assign( 2715 __entry->dev = log->l_mp->m_super->s_dev; 2716 __entry->blkno = buf_f->blf_blkno; 2717 __entry->len = buf_f->blf_len; 2718 __entry->flags = buf_f->blf_flags; 2719 __entry->size = buf_f->blf_size; 2720 __entry->map_size = buf_f->blf_map_size; 2721 ), 2722 TP_printk("dev %d:%d daddr 0x%llx, bbcount 0x%x, flags 0x%x, size %d, " 2723 "map_size %d", 2724 MAJOR(__entry->dev), MINOR(__entry->dev), 2725 __entry->blkno, 2726 __entry->len, 2727 __entry->flags, 2728 __entry->size, 2729 __entry->map_size) 2730 ) 2731 2732 #define DEFINE_LOG_RECOVER_BUF_ITEM(name) \ 2733 DEFINE_EVENT(xfs_log_recover_buf_item_class, name, \ 2734 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), \ 2735 TP_ARGS(log, buf_f)) 2736 2737 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_not_cancel); 2738 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel); 2739 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_add); 2740 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_ref_inc); 2741 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_recover); 2742 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_skip); 2743 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_inode_buf); 2744 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_reg_buf); 2745 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_dquot_buf); 2746 2747 DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class, 2748 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), 2749 TP_ARGS(log, in_f), 2750 TP_STRUCT__entry( 2751 __field(dev_t, dev) 2752 __field(xfs_ino_t, ino) 2753 __field(unsigned short, size) 2754 __field(int, fields) 2755 __field(unsigned short, asize) 2756 __field(unsigned short, dsize) 2757 __field(int64_t, blkno) 2758 __field(int, len) 2759 __field(int, boffset) 2760 ), 2761 TP_fast_assign( 2762 __entry->dev = log->l_mp->m_super->s_dev; 2763 __entry->ino = in_f->ilf_ino; 2764 __entry->size = in_f->ilf_size; 2765 __entry->fields = in_f->ilf_fields; 2766 __entry->asize = in_f->ilf_asize; 2767 __entry->dsize = in_f->ilf_dsize; 2768 __entry->blkno = in_f->ilf_blkno; 2769 __entry->len = in_f->ilf_len; 2770 __entry->boffset = in_f->ilf_boffset; 2771 ), 2772 TP_printk("dev %d:%d ino 0x%llx, size %u, fields 0x%x, asize %d, " 2773 "dsize %d, daddr 0x%llx, bbcount 0x%x, boffset %d", 2774 MAJOR(__entry->dev), MINOR(__entry->dev), 2775 __entry->ino, 2776 __entry->size, 2777 __entry->fields, 2778 __entry->asize, 2779 __entry->dsize, 2780 __entry->blkno, 2781 __entry->len, 2782 __entry->boffset) 2783 ) 2784 #define DEFINE_LOG_RECOVER_INO_ITEM(name) \ 2785 DEFINE_EVENT(xfs_log_recover_ino_item_class, name, \ 2786 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), \ 2787 TP_ARGS(log, in_f)) 2788 2789 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover); 2790 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_cancel); 2791 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_skip); 2792 2793 DECLARE_EVENT_CLASS(xfs_log_recover_icreate_item_class, 2794 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), 2795 TP_ARGS(log, in_f), 2796 TP_STRUCT__entry( 2797 __field(dev_t, dev) 2798 __field(xfs_agnumber_t, agno) 2799 __field(xfs_agblock_t, agbno) 2800 __field(unsigned int, count) 2801 __field(unsigned int, isize) 2802 __field(xfs_agblock_t, length) 2803 __field(unsigned int, gen) 2804 ), 2805 TP_fast_assign( 2806 __entry->dev = log->l_mp->m_super->s_dev; 2807 __entry->agno = be32_to_cpu(in_f->icl_ag); 2808 __entry->agbno = be32_to_cpu(in_f->icl_agbno); 2809 __entry->count = be32_to_cpu(in_f->icl_count); 2810 __entry->isize = be32_to_cpu(in_f->icl_isize); 2811 __entry->length = be32_to_cpu(in_f->icl_length); 2812 __entry->gen = be32_to_cpu(in_f->icl_gen); 2813 ), 2814 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x ireccount %u isize %u gen 0x%x", 2815 MAJOR(__entry->dev), MINOR(__entry->dev), 2816 __entry->agno, 2817 __entry->agbno, 2818 __entry->length, 2819 __entry->count, 2820 __entry->isize, 2821 __entry->gen) 2822 ) 2823 #define DEFINE_LOG_RECOVER_ICREATE_ITEM(name) \ 2824 DEFINE_EVENT(xfs_log_recover_icreate_item_class, name, \ 2825 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), \ 2826 TP_ARGS(log, in_f)) 2827 2828 DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_cancel); 2829 DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_recover); 2830 2831 DECLARE_EVENT_CLASS(xfs_discard_class, 2832 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 2833 xfs_extlen_t len), 2834 TP_ARGS(xg, agbno, len), 2835 TP_STRUCT__entry( 2836 __field(dev_t, dev) 2837 __field(enum xfs_group_type, type) 2838 __field(xfs_agnumber_t, agno) 2839 __field(xfs_agblock_t, agbno) 2840 __field(xfs_extlen_t, len) 2841 ), 2842 TP_fast_assign( 2843 __entry->dev = xg->xg_mount->m_super->s_dev; 2844 __entry->type = xg->xg_type; 2845 __entry->agno = xg->xg_gno; 2846 __entry->agbno = agbno; 2847 __entry->len = len; 2848 ), 2849 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x", 2850 MAJOR(__entry->dev), MINOR(__entry->dev), 2851 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2852 __entry->agno, 2853 __entry->agbno, 2854 __entry->len) 2855 ) 2856 2857 #define DEFINE_DISCARD_EVENT(name) \ 2858 DEFINE_EVENT(xfs_discard_class, name, \ 2859 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, \ 2860 xfs_extlen_t len), \ 2861 TP_ARGS(xg, agbno, len)) 2862 DEFINE_DISCARD_EVENT(xfs_discard_extent); 2863 DEFINE_DISCARD_EVENT(xfs_discard_toosmall); 2864 DEFINE_DISCARD_EVENT(xfs_discard_exclude); 2865 DEFINE_DISCARD_EVENT(xfs_discard_busy); 2866 2867 DECLARE_EVENT_CLASS(xfs_rtdiscard_class, 2868 TP_PROTO(struct xfs_mount *mp, 2869 xfs_rtblock_t rtbno, xfs_rtblock_t len), 2870 TP_ARGS(mp, rtbno, len), 2871 TP_STRUCT__entry( 2872 __field(dev_t, dev) 2873 __field(xfs_rtblock_t, rtbno) 2874 __field(xfs_rtblock_t, len) 2875 ), 2876 TP_fast_assign( 2877 __entry->dev = mp->m_rtdev_targp->bt_dev; 2878 __entry->rtbno = rtbno; 2879 __entry->len = len; 2880 ), 2881 TP_printk("dev %d:%d rtbno 0x%llx rtbcount 0x%llx", 2882 MAJOR(__entry->dev), MINOR(__entry->dev), 2883 __entry->rtbno, 2884 __entry->len) 2885 ) 2886 2887 #define DEFINE_RTDISCARD_EVENT(name) \ 2888 DEFINE_EVENT(xfs_rtdiscard_class, name, \ 2889 TP_PROTO(struct xfs_mount *mp, \ 2890 xfs_rtblock_t rtbno, xfs_rtblock_t len), \ 2891 TP_ARGS(mp, rtbno, len)) 2892 DEFINE_RTDISCARD_EVENT(xfs_discard_rtextent); 2893 DEFINE_RTDISCARD_EVENT(xfs_discard_rttoosmall); 2894 2895 DECLARE_EVENT_CLASS(xfs_btree_cur_class, 2896 TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), 2897 TP_ARGS(cur, level, bp), 2898 TP_STRUCT__entry( 2899 __field(dev_t, dev) 2900 __string(name, cur->bc_ops->name) 2901 __field(int, level) 2902 __field(int, nlevels) 2903 __field(int, ptr) 2904 __field(xfs_daddr_t, daddr) 2905 ), 2906 TP_fast_assign( 2907 __entry->dev = cur->bc_mp->m_super->s_dev; 2908 __assign_str(name); 2909 __entry->level = level; 2910 __entry->nlevels = cur->bc_nlevels; 2911 __entry->ptr = cur->bc_levels[level].ptr; 2912 __entry->daddr = bp ? xfs_buf_daddr(bp) : -1; 2913 ), 2914 TP_printk("dev %d:%d %sbt level %d/%d ptr %d daddr 0x%llx", 2915 MAJOR(__entry->dev), MINOR(__entry->dev), 2916 __get_str(name), 2917 __entry->level, 2918 __entry->nlevels, 2919 __entry->ptr, 2920 (unsigned long long)__entry->daddr) 2921 ) 2922 2923 #define DEFINE_BTREE_CUR_EVENT(name) \ 2924 DEFINE_EVENT(xfs_btree_cur_class, name, \ 2925 TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), \ 2926 TP_ARGS(cur, level, bp)) 2927 DEFINE_BTREE_CUR_EVENT(xfs_btree_updkeys); 2928 DEFINE_BTREE_CUR_EVENT(xfs_btree_overlapped_query_range); 2929 2930 TRACE_EVENT(xfs_btree_alloc_block, 2931 TP_PROTO(struct xfs_btree_cur *cur, union xfs_btree_ptr *ptr, int stat, 2932 int error), 2933 TP_ARGS(cur, ptr, stat, error), 2934 TP_STRUCT__entry( 2935 __field(dev_t, dev) 2936 __field(xfs_agnumber_t, agno) 2937 __field(xfs_ino_t, ino) 2938 __string(name, cur->bc_ops->name) 2939 __field(int, error) 2940 __field(xfs_agblock_t, agbno) 2941 ), 2942 TP_fast_assign( 2943 __entry->dev = cur->bc_mp->m_super->s_dev; 2944 switch (cur->bc_ops->type) { 2945 case XFS_BTREE_TYPE_INODE: 2946 __entry->agno = 0; 2947 __entry->ino = cur->bc_ino.ip->i_ino; 2948 break; 2949 case XFS_BTREE_TYPE_AG: 2950 __entry->agno = cur->bc_group->xg_gno; 2951 __entry->ino = 0; 2952 break; 2953 case XFS_BTREE_TYPE_MEM: 2954 __entry->agno = 0; 2955 __entry->ino = 0; 2956 break; 2957 } 2958 __assign_str(name); 2959 __entry->error = error; 2960 if (!error && stat) { 2961 if (cur->bc_ops->ptr_len == XFS_BTREE_LONG_PTR_LEN) { 2962 xfs_fsblock_t fsb = be64_to_cpu(ptr->l); 2963 2964 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, 2965 fsb); 2966 __entry->agbno = XFS_FSB_TO_AGBNO(cur->bc_mp, 2967 fsb); 2968 } else { 2969 __entry->agbno = be32_to_cpu(ptr->s); 2970 } 2971 } else { 2972 __entry->agbno = NULLAGBLOCK; 2973 } 2974 ), 2975 TP_printk("dev %d:%d %sbt agno 0x%x ino 0x%llx agbno 0x%x error %d", 2976 MAJOR(__entry->dev), MINOR(__entry->dev), 2977 __get_str(name), 2978 __entry->agno, 2979 __entry->ino, 2980 __entry->agbno, 2981 __entry->error) 2982 ); 2983 2984 TRACE_EVENT(xfs_btree_free_block, 2985 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_buf *bp), 2986 TP_ARGS(cur, bp), 2987 TP_STRUCT__entry( 2988 __field(dev_t, dev) 2989 __field(xfs_agnumber_t, agno) 2990 __field(xfs_ino_t, ino) 2991 __string(name, cur->bc_ops->name) 2992 __field(xfs_agblock_t, agbno) 2993 ), 2994 TP_fast_assign( 2995 __entry->dev = cur->bc_mp->m_super->s_dev; 2996 __entry->agno = xfs_daddr_to_agno(cur->bc_mp, 2997 xfs_buf_daddr(bp)); 2998 if (cur->bc_ops->type == XFS_BTREE_TYPE_INODE) 2999 __entry->ino = cur->bc_ino.ip->i_ino; 3000 else 3001 __entry->ino = 0; 3002 __assign_str(name); 3003 __entry->agbno = xfs_daddr_to_agbno(cur->bc_mp, 3004 xfs_buf_daddr(bp)); 3005 ), 3006 TP_printk("dev %d:%d %sbt agno 0x%x ino 0x%llx agbno 0x%x", 3007 MAJOR(__entry->dev), MINOR(__entry->dev), 3008 __get_str(name), 3009 __entry->agno, 3010 __entry->ino, 3011 __entry->agbno) 3012 ); 3013 3014 /* deferred ops */ 3015 struct xfs_defer_pending; 3016 3017 DECLARE_EVENT_CLASS(xfs_defer_class, 3018 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), 3019 TP_ARGS(tp, caller_ip), 3020 TP_STRUCT__entry( 3021 __field(dev_t, dev) 3022 __field(struct xfs_trans *, tp) 3023 __field(char, committed) 3024 __field(unsigned long, caller_ip) 3025 ), 3026 TP_fast_assign( 3027 __entry->dev = tp->t_mountp->m_super->s_dev; 3028 __entry->tp = tp; 3029 __entry->caller_ip = caller_ip; 3030 ), 3031 TP_printk("dev %d:%d tp %p caller %pS", 3032 MAJOR(__entry->dev), MINOR(__entry->dev), 3033 __entry->tp, 3034 (char *)__entry->caller_ip) 3035 ) 3036 #define DEFINE_DEFER_EVENT(name) \ 3037 DEFINE_EVENT(xfs_defer_class, name, \ 3038 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), \ 3039 TP_ARGS(tp, caller_ip)) 3040 3041 DECLARE_EVENT_CLASS(xfs_defer_error_class, 3042 TP_PROTO(struct xfs_trans *tp, int error), 3043 TP_ARGS(tp, error), 3044 TP_STRUCT__entry( 3045 __field(dev_t, dev) 3046 __field(struct xfs_trans *, tp) 3047 __field(char, committed) 3048 __field(int, error) 3049 ), 3050 TP_fast_assign( 3051 __entry->dev = tp->t_mountp->m_super->s_dev; 3052 __entry->tp = tp; 3053 __entry->error = error; 3054 ), 3055 TP_printk("dev %d:%d tp %p err %d", 3056 MAJOR(__entry->dev), MINOR(__entry->dev), 3057 __entry->tp, 3058 __entry->error) 3059 ) 3060 #define DEFINE_DEFER_ERROR_EVENT(name) \ 3061 DEFINE_EVENT(xfs_defer_error_class, name, \ 3062 TP_PROTO(struct xfs_trans *tp, int error), \ 3063 TP_ARGS(tp, error)) 3064 3065 DECLARE_EVENT_CLASS(xfs_defer_pending_class, 3066 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), 3067 TP_ARGS(mp, dfp), 3068 TP_STRUCT__entry( 3069 __field(dev_t, dev) 3070 __string(name, dfp->dfp_ops->name) 3071 __field(void *, intent) 3072 __field(unsigned int, flags) 3073 __field(char, committed) 3074 __field(int, nr) 3075 ), 3076 TP_fast_assign( 3077 __entry->dev = mp ? mp->m_super->s_dev : 0; 3078 __assign_str(name); 3079 __entry->intent = dfp->dfp_intent; 3080 __entry->flags = dfp->dfp_flags; 3081 __entry->committed = dfp->dfp_done != NULL; 3082 __entry->nr = dfp->dfp_count; 3083 ), 3084 TP_printk("dev %d:%d optype %s intent %p flags %s committed %d nr %d", 3085 MAJOR(__entry->dev), MINOR(__entry->dev), 3086 __get_str(name), 3087 __entry->intent, 3088 __print_flags(__entry->flags, "|", XFS_DEFER_PENDING_STRINGS), 3089 __entry->committed, 3090 __entry->nr) 3091 ) 3092 #define DEFINE_DEFER_PENDING_EVENT(name) \ 3093 DEFINE_EVENT(xfs_defer_pending_class, name, \ 3094 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), \ 3095 TP_ARGS(mp, dfp)) 3096 3097 DEFINE_DEFER_EVENT(xfs_defer_cancel); 3098 DEFINE_DEFER_EVENT(xfs_defer_trans_roll); 3099 DEFINE_DEFER_EVENT(xfs_defer_trans_abort); 3100 DEFINE_DEFER_EVENT(xfs_defer_finish); 3101 DEFINE_DEFER_EVENT(xfs_defer_finish_done); 3102 3103 DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error); 3104 DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error); 3105 3106 DEFINE_DEFER_PENDING_EVENT(xfs_defer_create_intent); 3107 DEFINE_DEFER_PENDING_EVENT(xfs_defer_cancel_list); 3108 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish); 3109 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort); 3110 DEFINE_DEFER_PENDING_EVENT(xfs_defer_relog_intent); 3111 DEFINE_DEFER_PENDING_EVENT(xfs_defer_isolate_paused); 3112 DEFINE_DEFER_PENDING_EVENT(xfs_defer_item_pause); 3113 DEFINE_DEFER_PENDING_EVENT(xfs_defer_item_unpause); 3114 3115 DECLARE_EVENT_CLASS(xfs_free_extent_deferred_class, 3116 TP_PROTO(struct xfs_mount *mp, struct xfs_extent_free_item *free), 3117 TP_ARGS(mp, free), 3118 TP_STRUCT__entry( 3119 __field(dev_t, dev) 3120 __field(enum xfs_group_type, type) 3121 __field(xfs_agnumber_t, agno) 3122 __field(xfs_agblock_t, agbno) 3123 __field(xfs_extlen_t, len) 3124 __field(unsigned int, flags) 3125 ), 3126 TP_fast_assign( 3127 __entry->dev = mp->m_super->s_dev; 3128 __entry->type = free->xefi_group->xg_type; 3129 __entry->agno = free->xefi_group->xg_gno; 3130 __entry->agbno = xfs_fsb_to_gbno(mp, free->xefi_startblock, 3131 free->xefi_group->xg_type); 3132 __entry->len = free->xefi_blockcount; 3133 __entry->flags = free->xefi_flags; 3134 ), 3135 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x flags 0x%x", 3136 MAJOR(__entry->dev), MINOR(__entry->dev), 3137 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3138 __entry->agno, 3139 __entry->agbno, 3140 __entry->len, 3141 __entry->flags) 3142 ); 3143 #define DEFINE_FREE_EXTENT_DEFERRED_EVENT(name) \ 3144 DEFINE_EVENT(xfs_free_extent_deferred_class, name, \ 3145 TP_PROTO(struct xfs_mount *mp, struct xfs_extent_free_item *free), \ 3146 TP_ARGS(mp, free)) 3147 DEFINE_FREE_EXTENT_DEFERRED_EVENT(xfs_agfl_free_deferred); 3148 DEFINE_FREE_EXTENT_DEFERRED_EVENT(xfs_extent_free_defer); 3149 DEFINE_FREE_EXTENT_DEFERRED_EVENT(xfs_extent_free_deferred); 3150 3151 DECLARE_EVENT_CLASS(xfs_defer_pending_item_class, 3152 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp, 3153 void *item), 3154 TP_ARGS(mp, dfp, item), 3155 TP_STRUCT__entry( 3156 __field(dev_t, dev) 3157 __string(name, dfp->dfp_ops->name) 3158 __field(void *, intent) 3159 __field(void *, item) 3160 __field(char, committed) 3161 __field(unsigned int, flags) 3162 __field(int, nr) 3163 ), 3164 TP_fast_assign( 3165 __entry->dev = mp ? mp->m_super->s_dev : 0; 3166 __assign_str(name); 3167 __entry->intent = dfp->dfp_intent; 3168 __entry->item = item; 3169 __entry->committed = dfp->dfp_done != NULL; 3170 __entry->flags = dfp->dfp_flags; 3171 __entry->nr = dfp->dfp_count; 3172 ), 3173 TP_printk("dev %d:%d optype %s intent %p item %p flags %s committed %d nr %d", 3174 MAJOR(__entry->dev), MINOR(__entry->dev), 3175 __get_str(name), 3176 __entry->intent, 3177 __entry->item, 3178 __print_flags(__entry->flags, "|", XFS_DEFER_PENDING_STRINGS), 3179 __entry->committed, 3180 __entry->nr) 3181 ) 3182 #define DEFINE_DEFER_PENDING_ITEM_EVENT(name) \ 3183 DEFINE_EVENT(xfs_defer_pending_item_class, name, \ 3184 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp, \ 3185 void *item), \ 3186 TP_ARGS(mp, dfp, item)) 3187 3188 DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_add_item); 3189 DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_cancel_item); 3190 DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_finish_item); 3191 3192 /* rmap tracepoints */ 3193 DECLARE_EVENT_CLASS(xfs_rmap_class, 3194 TP_PROTO(struct xfs_btree_cur *cur, 3195 xfs_agblock_t gbno, xfs_extlen_t len, bool unwritten, 3196 const struct xfs_owner_info *oinfo), 3197 TP_ARGS(cur, gbno, len, unwritten, oinfo), 3198 TP_STRUCT__entry( 3199 __field(dev_t, dev) 3200 __field(enum xfs_group_type, type) 3201 __field(xfs_agnumber_t, agno) 3202 __field(xfs_agblock_t, gbno) 3203 __field(xfs_extlen_t, len) 3204 __field(uint64_t, owner) 3205 __field(uint64_t, offset) 3206 __field(unsigned long, flags) 3207 ), 3208 TP_fast_assign( 3209 __entry->dev = cur->bc_mp->m_super->s_dev; 3210 __entry->type = cur->bc_group->xg_type; 3211 __entry->agno = cur->bc_group->xg_gno; 3212 __entry->gbno = gbno; 3213 __entry->len = len; 3214 __entry->owner = oinfo->oi_owner; 3215 __entry->offset = oinfo->oi_offset; 3216 __entry->flags = oinfo->oi_flags; 3217 if (unwritten) 3218 __entry->flags |= XFS_RMAP_UNWRITTEN; 3219 ), 3220 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%lx", 3221 MAJOR(__entry->dev), MINOR(__entry->dev), 3222 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3223 __entry->agno, 3224 __entry->gbno, 3225 __entry->len, 3226 __entry->owner, 3227 __entry->offset, 3228 __entry->flags) 3229 ); 3230 #define DEFINE_RMAP_EVENT(name) \ 3231 DEFINE_EVENT(xfs_rmap_class, name, \ 3232 TP_PROTO(struct xfs_btree_cur *cur, \ 3233 xfs_agblock_t gbno, xfs_extlen_t len, bool unwritten, \ 3234 const struct xfs_owner_info *oinfo), \ 3235 TP_ARGS(cur, gbno, len, unwritten, oinfo)) 3236 3237 /* btree cursor error/%ip tracepoint class */ 3238 DECLARE_EVENT_CLASS(xfs_btree_error_class, 3239 TP_PROTO(struct xfs_btree_cur *cur, int error, 3240 unsigned long caller_ip), 3241 TP_ARGS(cur, error, caller_ip), 3242 TP_STRUCT__entry( 3243 __field(dev_t, dev) 3244 __field(xfs_agnumber_t, agno) 3245 __field(xfs_ino_t, ino) 3246 __field(int, error) 3247 __field(unsigned long, caller_ip) 3248 ), 3249 TP_fast_assign( 3250 __entry->dev = cur->bc_mp->m_super->s_dev; 3251 switch (cur->bc_ops->type) { 3252 case XFS_BTREE_TYPE_INODE: 3253 __entry->agno = 0; 3254 __entry->ino = cur->bc_ino.ip->i_ino; 3255 break; 3256 case XFS_BTREE_TYPE_AG: 3257 __entry->agno = cur->bc_group->xg_gno; 3258 __entry->ino = 0; 3259 break; 3260 case XFS_BTREE_TYPE_MEM: 3261 __entry->agno = 0; 3262 __entry->ino = 0; 3263 break; 3264 } 3265 __entry->error = error; 3266 __entry->caller_ip = caller_ip; 3267 ), 3268 TP_printk("dev %d:%d agno 0x%x ino 0x%llx error %d caller %pS", 3269 MAJOR(__entry->dev), MINOR(__entry->dev), 3270 __entry->agno, 3271 __entry->ino, 3272 __entry->error, 3273 (char *)__entry->caller_ip) 3274 ); 3275 3276 #define DEFINE_BTREE_ERROR_EVENT(name) \ 3277 DEFINE_EVENT(xfs_btree_error_class, name, \ 3278 TP_PROTO(struct xfs_btree_cur *cur, int error, \ 3279 unsigned long caller_ip), \ 3280 TP_ARGS(cur, error, caller_ip)) 3281 3282 DEFINE_RMAP_EVENT(xfs_rmap_unmap); 3283 DEFINE_RMAP_EVENT(xfs_rmap_unmap_done); 3284 DEFINE_BTREE_ERROR_EVENT(xfs_rmap_unmap_error); 3285 DEFINE_RMAP_EVENT(xfs_rmap_map); 3286 DEFINE_RMAP_EVENT(xfs_rmap_map_done); 3287 DEFINE_BTREE_ERROR_EVENT(xfs_rmap_map_error); 3288 DEFINE_RMAP_EVENT(xfs_rmap_convert); 3289 DEFINE_RMAP_EVENT(xfs_rmap_convert_done); 3290 DEFINE_BTREE_ERROR_EVENT(xfs_rmap_convert_error); 3291 3292 TRACE_EVENT(xfs_rmap_convert_state, 3293 TP_PROTO(struct xfs_btree_cur *cur, int state, 3294 unsigned long caller_ip), 3295 TP_ARGS(cur, state, caller_ip), 3296 TP_STRUCT__entry( 3297 __field(dev_t, dev) 3298 __field(enum xfs_group_type, type) 3299 __field(xfs_agnumber_t, agno) 3300 __field(int, state) 3301 __field(unsigned long, caller_ip) 3302 ), 3303 TP_fast_assign( 3304 __entry->dev = cur->bc_mp->m_super->s_dev; 3305 __entry->type = cur->bc_group->xg_type; 3306 __entry->agno = cur->bc_group->xg_gno; 3307 __entry->state = state; 3308 __entry->caller_ip = caller_ip; 3309 ), 3310 TP_printk("dev %d:%d %sno 0x%x state %d caller %pS", 3311 MAJOR(__entry->dev), MINOR(__entry->dev), 3312 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3313 __entry->agno, 3314 __entry->state, 3315 (char *)__entry->caller_ip) 3316 ); 3317 3318 DECLARE_EVENT_CLASS(xfs_rmapbt_class, 3319 TP_PROTO(struct xfs_btree_cur *cur, 3320 xfs_agblock_t gbno, xfs_extlen_t len, 3321 uint64_t owner, uint64_t offset, unsigned int flags), 3322 TP_ARGS(cur, gbno, len, owner, offset, flags), 3323 TP_STRUCT__entry( 3324 __field(dev_t, dev) 3325 __field(enum xfs_group_type, type) 3326 __field(xfs_agnumber_t, agno) 3327 __field(xfs_agblock_t, gbno) 3328 __field(xfs_extlen_t, len) 3329 __field(uint64_t, owner) 3330 __field(uint64_t, offset) 3331 __field(unsigned int, flags) 3332 ), 3333 TP_fast_assign( 3334 __entry->dev = cur->bc_mp->m_super->s_dev; 3335 __entry->type = cur->bc_group->xg_type; 3336 __entry->agno = cur->bc_group->xg_gno; 3337 __entry->gbno = gbno; 3338 __entry->len = len; 3339 __entry->owner = owner; 3340 __entry->offset = offset; 3341 __entry->flags = flags; 3342 ), 3343 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 3344 MAJOR(__entry->dev), MINOR(__entry->dev), 3345 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3346 __entry->agno, 3347 __entry->gbno, 3348 __entry->len, 3349 __entry->owner, 3350 __entry->offset, 3351 __entry->flags) 3352 ); 3353 #define DEFINE_RMAPBT_EVENT(name) \ 3354 DEFINE_EVENT(xfs_rmapbt_class, name, \ 3355 TP_PROTO(struct xfs_btree_cur *cur, \ 3356 xfs_agblock_t gbno, xfs_extlen_t len, \ 3357 uint64_t owner, uint64_t offset, unsigned int flags), \ 3358 TP_ARGS(cur, gbno, len, owner, offset, flags)) 3359 3360 TRACE_DEFINE_ENUM(XFS_RMAP_MAP); 3361 TRACE_DEFINE_ENUM(XFS_RMAP_MAP_SHARED); 3362 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP); 3363 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP_SHARED); 3364 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT); 3365 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT_SHARED); 3366 TRACE_DEFINE_ENUM(XFS_RMAP_ALLOC); 3367 TRACE_DEFINE_ENUM(XFS_RMAP_FREE); 3368 3369 DECLARE_EVENT_CLASS(xfs_rmap_deferred_class, 3370 TP_PROTO(struct xfs_mount *mp, struct xfs_rmap_intent *ri), 3371 TP_ARGS(mp, ri), 3372 TP_STRUCT__entry( 3373 __field(dev_t, dev) 3374 __field(unsigned long long, owner) 3375 __field(enum xfs_group_type, type) 3376 __field(xfs_agnumber_t, agno) 3377 __field(xfs_agblock_t, gbno) 3378 __field(int, whichfork) 3379 __field(xfs_fileoff_t, l_loff) 3380 __field(xfs_filblks_t, l_len) 3381 __field(xfs_exntst_t, l_state) 3382 __field(int, op) 3383 ), 3384 TP_fast_assign( 3385 __entry->dev = mp->m_super->s_dev; 3386 __entry->type = ri->ri_group->xg_type; 3387 __entry->agno = ri->ri_group->xg_gno; 3388 __entry->gbno = xfs_fsb_to_gbno(mp, 3389 ri->ri_bmap.br_startblock, 3390 ri->ri_group->xg_type); 3391 __entry->owner = ri->ri_owner; 3392 __entry->whichfork = ri->ri_whichfork; 3393 __entry->l_loff = ri->ri_bmap.br_startoff; 3394 __entry->l_len = ri->ri_bmap.br_blockcount; 3395 __entry->l_state = ri->ri_bmap.br_state; 3396 __entry->op = ri->ri_type; 3397 ), 3398 TP_printk("dev %d:%d op %s %sno 0x%x gbno 0x%x owner 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d", 3399 MAJOR(__entry->dev), MINOR(__entry->dev), 3400 __print_symbolic(__entry->op, XFS_RMAP_INTENT_STRINGS), 3401 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3402 __entry->agno, 3403 __entry->gbno, 3404 __entry->owner, 3405 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 3406 __entry->l_loff, 3407 __entry->l_len, 3408 __entry->l_state) 3409 ); 3410 #define DEFINE_RMAP_DEFERRED_EVENT(name) \ 3411 DEFINE_EVENT(xfs_rmap_deferred_class, name, \ 3412 TP_PROTO(struct xfs_mount *mp, struct xfs_rmap_intent *ri), \ 3413 TP_ARGS(mp, ri)) 3414 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_defer); 3415 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_deferred); 3416 3417 DEFINE_RMAPBT_EVENT(xfs_rmap_update); 3418 DEFINE_RMAPBT_EVENT(xfs_rmap_insert); 3419 DEFINE_RMAPBT_EVENT(xfs_rmap_delete); 3420 DEFINE_BTREE_ERROR_EVENT(xfs_rmap_insert_error); 3421 DEFINE_BTREE_ERROR_EVENT(xfs_rmap_delete_error); 3422 DEFINE_BTREE_ERROR_EVENT(xfs_rmap_update_error); 3423 3424 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_candidate); 3425 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_query); 3426 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_candidate); 3427 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range); 3428 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_result); 3429 DEFINE_RMAPBT_EVENT(xfs_rmap_find_right_neighbor_result); 3430 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_result); 3431 3432 /* deferred bmbt updates */ 3433 TRACE_DEFINE_ENUM(XFS_BMAP_MAP); 3434 TRACE_DEFINE_ENUM(XFS_BMAP_UNMAP); 3435 3436 DECLARE_EVENT_CLASS(xfs_bmap_deferred_class, 3437 TP_PROTO(struct xfs_bmap_intent *bi), 3438 TP_ARGS(bi), 3439 TP_STRUCT__entry( 3440 __field(dev_t, dev) 3441 __field(enum xfs_group_type, type) 3442 __field(xfs_agnumber_t, agno) 3443 __field(xfs_ino_t, ino) 3444 __field(unsigned long long, gbno) 3445 __field(int, whichfork) 3446 __field(xfs_fileoff_t, l_loff) 3447 __field(xfs_filblks_t, l_len) 3448 __field(xfs_exntst_t, l_state) 3449 __field(int, op) 3450 ), 3451 TP_fast_assign( 3452 struct xfs_inode *ip = bi->bi_owner; 3453 struct xfs_mount *mp = ip->i_mount; 3454 3455 __entry->dev = mp->m_super->s_dev; 3456 __entry->type = bi->bi_group->xg_type; 3457 __entry->agno = bi->bi_group->xg_gno; 3458 if (bi->bi_group->xg_type == XG_TYPE_RTG && 3459 !xfs_has_rtgroups(mp)) { 3460 /* 3461 * Legacy rt filesystems do not have allocation groups 3462 * ondisk. We emulate this incore with one gigantic 3463 * rtgroup whose size can exceed a 32-bit block number. 3464 * For this tracepoint, we report group 0 and a 64-bit 3465 * group block number. 3466 */ 3467 __entry->gbno = bi->bi_bmap.br_startblock; 3468 } else { 3469 __entry->gbno = xfs_fsb_to_gbno(mp, 3470 bi->bi_bmap.br_startblock, 3471 bi->bi_group->xg_type); 3472 } 3473 __entry->ino = ip->i_ino; 3474 __entry->whichfork = bi->bi_whichfork; 3475 __entry->l_loff = bi->bi_bmap.br_startoff; 3476 __entry->l_len = bi->bi_bmap.br_blockcount; 3477 __entry->l_state = bi->bi_bmap.br_state; 3478 __entry->op = bi->bi_type; 3479 ), 3480 TP_printk("dev %d:%d op %s ino 0x%llx %sno 0x%x gbno 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d", 3481 MAJOR(__entry->dev), MINOR(__entry->dev), 3482 __print_symbolic(__entry->op, XFS_BMAP_INTENT_STRINGS), 3483 __entry->ino, 3484 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3485 __entry->agno, 3486 __entry->gbno, 3487 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 3488 __entry->l_loff, 3489 __entry->l_len, 3490 __entry->l_state) 3491 ); 3492 #define DEFINE_BMAP_DEFERRED_EVENT(name) \ 3493 DEFINE_EVENT(xfs_bmap_deferred_class, name, \ 3494 TP_PROTO(struct xfs_bmap_intent *bi), \ 3495 TP_ARGS(bi)) 3496 DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_defer); 3497 DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_deferred); 3498 3499 /* per-AG reservation */ 3500 DECLARE_EVENT_CLASS(xfs_ag_resv_class, 3501 TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type resv, 3502 xfs_extlen_t len), 3503 TP_ARGS(pag, resv, len), 3504 TP_STRUCT__entry( 3505 __field(dev_t, dev) 3506 __field(xfs_agnumber_t, agno) 3507 __field(int, resv) 3508 __field(xfs_extlen_t, freeblks) 3509 __field(xfs_extlen_t, flcount) 3510 __field(xfs_extlen_t, reserved) 3511 __field(xfs_extlen_t, asked) 3512 __field(xfs_extlen_t, len) 3513 ), 3514 TP_fast_assign( 3515 struct xfs_ag_resv *r = xfs_perag_resv(pag, resv); 3516 3517 __entry->dev = pag_mount(pag)->m_super->s_dev; 3518 __entry->agno = pag_agno(pag); 3519 __entry->resv = resv; 3520 __entry->freeblks = pag->pagf_freeblks; 3521 __entry->flcount = pag->pagf_flcount; 3522 __entry->reserved = r ? r->ar_reserved : 0; 3523 __entry->asked = r ? r->ar_asked : 0; 3524 __entry->len = len; 3525 ), 3526 TP_printk("dev %d:%d agno 0x%x resv %d freeblks %u flcount %u " 3527 "resv %u ask %u len %u", 3528 MAJOR(__entry->dev), MINOR(__entry->dev), 3529 __entry->agno, 3530 __entry->resv, 3531 __entry->freeblks, 3532 __entry->flcount, 3533 __entry->reserved, 3534 __entry->asked, 3535 __entry->len) 3536 ) 3537 #define DEFINE_AG_RESV_EVENT(name) \ 3538 DEFINE_EVENT(xfs_ag_resv_class, name, \ 3539 TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type type, \ 3540 xfs_extlen_t len), \ 3541 TP_ARGS(pag, type, len)) 3542 3543 /* per-AG reservation tracepoints */ 3544 DEFINE_AG_RESV_EVENT(xfs_ag_resv_init); 3545 DEFINE_AG_RESV_EVENT(xfs_ag_resv_free); 3546 DEFINE_AG_RESV_EVENT(xfs_ag_resv_alloc_extent); 3547 DEFINE_AG_RESV_EVENT(xfs_ag_resv_free_extent); 3548 DEFINE_AG_RESV_EVENT(xfs_ag_resv_critical); 3549 DEFINE_AG_RESV_EVENT(xfs_ag_resv_needed); 3550 3551 TRACE_EVENT(xfs_ag_resv_init_error, 3552 TP_PROTO(const struct xfs_perag *pag, int error, 3553 unsigned long caller_ip), 3554 TP_ARGS(pag, error, caller_ip), 3555 TP_STRUCT__entry( 3556 __field(dev_t, dev) 3557 __field(xfs_agnumber_t, agno) 3558 __field(int, error) 3559 __field(unsigned long, caller_ip) 3560 ), 3561 TP_fast_assign( 3562 __entry->dev = pag_mount(pag)->m_super->s_dev; 3563 __entry->agno = pag_agno(pag); 3564 __entry->error = error; 3565 __entry->caller_ip = caller_ip; 3566 ), 3567 TP_printk("dev %d:%d agno 0x%x error %d caller %pS", 3568 MAJOR(__entry->dev), MINOR(__entry->dev), 3569 __entry->agno, 3570 __entry->error, 3571 (char *)__entry->caller_ip) 3572 ); 3573 3574 /* refcount tracepoint classes */ 3575 3576 DECLARE_EVENT_CLASS(xfs_refcount_class, 3577 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t gbno, 3578 xfs_extlen_t len), 3579 TP_ARGS(cur, gbno, len), 3580 TP_STRUCT__entry( 3581 __field(dev_t, dev) 3582 __field(enum xfs_group_type, type) 3583 __field(xfs_agnumber_t, agno) 3584 __field(xfs_agblock_t, gbno) 3585 __field(xfs_extlen_t, len) 3586 ), 3587 TP_fast_assign( 3588 __entry->dev = cur->bc_mp->m_super->s_dev; 3589 __entry->type = cur->bc_group->xg_type; 3590 __entry->agno = cur->bc_group->xg_gno; 3591 __entry->gbno = gbno; 3592 __entry->len = len; 3593 ), 3594 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x", 3595 MAJOR(__entry->dev), MINOR(__entry->dev), 3596 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3597 __entry->agno, 3598 __entry->gbno, 3599 __entry->len) 3600 ); 3601 #define DEFINE_REFCOUNT_EVENT(name) \ 3602 DEFINE_EVENT(xfs_refcount_class, name, \ 3603 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t gbno, \ 3604 xfs_extlen_t len), \ 3605 TP_ARGS(cur, gbno, len)) 3606 3607 TRACE_DEFINE_ENUM(XFS_LOOKUP_EQi); 3608 TRACE_DEFINE_ENUM(XFS_LOOKUP_LEi); 3609 TRACE_DEFINE_ENUM(XFS_LOOKUP_GEi); 3610 TRACE_EVENT(xfs_refcount_lookup, 3611 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t gbno, 3612 xfs_lookup_t dir), 3613 TP_ARGS(cur, gbno, dir), 3614 TP_STRUCT__entry( 3615 __field(dev_t, dev) 3616 __field(enum xfs_group_type, type) 3617 __field(xfs_agnumber_t, agno) 3618 __field(xfs_agblock_t, gbno) 3619 __field(xfs_lookup_t, dir) 3620 ), 3621 TP_fast_assign( 3622 __entry->dev = cur->bc_mp->m_super->s_dev; 3623 __entry->type = cur->bc_group->xg_type; 3624 __entry->agno = cur->bc_group->xg_gno; 3625 __entry->gbno = gbno; 3626 __entry->dir = dir; 3627 ), 3628 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x cmp %s(%d)", 3629 MAJOR(__entry->dev), MINOR(__entry->dev), 3630 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3631 __entry->agno, 3632 __entry->gbno, 3633 __print_symbolic(__entry->dir, XFS_AG_BTREE_CMP_FORMAT_STR), 3634 __entry->dir) 3635 ) 3636 3637 /* single-rcext tracepoint class */ 3638 DECLARE_EVENT_CLASS(xfs_refcount_extent_class, 3639 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec), 3640 TP_ARGS(cur, irec), 3641 TP_STRUCT__entry( 3642 __field(dev_t, dev) 3643 __field(enum xfs_group_type, type) 3644 __field(xfs_agnumber_t, agno) 3645 __field(enum xfs_refc_domain, domain) 3646 __field(xfs_agblock_t, startblock) 3647 __field(xfs_extlen_t, blockcount) 3648 __field(xfs_nlink_t, refcount) 3649 ), 3650 TP_fast_assign( 3651 __entry->dev = cur->bc_mp->m_super->s_dev; 3652 __entry->type = cur->bc_group->xg_type; 3653 __entry->agno = cur->bc_group->xg_gno; 3654 __entry->domain = irec->rc_domain; 3655 __entry->startblock = irec->rc_startblock; 3656 __entry->blockcount = irec->rc_blockcount; 3657 __entry->refcount = irec->rc_refcount; 3658 ), 3659 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u", 3660 MAJOR(__entry->dev), MINOR(__entry->dev), 3661 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3662 __entry->agno, 3663 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 3664 __entry->startblock, 3665 __entry->blockcount, 3666 __entry->refcount) 3667 ) 3668 3669 #define DEFINE_REFCOUNT_EXTENT_EVENT(name) \ 3670 DEFINE_EVENT(xfs_refcount_extent_class, name, \ 3671 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec), \ 3672 TP_ARGS(cur, irec)) 3673 3674 /* single-rcext and an agbno tracepoint class */ 3675 DECLARE_EVENT_CLASS(xfs_refcount_extent_at_class, 3676 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec, 3677 xfs_agblock_t gbno), 3678 TP_ARGS(cur, irec, gbno), 3679 TP_STRUCT__entry( 3680 __field(dev_t, dev) 3681 __field(enum xfs_group_type, type) 3682 __field(xfs_agnumber_t, agno) 3683 __field(enum xfs_refc_domain, domain) 3684 __field(xfs_agblock_t, startblock) 3685 __field(xfs_extlen_t, blockcount) 3686 __field(xfs_nlink_t, refcount) 3687 __field(xfs_agblock_t, gbno) 3688 ), 3689 TP_fast_assign( 3690 __entry->dev = cur->bc_mp->m_super->s_dev; 3691 __entry->type = cur->bc_group->xg_type; 3692 __entry->agno = cur->bc_group->xg_gno; 3693 __entry->domain = irec->rc_domain; 3694 __entry->startblock = irec->rc_startblock; 3695 __entry->blockcount = irec->rc_blockcount; 3696 __entry->refcount = irec->rc_refcount; 3697 __entry->gbno = gbno; 3698 ), 3699 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u @ gbno 0x%x", 3700 MAJOR(__entry->dev), MINOR(__entry->dev), 3701 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3702 __entry->agno, 3703 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 3704 __entry->startblock, 3705 __entry->blockcount, 3706 __entry->refcount, 3707 __entry->gbno) 3708 ) 3709 3710 #define DEFINE_REFCOUNT_EXTENT_AT_EVENT(name) \ 3711 DEFINE_EVENT(xfs_refcount_extent_at_class, name, \ 3712 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec, \ 3713 xfs_agblock_t gbno), \ 3714 TP_ARGS(cur, irec, gbno)) 3715 3716 /* double-rcext tracepoint class */ 3717 DECLARE_EVENT_CLASS(xfs_refcount_double_extent_class, 3718 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, 3719 struct xfs_refcount_irec *i2), 3720 TP_ARGS(cur, i1, i2), 3721 TP_STRUCT__entry( 3722 __field(dev_t, dev) 3723 __field(enum xfs_group_type, type) 3724 __field(xfs_agnumber_t, agno) 3725 __field(enum xfs_refc_domain, i1_domain) 3726 __field(xfs_agblock_t, i1_startblock) 3727 __field(xfs_extlen_t, i1_blockcount) 3728 __field(xfs_nlink_t, i1_refcount) 3729 __field(enum xfs_refc_domain, i2_domain) 3730 __field(xfs_agblock_t, i2_startblock) 3731 __field(xfs_extlen_t, i2_blockcount) 3732 __field(xfs_nlink_t, i2_refcount) 3733 ), 3734 TP_fast_assign( 3735 __entry->dev = cur->bc_mp->m_super->s_dev; 3736 __entry->type = cur->bc_group->xg_type; 3737 __entry->agno = cur->bc_group->xg_gno; 3738 __entry->i1_domain = i1->rc_domain; 3739 __entry->i1_startblock = i1->rc_startblock; 3740 __entry->i1_blockcount = i1->rc_blockcount; 3741 __entry->i1_refcount = i1->rc_refcount; 3742 __entry->i2_domain = i2->rc_domain; 3743 __entry->i2_startblock = i2->rc_startblock; 3744 __entry->i2_blockcount = i2->rc_blockcount; 3745 __entry->i2_refcount = i2->rc_refcount; 3746 ), 3747 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3748 "dom %s gbno 0x%x fsbcount 0x%x refcount %u", 3749 MAJOR(__entry->dev), MINOR(__entry->dev), 3750 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3751 __entry->agno, 3752 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3753 __entry->i1_startblock, 3754 __entry->i1_blockcount, 3755 __entry->i1_refcount, 3756 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3757 __entry->i2_startblock, 3758 __entry->i2_blockcount, 3759 __entry->i2_refcount) 3760 ) 3761 3762 #define DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(name) \ 3763 DEFINE_EVENT(xfs_refcount_double_extent_class, name, \ 3764 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, \ 3765 struct xfs_refcount_irec *i2), \ 3766 TP_ARGS(cur, i1, i2)) 3767 3768 /* double-rcext and an agbno tracepoint class */ 3769 DECLARE_EVENT_CLASS(xfs_refcount_double_extent_at_class, 3770 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, 3771 struct xfs_refcount_irec *i2, xfs_agblock_t gbno), 3772 TP_ARGS(cur, i1, i2, gbno), 3773 TP_STRUCT__entry( 3774 __field(dev_t, dev) 3775 __field(enum xfs_group_type, type) 3776 __field(xfs_agnumber_t, agno) 3777 __field(enum xfs_refc_domain, i1_domain) 3778 __field(xfs_agblock_t, i1_startblock) 3779 __field(xfs_extlen_t, i1_blockcount) 3780 __field(xfs_nlink_t, i1_refcount) 3781 __field(enum xfs_refc_domain, i2_domain) 3782 __field(xfs_agblock_t, i2_startblock) 3783 __field(xfs_extlen_t, i2_blockcount) 3784 __field(xfs_nlink_t, i2_refcount) 3785 __field(xfs_agblock_t, gbno) 3786 ), 3787 TP_fast_assign( 3788 __entry->dev = cur->bc_mp->m_super->s_dev; 3789 __entry->type = cur->bc_group->xg_type; 3790 __entry->agno = cur->bc_group->xg_gno; 3791 __entry->i1_domain = i1->rc_domain; 3792 __entry->i1_startblock = i1->rc_startblock; 3793 __entry->i1_blockcount = i1->rc_blockcount; 3794 __entry->i1_refcount = i1->rc_refcount; 3795 __entry->i2_domain = i2->rc_domain; 3796 __entry->i2_startblock = i2->rc_startblock; 3797 __entry->i2_blockcount = i2->rc_blockcount; 3798 __entry->i2_refcount = i2->rc_refcount; 3799 __entry->gbno = gbno; 3800 ), 3801 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3802 "dom %s gbno 0x%x fsbcount 0x%x refcount %u @ gbno 0x%x", 3803 MAJOR(__entry->dev), MINOR(__entry->dev), 3804 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3805 __entry->agno, 3806 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3807 __entry->i1_startblock, 3808 __entry->i1_blockcount, 3809 __entry->i1_refcount, 3810 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3811 __entry->i2_startblock, 3812 __entry->i2_blockcount, 3813 __entry->i2_refcount, 3814 __entry->gbno) 3815 ) 3816 3817 #define DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(name) \ 3818 DEFINE_EVENT(xfs_refcount_double_extent_at_class, name, \ 3819 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, \ 3820 struct xfs_refcount_irec *i2, xfs_agblock_t gbno), \ 3821 TP_ARGS(cur, i1, i2, gbno)) 3822 3823 /* triple-rcext tracepoint class */ 3824 DECLARE_EVENT_CLASS(xfs_refcount_triple_extent_class, 3825 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, 3826 struct xfs_refcount_irec *i2, struct xfs_refcount_irec *i3), 3827 TP_ARGS(cur, i1, i2, i3), 3828 TP_STRUCT__entry( 3829 __field(dev_t, dev) 3830 __field(enum xfs_group_type, type) 3831 __field(xfs_agnumber_t, agno) 3832 __field(enum xfs_refc_domain, i1_domain) 3833 __field(xfs_agblock_t, i1_startblock) 3834 __field(xfs_extlen_t, i1_blockcount) 3835 __field(xfs_nlink_t, i1_refcount) 3836 __field(enum xfs_refc_domain, i2_domain) 3837 __field(xfs_agblock_t, i2_startblock) 3838 __field(xfs_extlen_t, i2_blockcount) 3839 __field(xfs_nlink_t, i2_refcount) 3840 __field(enum xfs_refc_domain, i3_domain) 3841 __field(xfs_agblock_t, i3_startblock) 3842 __field(xfs_extlen_t, i3_blockcount) 3843 __field(xfs_nlink_t, i3_refcount) 3844 ), 3845 TP_fast_assign( 3846 __entry->dev = cur->bc_mp->m_super->s_dev; 3847 __entry->type = cur->bc_group->xg_type; 3848 __entry->agno = cur->bc_group->xg_gno; 3849 __entry->i1_domain = i1->rc_domain; 3850 __entry->i1_startblock = i1->rc_startblock; 3851 __entry->i1_blockcount = i1->rc_blockcount; 3852 __entry->i1_refcount = i1->rc_refcount; 3853 __entry->i2_domain = i2->rc_domain; 3854 __entry->i2_startblock = i2->rc_startblock; 3855 __entry->i2_blockcount = i2->rc_blockcount; 3856 __entry->i2_refcount = i2->rc_refcount; 3857 __entry->i3_domain = i3->rc_domain; 3858 __entry->i3_startblock = i3->rc_startblock; 3859 __entry->i3_blockcount = i3->rc_blockcount; 3860 __entry->i3_refcount = i3->rc_refcount; 3861 ), 3862 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3863 "dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3864 "dom %s gbno 0x%x fsbcount 0x%x refcount %u", 3865 MAJOR(__entry->dev), MINOR(__entry->dev), 3866 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3867 __entry->agno, 3868 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3869 __entry->i1_startblock, 3870 __entry->i1_blockcount, 3871 __entry->i1_refcount, 3872 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3873 __entry->i2_startblock, 3874 __entry->i2_blockcount, 3875 __entry->i2_refcount, 3876 __print_symbolic(__entry->i3_domain, XFS_REFC_DOMAIN_STRINGS), 3877 __entry->i3_startblock, 3878 __entry->i3_blockcount, 3879 __entry->i3_refcount) 3880 ); 3881 3882 #define DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(name) \ 3883 DEFINE_EVENT(xfs_refcount_triple_extent_class, name, \ 3884 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, \ 3885 struct xfs_refcount_irec *i2, struct xfs_refcount_irec *i3), \ 3886 TP_ARGS(cur, i1, i2, i3)) 3887 3888 /* refcount btree tracepoints */ 3889 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_get); 3890 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_update); 3891 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_insert); 3892 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_delete); 3893 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_insert_error); 3894 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_delete_error); 3895 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_update_error); 3896 3897 /* refcount adjustment tracepoints */ 3898 DEFINE_REFCOUNT_EVENT(xfs_refcount_increase); 3899 DEFINE_REFCOUNT_EVENT(xfs_refcount_decrease); 3900 DEFINE_REFCOUNT_EVENT(xfs_refcount_cow_increase); 3901 DEFINE_REFCOUNT_EVENT(xfs_refcount_cow_decrease); 3902 DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(xfs_refcount_merge_center_extents); 3903 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_modify_extent); 3904 DEFINE_REFCOUNT_EXTENT_AT_EVENT(xfs_refcount_split_extent); 3905 DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_left_extent); 3906 DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_right_extent); 3907 DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_left_extent); 3908 DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_right_extent); 3909 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_adjust_error); 3910 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_adjust_cow_error); 3911 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_merge_center_extents_error); 3912 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_modify_extent_error); 3913 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_split_extent_error); 3914 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_merge_left_extent_error); 3915 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_merge_right_extent_error); 3916 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_find_left_extent_error); 3917 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_find_right_extent_error); 3918 3919 /* reflink helpers */ 3920 DEFINE_REFCOUNT_EVENT(xfs_refcount_find_shared); 3921 DEFINE_REFCOUNT_EVENT(xfs_refcount_find_shared_result); 3922 DEFINE_BTREE_ERROR_EVENT(xfs_refcount_find_shared_error); 3923 3924 TRACE_DEFINE_ENUM(XFS_REFCOUNT_INCREASE); 3925 TRACE_DEFINE_ENUM(XFS_REFCOUNT_DECREASE); 3926 TRACE_DEFINE_ENUM(XFS_REFCOUNT_ALLOC_COW); 3927 TRACE_DEFINE_ENUM(XFS_REFCOUNT_FREE_COW); 3928 3929 DECLARE_EVENT_CLASS(xfs_refcount_deferred_class, 3930 TP_PROTO(struct xfs_mount *mp, struct xfs_refcount_intent *refc), 3931 TP_ARGS(mp, refc), 3932 TP_STRUCT__entry( 3933 __field(dev_t, dev) 3934 __field(enum xfs_group_type, type) 3935 __field(xfs_agnumber_t, agno) 3936 __field(int, op) 3937 __field(xfs_agblock_t, gbno) 3938 __field(xfs_extlen_t, len) 3939 ), 3940 TP_fast_assign( 3941 __entry->dev = mp->m_super->s_dev; 3942 __entry->type = refc->ri_group->xg_type; 3943 __entry->agno = refc->ri_group->xg_gno; 3944 __entry->op = refc->ri_type; 3945 __entry->gbno = xfs_fsb_to_gbno(mp, refc->ri_startblock, 3946 refc->ri_group->xg_type); 3947 __entry->len = refc->ri_blockcount; 3948 ), 3949 TP_printk("dev %d:%d op %s %sno 0x%x gbno 0x%x fsbcount 0x%x", 3950 MAJOR(__entry->dev), MINOR(__entry->dev), 3951 __print_symbolic(__entry->op, XFS_REFCOUNT_INTENT_STRINGS), 3952 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3953 __entry->agno, 3954 __entry->gbno, 3955 __entry->len) 3956 ); 3957 #define DEFINE_REFCOUNT_DEFERRED_EVENT(name) \ 3958 DEFINE_EVENT(xfs_refcount_deferred_class, name, \ 3959 TP_PROTO(struct xfs_mount *mp, struct xfs_refcount_intent *refc), \ 3960 TP_ARGS(mp, refc)) 3961 DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_defer); 3962 DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_deferred); 3963 DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_finish_one_leftover); 3964 3965 /* simple inode-based error/%ip tracepoint class */ 3966 DECLARE_EVENT_CLASS(xfs_inode_error_class, 3967 TP_PROTO(struct xfs_inode *ip, int error, unsigned long caller_ip), 3968 TP_ARGS(ip, error, caller_ip), 3969 TP_STRUCT__entry( 3970 __field(dev_t, dev) 3971 __field(xfs_ino_t, ino) 3972 __field(int, error) 3973 __field(unsigned long, caller_ip) 3974 ), 3975 TP_fast_assign( 3976 __entry->dev = VFS_I(ip)->i_sb->s_dev; 3977 __entry->ino = ip->i_ino; 3978 __entry->error = error; 3979 __entry->caller_ip = caller_ip; 3980 ), 3981 TP_printk("dev %d:%d ino 0x%llx error %d caller %pS", 3982 MAJOR(__entry->dev), MINOR(__entry->dev), 3983 __entry->ino, 3984 __entry->error, 3985 (char *)__entry->caller_ip) 3986 ); 3987 3988 #define DEFINE_INODE_ERROR_EVENT(name) \ 3989 DEFINE_EVENT(xfs_inode_error_class, name, \ 3990 TP_PROTO(struct xfs_inode *ip, int error, \ 3991 unsigned long caller_ip), \ 3992 TP_ARGS(ip, error, caller_ip)) 3993 3994 /* reflink tracepoint classes */ 3995 3996 /* two-file io tracepoint class */ 3997 DECLARE_EVENT_CLASS(xfs_double_io_class, 3998 TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len, 3999 struct xfs_inode *dest, xfs_off_t doffset), 4000 TP_ARGS(src, soffset, len, dest, doffset), 4001 TP_STRUCT__entry( 4002 __field(dev_t, dev) 4003 __field(xfs_ino_t, src_ino) 4004 __field(loff_t, src_isize) 4005 __field(loff_t, src_disize) 4006 __field(loff_t, src_offset) 4007 __field(long long, len) 4008 __field(xfs_ino_t, dest_ino) 4009 __field(loff_t, dest_isize) 4010 __field(loff_t, dest_disize) 4011 __field(loff_t, dest_offset) 4012 ), 4013 TP_fast_assign( 4014 __entry->dev = VFS_I(src)->i_sb->s_dev; 4015 __entry->src_ino = src->i_ino; 4016 __entry->src_isize = VFS_I(src)->i_size; 4017 __entry->src_disize = src->i_disk_size; 4018 __entry->src_offset = soffset; 4019 __entry->len = len; 4020 __entry->dest_ino = dest->i_ino; 4021 __entry->dest_isize = VFS_I(dest)->i_size; 4022 __entry->dest_disize = dest->i_disk_size; 4023 __entry->dest_offset = doffset; 4024 ), 4025 TP_printk("dev %d:%d bytecount 0x%llx " 4026 "ino 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx -> " 4027 "ino 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx", 4028 MAJOR(__entry->dev), MINOR(__entry->dev), 4029 __entry->len, 4030 __entry->src_ino, 4031 __entry->src_isize, 4032 __entry->src_disize, 4033 __entry->src_offset, 4034 __entry->dest_ino, 4035 __entry->dest_isize, 4036 __entry->dest_disize, 4037 __entry->dest_offset) 4038 ) 4039 4040 #define DEFINE_DOUBLE_IO_EVENT(name) \ 4041 DEFINE_EVENT(xfs_double_io_class, name, \ 4042 TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len, \ 4043 struct xfs_inode *dest, xfs_off_t doffset), \ 4044 TP_ARGS(src, soffset, len, dest, doffset)) 4045 4046 /* inode/irec events */ 4047 DECLARE_EVENT_CLASS(xfs_inode_irec_class, 4048 TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec), 4049 TP_ARGS(ip, irec), 4050 TP_STRUCT__entry( 4051 __field(dev_t, dev) 4052 __field(xfs_ino_t, ino) 4053 __field(xfs_fileoff_t, lblk) 4054 __field(xfs_extlen_t, len) 4055 __field(xfs_fsblock_t, pblk) 4056 __field(int, state) 4057 ), 4058 TP_fast_assign( 4059 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4060 __entry->ino = ip->i_ino; 4061 __entry->lblk = irec->br_startoff; 4062 __entry->len = irec->br_blockcount; 4063 __entry->pblk = irec->br_startblock; 4064 __entry->state = irec->br_state; 4065 ), 4066 TP_printk("dev %d:%d ino 0x%llx fileoff 0x%llx fsbcount 0x%x startblock 0x%llx st %d", 4067 MAJOR(__entry->dev), MINOR(__entry->dev), 4068 __entry->ino, 4069 __entry->lblk, 4070 __entry->len, 4071 __entry->pblk, 4072 __entry->state) 4073 ); 4074 #define DEFINE_INODE_IREC_EVENT(name) \ 4075 DEFINE_EVENT(xfs_inode_irec_class, name, \ 4076 TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec), \ 4077 TP_ARGS(ip, irec)) 4078 4079 /* inode iomap invalidation events */ 4080 DECLARE_EVENT_CLASS(xfs_wb_invalid_class, 4081 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap, unsigned int wpcseq, int whichfork), 4082 TP_ARGS(ip, iomap, wpcseq, whichfork), 4083 TP_STRUCT__entry( 4084 __field(dev_t, dev) 4085 __field(xfs_ino_t, ino) 4086 __field(u64, addr) 4087 __field(loff_t, pos) 4088 __field(u64, len) 4089 __field(u16, type) 4090 __field(u16, flags) 4091 __field(u32, wpcseq) 4092 __field(u32, forkseq) 4093 ), 4094 TP_fast_assign( 4095 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4096 __entry->ino = ip->i_ino; 4097 __entry->addr = iomap->addr; 4098 __entry->pos = iomap->offset; 4099 __entry->len = iomap->length; 4100 __entry->type = iomap->type; 4101 __entry->flags = iomap->flags; 4102 __entry->wpcseq = wpcseq; 4103 __entry->forkseq = READ_ONCE(xfs_ifork_ptr(ip, whichfork)->if_seq); 4104 ), 4105 TP_printk("dev %d:%d ino 0x%llx pos 0x%llx addr 0x%llx bytecount 0x%llx type 0x%x flags 0x%x wpcseq 0x%x forkseq 0x%x", 4106 MAJOR(__entry->dev), MINOR(__entry->dev), 4107 __entry->ino, 4108 __entry->pos, 4109 __entry->addr, 4110 __entry->len, 4111 __entry->type, 4112 __entry->flags, 4113 __entry->wpcseq, 4114 __entry->forkseq) 4115 ); 4116 #define DEFINE_WB_INVALID_EVENT(name) \ 4117 DEFINE_EVENT(xfs_wb_invalid_class, name, \ 4118 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap, unsigned int wpcseq, int whichfork), \ 4119 TP_ARGS(ip, iomap, wpcseq, whichfork)) 4120 DEFINE_WB_INVALID_EVENT(xfs_wb_cow_iomap_invalid); 4121 DEFINE_WB_INVALID_EVENT(xfs_wb_data_iomap_invalid); 4122 4123 DECLARE_EVENT_CLASS(xfs_iomap_invalid_class, 4124 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap), 4125 TP_ARGS(ip, iomap), 4126 TP_STRUCT__entry( 4127 __field(dev_t, dev) 4128 __field(xfs_ino_t, ino) 4129 __field(u64, addr) 4130 __field(loff_t, pos) 4131 __field(u64, len) 4132 __field(u64, validity_cookie) 4133 __field(u64, inodeseq) 4134 __field(u16, type) 4135 __field(u16, flags) 4136 ), 4137 TP_fast_assign( 4138 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4139 __entry->ino = ip->i_ino; 4140 __entry->addr = iomap->addr; 4141 __entry->pos = iomap->offset; 4142 __entry->len = iomap->length; 4143 __entry->validity_cookie = iomap->validity_cookie; 4144 __entry->type = iomap->type; 4145 __entry->flags = iomap->flags; 4146 __entry->inodeseq = xfs_iomap_inode_sequence(ip, iomap->flags); 4147 ), 4148 TP_printk("dev %d:%d ino 0x%llx pos 0x%llx addr 0x%llx bytecount 0x%llx type 0x%x flags 0x%x validity_cookie 0x%llx inodeseq 0x%llx", 4149 MAJOR(__entry->dev), MINOR(__entry->dev), 4150 __entry->ino, 4151 __entry->pos, 4152 __entry->addr, 4153 __entry->len, 4154 __entry->type, 4155 __entry->flags, 4156 __entry->validity_cookie, 4157 __entry->inodeseq) 4158 ); 4159 #define DEFINE_IOMAP_INVALID_EVENT(name) \ 4160 DEFINE_EVENT(xfs_iomap_invalid_class, name, \ 4161 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap), \ 4162 TP_ARGS(ip, iomap)) 4163 DEFINE_IOMAP_INVALID_EVENT(xfs_iomap_invalid); 4164 4165 /* refcount/reflink tracepoint definitions */ 4166 4167 /* reflink tracepoints */ 4168 DEFINE_INODE_EVENT(xfs_reflink_set_inode_flag); 4169 DEFINE_INODE_EVENT(xfs_reflink_unset_inode_flag); 4170 DEFINE_ITRUNC_EVENT(xfs_reflink_update_inode_size); 4171 TRACE_EVENT(xfs_reflink_remap_blocks, 4172 TP_PROTO(struct xfs_inode *src, xfs_fileoff_t soffset, 4173 xfs_filblks_t len, struct xfs_inode *dest, 4174 xfs_fileoff_t doffset), 4175 TP_ARGS(src, soffset, len, dest, doffset), 4176 TP_STRUCT__entry( 4177 __field(dev_t, dev) 4178 __field(xfs_ino_t, src_ino) 4179 __field(xfs_fileoff_t, src_lblk) 4180 __field(xfs_filblks_t, len) 4181 __field(xfs_ino_t, dest_ino) 4182 __field(xfs_fileoff_t, dest_lblk) 4183 ), 4184 TP_fast_assign( 4185 __entry->dev = VFS_I(src)->i_sb->s_dev; 4186 __entry->src_ino = src->i_ino; 4187 __entry->src_lblk = soffset; 4188 __entry->len = len; 4189 __entry->dest_ino = dest->i_ino; 4190 __entry->dest_lblk = doffset; 4191 ), 4192 TP_printk("dev %d:%d fsbcount 0x%llx " 4193 "ino 0x%llx fileoff 0x%llx -> ino 0x%llx fileoff 0x%llx", 4194 MAJOR(__entry->dev), MINOR(__entry->dev), 4195 __entry->len, 4196 __entry->src_ino, 4197 __entry->src_lblk, 4198 __entry->dest_ino, 4199 __entry->dest_lblk) 4200 ); 4201 DEFINE_DOUBLE_IO_EVENT(xfs_reflink_remap_range); 4202 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_range_error); 4203 DEFINE_INODE_ERROR_EVENT(xfs_reflink_set_inode_flag_error); 4204 DEFINE_INODE_ERROR_EVENT(xfs_reflink_update_inode_size_error); 4205 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_blocks_error); 4206 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_extent_error); 4207 DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_src); 4208 DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_dest); 4209 4210 /* unshare tracepoints */ 4211 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_unshare); 4212 DEFINE_INODE_ERROR_EVENT(xfs_reflink_unshare_error); 4213 4214 /* copy on write */ 4215 DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_around_shared); 4216 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_found); 4217 DEFINE_INODE_IREC_EVENT(xfs_reflink_convert_cow); 4218 4219 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_cancel_cow_range); 4220 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_end_cow); 4221 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_from); 4222 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_to); 4223 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_skip); 4224 4225 DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_cow_range_error); 4226 DEFINE_INODE_ERROR_EVENT(xfs_reflink_end_cow_error); 4227 4228 4229 DEFINE_INODE_IREC_EVENT(xfs_reflink_cancel_cow); 4230 4231 /* rmap swapext tracepoints */ 4232 DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap); 4233 DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap_piece); 4234 DEFINE_INODE_ERROR_EVENT(xfs_swap_extent_rmap_error); 4235 4236 /* fsmap traces */ 4237 TRACE_EVENT(xfs_fsmap_mapping, 4238 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, 4239 const struct xfs_fsmap_irec *frec), 4240 TP_ARGS(mp, keydev, agno, frec), 4241 TP_STRUCT__entry( 4242 __field(dev_t, dev) 4243 __field(dev_t, keydev) 4244 __field(xfs_agnumber_t, agno) 4245 __field(xfs_agblock_t, agbno) 4246 __field(xfs_daddr_t, start_daddr) 4247 __field(xfs_daddr_t, len_daddr) 4248 __field(uint64_t, owner) 4249 __field(uint64_t, offset) 4250 __field(unsigned int, flags) 4251 ), 4252 TP_fast_assign( 4253 __entry->dev = mp->m_super->s_dev; 4254 __entry->keydev = new_decode_dev(keydev); 4255 __entry->agno = agno; 4256 __entry->agbno = frec->rec_key; 4257 __entry->start_daddr = frec->start_daddr; 4258 __entry->len_daddr = frec->len_daddr; 4259 __entry->owner = frec->owner; 4260 __entry->offset = frec->offset; 4261 __entry->flags = frec->rm_flags; 4262 ), 4263 TP_printk("dev %d:%d keydev %d:%d agno 0x%x gbno 0x%x start_daddr 0x%llx len_daddr 0x%llx owner 0x%llx fileoff 0x%llx flags 0x%x", 4264 MAJOR(__entry->dev), MINOR(__entry->dev), 4265 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4266 __entry->agno, 4267 __entry->agbno, 4268 __entry->start_daddr, 4269 __entry->len_daddr, 4270 __entry->owner, 4271 __entry->offset, 4272 __entry->flags) 4273 ); 4274 4275 DECLARE_EVENT_CLASS(xfs_fsmap_group_key_class, 4276 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, 4277 const struct xfs_rmap_irec *rmap), 4278 TP_ARGS(mp, keydev, agno, rmap), 4279 TP_STRUCT__entry( 4280 __field(dev_t, dev) 4281 __field(dev_t, keydev) 4282 __field(xfs_agnumber_t, agno) 4283 __field(xfs_agblock_t, agbno) 4284 __field(uint64_t, owner) 4285 __field(uint64_t, offset) 4286 __field(unsigned int, flags) 4287 ), 4288 TP_fast_assign( 4289 __entry->dev = mp->m_super->s_dev; 4290 __entry->keydev = new_decode_dev(keydev); 4291 __entry->agno = agno; 4292 __entry->agbno = rmap->rm_startblock; 4293 __entry->owner = rmap->rm_owner; 4294 __entry->offset = rmap->rm_offset; 4295 __entry->flags = rmap->rm_flags; 4296 ), 4297 TP_printk("dev %d:%d keydev %d:%d agno 0x%x startblock 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 4298 MAJOR(__entry->dev), MINOR(__entry->dev), 4299 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4300 __entry->agno, 4301 __entry->agbno, 4302 __entry->owner, 4303 __entry->offset, 4304 __entry->flags) 4305 ) 4306 #define DEFINE_FSMAP_GROUP_KEY_EVENT(name) \ 4307 DEFINE_EVENT(xfs_fsmap_group_key_class, name, \ 4308 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, \ 4309 const struct xfs_rmap_irec *rmap), \ 4310 TP_ARGS(mp, keydev, agno, rmap)) 4311 DEFINE_FSMAP_GROUP_KEY_EVENT(xfs_fsmap_low_group_key); 4312 DEFINE_FSMAP_GROUP_KEY_EVENT(xfs_fsmap_high_group_key); 4313 4314 DECLARE_EVENT_CLASS(xfs_fsmap_linear_key_class, 4315 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_fsblock_t bno), 4316 TP_ARGS(mp, keydev, bno), 4317 TP_STRUCT__entry( 4318 __field(dev_t, dev) 4319 __field(dev_t, keydev) 4320 __field(xfs_fsblock_t, bno) 4321 ), 4322 TP_fast_assign( 4323 __entry->dev = mp->m_super->s_dev; 4324 __entry->keydev = new_decode_dev(keydev); 4325 __entry->bno = bno; 4326 ), 4327 TP_printk("dev %d:%d keydev %d:%d bno 0x%llx", 4328 MAJOR(__entry->dev), MINOR(__entry->dev), 4329 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4330 __entry->bno) 4331 ) 4332 #define DEFINE_FSMAP_LINEAR_KEY_EVENT(name) \ 4333 DEFINE_EVENT(xfs_fsmap_linear_key_class, name, \ 4334 TP_PROTO(struct xfs_mount *mp, u32 keydev, uint64_t bno), \ 4335 TP_ARGS(mp, keydev, bno)) 4336 DEFINE_FSMAP_LINEAR_KEY_EVENT(xfs_fsmap_low_linear_key); 4337 DEFINE_FSMAP_LINEAR_KEY_EVENT(xfs_fsmap_high_linear_key); 4338 4339 DECLARE_EVENT_CLASS(xfs_getfsmap_class, 4340 TP_PROTO(struct xfs_mount *mp, struct xfs_fsmap *fsmap), 4341 TP_ARGS(mp, fsmap), 4342 TP_STRUCT__entry( 4343 __field(dev_t, dev) 4344 __field(dev_t, keydev) 4345 __field(xfs_daddr_t, block) 4346 __field(xfs_daddr_t, len) 4347 __field(uint64_t, owner) 4348 __field(uint64_t, offset) 4349 __field(uint64_t, flags) 4350 ), 4351 TP_fast_assign( 4352 __entry->dev = mp->m_super->s_dev; 4353 __entry->keydev = new_decode_dev(fsmap->fmr_device); 4354 __entry->block = fsmap->fmr_physical; 4355 __entry->len = fsmap->fmr_length; 4356 __entry->owner = fsmap->fmr_owner; 4357 __entry->offset = fsmap->fmr_offset; 4358 __entry->flags = fsmap->fmr_flags; 4359 ), 4360 TP_printk("dev %d:%d keydev %d:%d daddr 0x%llx bbcount 0x%llx owner 0x%llx fileoff_daddr 0x%llx flags 0x%llx", 4361 MAJOR(__entry->dev), MINOR(__entry->dev), 4362 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4363 __entry->block, 4364 __entry->len, 4365 __entry->owner, 4366 __entry->offset, 4367 __entry->flags) 4368 ) 4369 #define DEFINE_GETFSMAP_EVENT(name) \ 4370 DEFINE_EVENT(xfs_getfsmap_class, name, \ 4371 TP_PROTO(struct xfs_mount *mp, struct xfs_fsmap *fsmap), \ 4372 TP_ARGS(mp, fsmap)) 4373 DEFINE_GETFSMAP_EVENT(xfs_getfsmap_low_key); 4374 DEFINE_GETFSMAP_EVENT(xfs_getfsmap_high_key); 4375 DEFINE_GETFSMAP_EVENT(xfs_getfsmap_mapping); 4376 4377 DECLARE_EVENT_CLASS(xfs_trans_resv_class, 4378 TP_PROTO(struct xfs_mount *mp, unsigned int type, 4379 struct xfs_trans_res *res), 4380 TP_ARGS(mp, type, res), 4381 TP_STRUCT__entry( 4382 __field(dev_t, dev) 4383 __field(int, type) 4384 __field(uint, logres) 4385 __field(int, logcount) 4386 __field(int, logflags) 4387 ), 4388 TP_fast_assign( 4389 __entry->dev = mp->m_super->s_dev; 4390 __entry->type = type; 4391 __entry->logres = res->tr_logres; 4392 __entry->logcount = res->tr_logcount; 4393 __entry->logflags = res->tr_logflags; 4394 ), 4395 TP_printk("dev %d:%d type %d logres %u logcount %d flags 0x%x", 4396 MAJOR(__entry->dev), MINOR(__entry->dev), 4397 __entry->type, 4398 __entry->logres, 4399 __entry->logcount, 4400 __entry->logflags) 4401 ) 4402 4403 #define DEFINE_TRANS_RESV_EVENT(name) \ 4404 DEFINE_EVENT(xfs_trans_resv_class, name, \ 4405 TP_PROTO(struct xfs_mount *mp, unsigned int type, \ 4406 struct xfs_trans_res *res), \ 4407 TP_ARGS(mp, type, res)) 4408 DEFINE_TRANS_RESV_EVENT(xfs_trans_resv_calc); 4409 DEFINE_TRANS_RESV_EVENT(xfs_trans_resv_calc_minlogsize); 4410 4411 TRACE_EVENT(xfs_log_get_max_trans_res, 4412 TP_PROTO(struct xfs_mount *mp, const struct xfs_trans_res *res), 4413 TP_ARGS(mp, res), 4414 TP_STRUCT__entry( 4415 __field(dev_t, dev) 4416 __field(uint, logres) 4417 __field(int, logcount) 4418 ), 4419 TP_fast_assign( 4420 __entry->dev = mp->m_super->s_dev; 4421 __entry->logres = res->tr_logres; 4422 __entry->logcount = res->tr_logcount; 4423 ), 4424 TP_printk("dev %d:%d logres %u logcount %d", 4425 MAJOR(__entry->dev), MINOR(__entry->dev), 4426 __entry->logres, 4427 __entry->logcount) 4428 ); 4429 4430 DECLARE_EVENT_CLASS(xfs_trans_class, 4431 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), 4432 TP_ARGS(tp, caller_ip), 4433 TP_STRUCT__entry( 4434 __field(dev_t, dev) 4435 __field(uint32_t, tid) 4436 __field(uint32_t, flags) 4437 __field(unsigned long, caller_ip) 4438 ), 4439 TP_fast_assign( 4440 __entry->dev = tp->t_mountp->m_super->s_dev; 4441 __entry->tid = 0; 4442 if (tp->t_ticket) 4443 __entry->tid = tp->t_ticket->t_tid; 4444 __entry->flags = tp->t_flags; 4445 __entry->caller_ip = caller_ip; 4446 ), 4447 TP_printk("dev %d:%d trans %x flags 0x%x caller %pS", 4448 MAJOR(__entry->dev), MINOR(__entry->dev), 4449 __entry->tid, 4450 __entry->flags, 4451 (char *)__entry->caller_ip) 4452 ) 4453 4454 #define DEFINE_TRANS_EVENT(name) \ 4455 DEFINE_EVENT(xfs_trans_class, name, \ 4456 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), \ 4457 TP_ARGS(tp, caller_ip)) 4458 DEFINE_TRANS_EVENT(xfs_trans_alloc); 4459 DEFINE_TRANS_EVENT(xfs_trans_cancel); 4460 DEFINE_TRANS_EVENT(xfs_trans_commit); 4461 DEFINE_TRANS_EVENT(xfs_trans_dup); 4462 DEFINE_TRANS_EVENT(xfs_trans_free); 4463 DEFINE_TRANS_EVENT(xfs_trans_roll); 4464 DEFINE_TRANS_EVENT(xfs_trans_add_item); 4465 DEFINE_TRANS_EVENT(xfs_trans_commit_items); 4466 DEFINE_TRANS_EVENT(xfs_trans_free_items); 4467 4468 TRACE_EVENT(xfs_iunlink_update_bucket, 4469 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, 4470 xfs_agino_t old_ptr, xfs_agino_t new_ptr), 4471 TP_ARGS(pag, bucket, old_ptr, new_ptr), 4472 TP_STRUCT__entry( 4473 __field(dev_t, dev) 4474 __field(xfs_agnumber_t, agno) 4475 __field(unsigned int, bucket) 4476 __field(xfs_agino_t, old_ptr) 4477 __field(xfs_agino_t, new_ptr) 4478 ), 4479 TP_fast_assign( 4480 __entry->dev = pag_mount(pag)->m_super->s_dev; 4481 __entry->agno = pag_agno(pag); 4482 __entry->bucket = bucket; 4483 __entry->old_ptr = old_ptr; 4484 __entry->new_ptr = new_ptr; 4485 ), 4486 TP_printk("dev %d:%d agno 0x%x bucket %u old 0x%x new 0x%x", 4487 MAJOR(__entry->dev), MINOR(__entry->dev), 4488 __entry->agno, 4489 __entry->bucket, 4490 __entry->old_ptr, 4491 __entry->new_ptr) 4492 ); 4493 4494 TRACE_EVENT(xfs_iunlink_update_dinode, 4495 TP_PROTO(const struct xfs_iunlink_item *iup, xfs_agino_t old_ptr), 4496 TP_ARGS(iup, old_ptr), 4497 TP_STRUCT__entry( 4498 __field(dev_t, dev) 4499 __field(xfs_agnumber_t, agno) 4500 __field(xfs_agino_t, agino) 4501 __field(xfs_agino_t, old_ptr) 4502 __field(xfs_agino_t, new_ptr) 4503 ), 4504 TP_fast_assign( 4505 __entry->dev = pag_mount(iup->pag)->m_super->s_dev; 4506 __entry->agno = pag_agno(iup->pag); 4507 __entry->agino = 4508 XFS_INO_TO_AGINO(iup->ip->i_mount, iup->ip->i_ino); 4509 __entry->old_ptr = old_ptr; 4510 __entry->new_ptr = iup->next_agino; 4511 ), 4512 TP_printk("dev %d:%d agno 0x%x agino 0x%x old 0x%x new 0x%x", 4513 MAJOR(__entry->dev), MINOR(__entry->dev), 4514 __entry->agno, 4515 __entry->agino, 4516 __entry->old_ptr, 4517 __entry->new_ptr) 4518 ); 4519 4520 TRACE_EVENT(xfs_iunlink_reload_next, 4521 TP_PROTO(struct xfs_inode *ip), 4522 TP_ARGS(ip), 4523 TP_STRUCT__entry( 4524 __field(dev_t, dev) 4525 __field(xfs_agnumber_t, agno) 4526 __field(xfs_agino_t, agino) 4527 __field(xfs_agino_t, prev_agino) 4528 __field(xfs_agino_t, next_agino) 4529 ), 4530 TP_fast_assign( 4531 __entry->dev = ip->i_mount->m_super->s_dev; 4532 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 4533 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 4534 __entry->prev_agino = ip->i_prev_unlinked; 4535 __entry->next_agino = ip->i_next_unlinked; 4536 ), 4537 TP_printk("dev %d:%d agno 0x%x agino 0x%x prev_unlinked 0x%x next_unlinked 0x%x", 4538 MAJOR(__entry->dev), MINOR(__entry->dev), 4539 __entry->agno, 4540 __entry->agino, 4541 __entry->prev_agino, 4542 __entry->next_agino) 4543 ); 4544 4545 TRACE_EVENT(xfs_inode_reload_unlinked_bucket, 4546 TP_PROTO(struct xfs_inode *ip), 4547 TP_ARGS(ip), 4548 TP_STRUCT__entry( 4549 __field(dev_t, dev) 4550 __field(xfs_agnumber_t, agno) 4551 __field(xfs_agino_t, agino) 4552 ), 4553 TP_fast_assign( 4554 __entry->dev = ip->i_mount->m_super->s_dev; 4555 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 4556 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 4557 ), 4558 TP_printk("dev %d:%d agno 0x%x agino 0x%x bucket %u", 4559 MAJOR(__entry->dev), MINOR(__entry->dev), 4560 __entry->agno, 4561 __entry->agino, 4562 __entry->agino % XFS_AGI_UNLINKED_BUCKETS) 4563 ); 4564 4565 DECLARE_EVENT_CLASS(xfs_ag_inode_class, 4566 TP_PROTO(struct xfs_inode *ip), 4567 TP_ARGS(ip), 4568 TP_STRUCT__entry( 4569 __field(dev_t, dev) 4570 __field(xfs_agnumber_t, agno) 4571 __field(xfs_agino_t, agino) 4572 ), 4573 TP_fast_assign( 4574 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4575 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 4576 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 4577 ), 4578 TP_printk("dev %d:%d agno 0x%x agino 0x%x", 4579 MAJOR(__entry->dev), MINOR(__entry->dev), 4580 __entry->agno, __entry->agino) 4581 ) 4582 4583 #define DEFINE_AGINODE_EVENT(name) \ 4584 DEFINE_EVENT(xfs_ag_inode_class, name, \ 4585 TP_PROTO(struct xfs_inode *ip), \ 4586 TP_ARGS(ip)) 4587 DEFINE_AGINODE_EVENT(xfs_iunlink); 4588 DEFINE_AGINODE_EVENT(xfs_iunlink_remove); 4589 4590 DECLARE_EVENT_CLASS(xfs_fs_corrupt_class, 4591 TP_PROTO(struct xfs_mount *mp, unsigned int flags), 4592 TP_ARGS(mp, flags), 4593 TP_STRUCT__entry( 4594 __field(dev_t, dev) 4595 __field(unsigned int, flags) 4596 ), 4597 TP_fast_assign( 4598 __entry->dev = mp->m_super->s_dev; 4599 __entry->flags = flags; 4600 ), 4601 TP_printk("dev %d:%d flags 0x%x", 4602 MAJOR(__entry->dev), MINOR(__entry->dev), 4603 __entry->flags) 4604 ); 4605 #define DEFINE_FS_CORRUPT_EVENT(name) \ 4606 DEFINE_EVENT(xfs_fs_corrupt_class, name, \ 4607 TP_PROTO(struct xfs_mount *mp, unsigned int flags), \ 4608 TP_ARGS(mp, flags)) 4609 DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_sick); 4610 DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_corrupt); 4611 DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_healthy); 4612 DEFINE_FS_CORRUPT_EVENT(xfs_fs_unfixed_corruption); 4613 4614 DECLARE_EVENT_CLASS(xfs_group_corrupt_class, 4615 TP_PROTO(const struct xfs_group *xg, unsigned int flags), 4616 TP_ARGS(xg, flags), 4617 TP_STRUCT__entry( 4618 __field(dev_t, dev) 4619 __field(enum xfs_group_type, type) 4620 __field(uint32_t, index) 4621 __field(unsigned int, flags) 4622 ), 4623 TP_fast_assign( 4624 __entry->dev = xg->xg_mount->m_super->s_dev; 4625 __entry->type = xg->xg_type; 4626 __entry->index = xg->xg_gno; 4627 __entry->flags = flags; 4628 ), 4629 TP_printk("dev %d:%d %sno 0x%x flags 0x%x", 4630 MAJOR(__entry->dev), MINOR(__entry->dev), 4631 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 4632 __entry->index, __entry->flags) 4633 ); 4634 #define DEFINE_GROUP_CORRUPT_EVENT(name) \ 4635 DEFINE_EVENT(xfs_group_corrupt_class, name, \ 4636 TP_PROTO(const struct xfs_group *xg, unsigned int flags), \ 4637 TP_ARGS(xg, flags)) 4638 DEFINE_GROUP_CORRUPT_EVENT(xfs_group_mark_sick); 4639 DEFINE_GROUP_CORRUPT_EVENT(xfs_group_mark_corrupt); 4640 DEFINE_GROUP_CORRUPT_EVENT(xfs_group_mark_healthy); 4641 DEFINE_GROUP_CORRUPT_EVENT(xfs_group_unfixed_corruption); 4642 4643 DECLARE_EVENT_CLASS(xfs_inode_corrupt_class, 4644 TP_PROTO(struct xfs_inode *ip, unsigned int flags), 4645 TP_ARGS(ip, flags), 4646 TP_STRUCT__entry( 4647 __field(dev_t, dev) 4648 __field(xfs_ino_t, ino) 4649 __field(unsigned int, flags) 4650 ), 4651 TP_fast_assign( 4652 __entry->dev = ip->i_mount->m_super->s_dev; 4653 __entry->ino = ip->i_ino; 4654 __entry->flags = flags; 4655 ), 4656 TP_printk("dev %d:%d ino 0x%llx flags 0x%x", 4657 MAJOR(__entry->dev), MINOR(__entry->dev), 4658 __entry->ino, __entry->flags) 4659 ); 4660 #define DEFINE_INODE_CORRUPT_EVENT(name) \ 4661 DEFINE_EVENT(xfs_inode_corrupt_class, name, \ 4662 TP_PROTO(struct xfs_inode *ip, unsigned int flags), \ 4663 TP_ARGS(ip, flags)) 4664 DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_sick); 4665 DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_corrupt); 4666 DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_healthy); 4667 DEFINE_INODE_CORRUPT_EVENT(xfs_inode_unfixed_corruption); 4668 4669 TRACE_EVENT(xfs_iwalk_ag_rec, 4670 TP_PROTO(const struct xfs_perag *pag, \ 4671 struct xfs_inobt_rec_incore *irec), 4672 TP_ARGS(pag, irec), 4673 TP_STRUCT__entry( 4674 __field(dev_t, dev) 4675 __field(xfs_agnumber_t, agno) 4676 __field(xfs_agino_t, startino) 4677 __field(uint64_t, freemask) 4678 ), 4679 TP_fast_assign( 4680 __entry->dev = pag_mount(pag)->m_super->s_dev; 4681 __entry->agno = pag_agno(pag); 4682 __entry->startino = irec->ir_startino; 4683 __entry->freemask = irec->ir_free; 4684 ), 4685 TP_printk("dev %d:%d agno 0x%x startino 0x%x freemask 0x%llx", 4686 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->agno, 4687 __entry->startino, __entry->freemask) 4688 ) 4689 4690 TRACE_EVENT(xfs_pwork_init, 4691 TP_PROTO(struct xfs_mount *mp, unsigned int nr_threads, pid_t pid), 4692 TP_ARGS(mp, nr_threads, pid), 4693 TP_STRUCT__entry( 4694 __field(dev_t, dev) 4695 __field(unsigned int, nr_threads) 4696 __field(pid_t, pid) 4697 ), 4698 TP_fast_assign( 4699 __entry->dev = mp->m_super->s_dev; 4700 __entry->nr_threads = nr_threads; 4701 __entry->pid = pid; 4702 ), 4703 TP_printk("dev %d:%d nr_threads %u pid %u", 4704 MAJOR(__entry->dev), MINOR(__entry->dev), 4705 __entry->nr_threads, __entry->pid) 4706 ) 4707 4708 TRACE_EVENT(xfs_check_new_dalign, 4709 TP_PROTO(struct xfs_mount *mp, int new_dalign, xfs_ino_t calc_rootino), 4710 TP_ARGS(mp, new_dalign, calc_rootino), 4711 TP_STRUCT__entry( 4712 __field(dev_t, dev) 4713 __field(int, new_dalign) 4714 __field(xfs_ino_t, sb_rootino) 4715 __field(xfs_ino_t, calc_rootino) 4716 ), 4717 TP_fast_assign( 4718 __entry->dev = mp->m_super->s_dev; 4719 __entry->new_dalign = new_dalign; 4720 __entry->sb_rootino = mp->m_sb.sb_rootino; 4721 __entry->calc_rootino = calc_rootino; 4722 ), 4723 TP_printk("dev %d:%d new_dalign %d sb_rootino 0x%llx calc_rootino 0x%llx", 4724 MAJOR(__entry->dev), MINOR(__entry->dev), 4725 __entry->new_dalign, __entry->sb_rootino, 4726 __entry->calc_rootino) 4727 ) 4728 4729 TRACE_EVENT(xfs_btree_commit_afakeroot, 4730 TP_PROTO(struct xfs_btree_cur *cur), 4731 TP_ARGS(cur), 4732 TP_STRUCT__entry( 4733 __field(dev_t, dev) 4734 __string(name, cur->bc_ops->name) 4735 __field(xfs_agnumber_t, agno) 4736 __field(xfs_agblock_t, agbno) 4737 __field(unsigned int, levels) 4738 __field(unsigned int, blocks) 4739 ), 4740 TP_fast_assign( 4741 __entry->dev = cur->bc_mp->m_super->s_dev; 4742 __assign_str(name); 4743 __entry->agno = cur->bc_group->xg_gno; 4744 __entry->agbno = cur->bc_ag.afake->af_root; 4745 __entry->levels = cur->bc_ag.afake->af_levels; 4746 __entry->blocks = cur->bc_ag.afake->af_blocks; 4747 ), 4748 TP_printk("dev %d:%d %sbt agno 0x%x levels %u blocks %u root %u", 4749 MAJOR(__entry->dev), MINOR(__entry->dev), 4750 __get_str(name), 4751 __entry->agno, 4752 __entry->levels, 4753 __entry->blocks, 4754 __entry->agbno) 4755 ) 4756 4757 TRACE_EVENT(xfs_btree_commit_ifakeroot, 4758 TP_PROTO(struct xfs_btree_cur *cur), 4759 TP_ARGS(cur), 4760 TP_STRUCT__entry( 4761 __field(dev_t, dev) 4762 __string(name, cur->bc_ops->name) 4763 __field(xfs_agnumber_t, agno) 4764 __field(xfs_agino_t, agino) 4765 __field(unsigned int, levels) 4766 __field(unsigned int, blocks) 4767 __field(int, whichfork) 4768 ), 4769 TP_fast_assign( 4770 __entry->dev = cur->bc_mp->m_super->s_dev; 4771 __assign_str(name); 4772 __entry->agno = XFS_INO_TO_AGNO(cur->bc_mp, 4773 cur->bc_ino.ip->i_ino); 4774 __entry->agino = XFS_INO_TO_AGINO(cur->bc_mp, 4775 cur->bc_ino.ip->i_ino); 4776 __entry->levels = cur->bc_ino.ifake->if_levels; 4777 __entry->blocks = cur->bc_ino.ifake->if_blocks; 4778 __entry->whichfork = cur->bc_ino.whichfork; 4779 ), 4780 TP_printk("dev %d:%d %sbt agno 0x%x agino 0x%x whichfork %s levels %u blocks %u", 4781 MAJOR(__entry->dev), MINOR(__entry->dev), 4782 __get_str(name), 4783 __entry->agno, 4784 __entry->agino, 4785 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 4786 __entry->levels, 4787 __entry->blocks) 4788 ) 4789 4790 TRACE_EVENT(xfs_btree_bload_level_geometry, 4791 TP_PROTO(struct xfs_btree_cur *cur, unsigned int level, 4792 uint64_t nr_this_level, unsigned int nr_per_block, 4793 unsigned int desired_npb, uint64_t blocks, 4794 uint64_t blocks_with_extra), 4795 TP_ARGS(cur, level, nr_this_level, nr_per_block, desired_npb, blocks, 4796 blocks_with_extra), 4797 TP_STRUCT__entry( 4798 __field(dev_t, dev) 4799 __string(name, cur->bc_ops->name) 4800 __field(unsigned int, level) 4801 __field(unsigned int, nlevels) 4802 __field(uint64_t, nr_this_level) 4803 __field(unsigned int, nr_per_block) 4804 __field(unsigned int, desired_npb) 4805 __field(unsigned long long, blocks) 4806 __field(unsigned long long, blocks_with_extra) 4807 ), 4808 TP_fast_assign( 4809 __entry->dev = cur->bc_mp->m_super->s_dev; 4810 __assign_str(name); 4811 __entry->level = level; 4812 __entry->nlevels = cur->bc_nlevels; 4813 __entry->nr_this_level = nr_this_level; 4814 __entry->nr_per_block = nr_per_block; 4815 __entry->desired_npb = desired_npb; 4816 __entry->blocks = blocks; 4817 __entry->blocks_with_extra = blocks_with_extra; 4818 ), 4819 TP_printk("dev %d:%d %sbt level %u/%u nr_this_level %llu nr_per_block %u desired_npb %u blocks %llu blocks_with_extra %llu", 4820 MAJOR(__entry->dev), MINOR(__entry->dev), 4821 __get_str(name), 4822 __entry->level, 4823 __entry->nlevels, 4824 __entry->nr_this_level, 4825 __entry->nr_per_block, 4826 __entry->desired_npb, 4827 __entry->blocks, 4828 __entry->blocks_with_extra) 4829 ) 4830 4831 TRACE_EVENT(xfs_btree_bload_block, 4832 TP_PROTO(struct xfs_btree_cur *cur, unsigned int level, 4833 uint64_t block_idx, uint64_t nr_blocks, 4834 union xfs_btree_ptr *ptr, unsigned int nr_records), 4835 TP_ARGS(cur, level, block_idx, nr_blocks, ptr, nr_records), 4836 TP_STRUCT__entry( 4837 __field(dev_t, dev) 4838 __string(name, cur->bc_ops->name) 4839 __field(unsigned int, level) 4840 __field(unsigned long long, block_idx) 4841 __field(unsigned long long, nr_blocks) 4842 __field(xfs_agnumber_t, agno) 4843 __field(xfs_agblock_t, agbno) 4844 __field(unsigned int, nr_records) 4845 ), 4846 TP_fast_assign( 4847 __entry->dev = cur->bc_mp->m_super->s_dev; 4848 __assign_str(name); 4849 __entry->level = level; 4850 __entry->block_idx = block_idx; 4851 __entry->nr_blocks = nr_blocks; 4852 if (cur->bc_ops->ptr_len == XFS_BTREE_LONG_PTR_LEN) { 4853 xfs_fsblock_t fsb = be64_to_cpu(ptr->l); 4854 4855 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsb); 4856 __entry->agbno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsb); 4857 } else { 4858 __entry->agno = cur->bc_group->xg_gno; 4859 __entry->agbno = be32_to_cpu(ptr->s); 4860 } 4861 __entry->nr_records = nr_records; 4862 ), 4863 TP_printk("dev %d:%d %sbt level %u block %llu/%llu agno 0x%x agbno 0x%x recs %u", 4864 MAJOR(__entry->dev), MINOR(__entry->dev), 4865 __get_str(name), 4866 __entry->level, 4867 __entry->block_idx, 4868 __entry->nr_blocks, 4869 __entry->agno, 4870 __entry->agbno, 4871 __entry->nr_records) 4872 ) 4873 4874 DECLARE_EVENT_CLASS(xfs_timestamp_range_class, 4875 TP_PROTO(struct xfs_mount *mp, time64_t min, time64_t max), 4876 TP_ARGS(mp, min, max), 4877 TP_STRUCT__entry( 4878 __field(dev_t, dev) 4879 __field(long long, min) 4880 __field(long long, max) 4881 ), 4882 TP_fast_assign( 4883 __entry->dev = mp->m_super->s_dev; 4884 __entry->min = min; 4885 __entry->max = max; 4886 ), 4887 TP_printk("dev %d:%d min %lld max %lld", 4888 MAJOR(__entry->dev), MINOR(__entry->dev), 4889 __entry->min, 4890 __entry->max) 4891 ) 4892 4893 #define DEFINE_TIMESTAMP_RANGE_EVENT(name) \ 4894 DEFINE_EVENT(xfs_timestamp_range_class, name, \ 4895 TP_PROTO(struct xfs_mount *mp, long long min, long long max), \ 4896 TP_ARGS(mp, min, max)) 4897 DEFINE_TIMESTAMP_RANGE_EVENT(xfs_inode_timestamp_range); 4898 DEFINE_TIMESTAMP_RANGE_EVENT(xfs_quota_expiry_range); 4899 4900 DECLARE_EVENT_CLASS(xfs_icwalk_class, 4901 TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw, 4902 unsigned long caller_ip), 4903 TP_ARGS(mp, icw, caller_ip), 4904 TP_STRUCT__entry( 4905 __field(dev_t, dev) 4906 __field(__u32, flags) 4907 __field(uint32_t, uid) 4908 __field(uint32_t, gid) 4909 __field(prid_t, prid) 4910 __field(__u64, min_file_size) 4911 __field(long, scan_limit) 4912 __field(unsigned long, caller_ip) 4913 ), 4914 TP_fast_assign( 4915 __entry->dev = mp->m_super->s_dev; 4916 __entry->flags = icw ? icw->icw_flags : 0; 4917 __entry->uid = icw ? from_kuid(mp->m_super->s_user_ns, 4918 icw->icw_uid) : 0; 4919 __entry->gid = icw ? from_kgid(mp->m_super->s_user_ns, 4920 icw->icw_gid) : 0; 4921 __entry->prid = icw ? icw->icw_prid : 0; 4922 __entry->min_file_size = icw ? icw->icw_min_file_size : 0; 4923 __entry->scan_limit = icw ? icw->icw_scan_limit : 0; 4924 __entry->caller_ip = caller_ip; 4925 ), 4926 TP_printk("dev %d:%d flags 0x%x uid %u gid %u prid %u minsize %llu scan_limit %ld caller %pS", 4927 MAJOR(__entry->dev), MINOR(__entry->dev), 4928 __entry->flags, 4929 __entry->uid, 4930 __entry->gid, 4931 __entry->prid, 4932 __entry->min_file_size, 4933 __entry->scan_limit, 4934 (char *)__entry->caller_ip) 4935 ); 4936 #define DEFINE_ICWALK_EVENT(name) \ 4937 DEFINE_EVENT(xfs_icwalk_class, name, \ 4938 TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw, \ 4939 unsigned long caller_ip), \ 4940 TP_ARGS(mp, icw, caller_ip)) 4941 DEFINE_ICWALK_EVENT(xfs_ioc_free_eofblocks); 4942 DEFINE_ICWALK_EVENT(xfs_blockgc_free_space); 4943 4944 TRACE_DEFINE_ENUM(XLOG_STATE_ACTIVE); 4945 TRACE_DEFINE_ENUM(XLOG_STATE_WANT_SYNC); 4946 TRACE_DEFINE_ENUM(XLOG_STATE_SYNCING); 4947 TRACE_DEFINE_ENUM(XLOG_STATE_DONE_SYNC); 4948 TRACE_DEFINE_ENUM(XLOG_STATE_CALLBACK); 4949 TRACE_DEFINE_ENUM(XLOG_STATE_DIRTY); 4950 4951 DECLARE_EVENT_CLASS(xlog_iclog_class, 4952 TP_PROTO(struct xlog_in_core *iclog, unsigned long caller_ip), 4953 TP_ARGS(iclog, caller_ip), 4954 TP_STRUCT__entry( 4955 __field(dev_t, dev) 4956 __field(uint32_t, state) 4957 __field(int32_t, refcount) 4958 __field(uint32_t, offset) 4959 __field(uint32_t, flags) 4960 __field(unsigned long long, lsn) 4961 __field(unsigned long, caller_ip) 4962 ), 4963 TP_fast_assign( 4964 __entry->dev = iclog->ic_log->l_mp->m_super->s_dev; 4965 __entry->state = iclog->ic_state; 4966 __entry->refcount = atomic_read(&iclog->ic_refcnt); 4967 __entry->offset = iclog->ic_offset; 4968 __entry->flags = iclog->ic_flags; 4969 __entry->lsn = be64_to_cpu(iclog->ic_header->h_lsn); 4970 __entry->caller_ip = caller_ip; 4971 ), 4972 TP_printk("dev %d:%d state %s refcnt %d offset %u lsn 0x%llx flags %s caller %pS", 4973 MAJOR(__entry->dev), MINOR(__entry->dev), 4974 __print_symbolic(__entry->state, XLOG_STATE_STRINGS), 4975 __entry->refcount, 4976 __entry->offset, 4977 __entry->lsn, 4978 __print_flags(__entry->flags, "|", XLOG_ICL_STRINGS), 4979 (char *)__entry->caller_ip) 4980 4981 ); 4982 4983 #define DEFINE_ICLOG_EVENT(name) \ 4984 DEFINE_EVENT(xlog_iclog_class, name, \ 4985 TP_PROTO(struct xlog_in_core *iclog, unsigned long caller_ip), \ 4986 TP_ARGS(iclog, caller_ip)) 4987 4988 DEFINE_ICLOG_EVENT(xlog_iclog_activate); 4989 DEFINE_ICLOG_EVENT(xlog_iclog_clean); 4990 DEFINE_ICLOG_EVENT(xlog_iclog_callback); 4991 DEFINE_ICLOG_EVENT(xlog_iclog_callbacks_start); 4992 DEFINE_ICLOG_EVENT(xlog_iclog_callbacks_done); 4993 DEFINE_ICLOG_EVENT(xlog_iclog_force); 4994 DEFINE_ICLOG_EVENT(xlog_iclog_force_lsn); 4995 DEFINE_ICLOG_EVENT(xlog_iclog_get_space); 4996 DEFINE_ICLOG_EVENT(xlog_iclog_release); 4997 DEFINE_ICLOG_EVENT(xlog_iclog_switch); 4998 DEFINE_ICLOG_EVENT(xlog_iclog_sync); 4999 DEFINE_ICLOG_EVENT(xlog_iclog_syncing); 5000 DEFINE_ICLOG_EVENT(xlog_iclog_sync_done); 5001 DEFINE_ICLOG_EVENT(xlog_iclog_wait_on); 5002 DEFINE_ICLOG_EVENT(xlog_iclog_write); 5003 5004 TRACE_DEFINE_ENUM(XFS_DAS_UNINIT); 5005 TRACE_DEFINE_ENUM(XFS_DAS_SF_ADD); 5006 TRACE_DEFINE_ENUM(XFS_DAS_SF_REMOVE); 5007 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_ADD); 5008 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE); 5009 TRACE_DEFINE_ENUM(XFS_DAS_NODE_ADD); 5010 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE); 5011 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_SET_RMT); 5012 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_ALLOC_RMT); 5013 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REPLACE); 5014 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_OLD); 5015 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_RMT); 5016 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_ATTR); 5017 TRACE_DEFINE_ENUM(XFS_DAS_NODE_SET_RMT); 5018 TRACE_DEFINE_ENUM(XFS_DAS_NODE_ALLOC_RMT); 5019 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REPLACE); 5020 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_OLD); 5021 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_RMT); 5022 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_ATTR); 5023 TRACE_DEFINE_ENUM(XFS_DAS_DONE); 5024 5025 DECLARE_EVENT_CLASS(xfs_das_state_class, 5026 TP_PROTO(int das, struct xfs_inode *ip), 5027 TP_ARGS(das, ip), 5028 TP_STRUCT__entry( 5029 __field(int, das) 5030 __field(xfs_ino_t, ino) 5031 ), 5032 TP_fast_assign( 5033 __entry->das = das; 5034 __entry->ino = ip->i_ino; 5035 ), 5036 TP_printk("state change %s ino 0x%llx", 5037 __print_symbolic(__entry->das, XFS_DAS_STRINGS), 5038 __entry->ino) 5039 ) 5040 5041 #define DEFINE_DAS_STATE_EVENT(name) \ 5042 DEFINE_EVENT(xfs_das_state_class, name, \ 5043 TP_PROTO(int das, struct xfs_inode *ip), \ 5044 TP_ARGS(das, ip)) 5045 DEFINE_DAS_STATE_EVENT(xfs_attr_sf_addname_return); 5046 DEFINE_DAS_STATE_EVENT(xfs_attr_set_iter_return); 5047 DEFINE_DAS_STATE_EVENT(xfs_attr_leaf_addname_return); 5048 DEFINE_DAS_STATE_EVENT(xfs_attr_node_addname_return); 5049 DEFINE_DAS_STATE_EVENT(xfs_attr_rmtval_alloc); 5050 DEFINE_DAS_STATE_EVENT(xfs_attr_rmtval_remove_return); 5051 DEFINE_DAS_STATE_EVENT(xfs_attr_defer_add); 5052 5053 5054 TRACE_EVENT(xfs_force_shutdown, 5055 TP_PROTO(struct xfs_mount *mp, int ptag, int flags, const char *fname, 5056 int line_num), 5057 TP_ARGS(mp, ptag, flags, fname, line_num), 5058 TP_STRUCT__entry( 5059 __field(dev_t, dev) 5060 __field(int, ptag) 5061 __field(int, flags) 5062 __string(fname, fname) 5063 __field(int, line_num) 5064 ), 5065 TP_fast_assign( 5066 __entry->dev = mp->m_super->s_dev; 5067 __entry->ptag = ptag; 5068 __entry->flags = flags; 5069 __assign_str(fname); 5070 __entry->line_num = line_num; 5071 ), 5072 TP_printk("dev %d:%d tag %s flags %s file %s line_num %d", 5073 MAJOR(__entry->dev), MINOR(__entry->dev), 5074 __print_flags(__entry->ptag, "|", XFS_PTAG_STRINGS), 5075 __print_flags(__entry->flags, "|", XFS_SHUTDOWN_STRINGS), 5076 __get_str(fname), 5077 __entry->line_num) 5078 ); 5079 5080 #ifdef CONFIG_XFS_DRAIN_INTENTS 5081 DECLARE_EVENT_CLASS(xfs_group_intents_class, 5082 TP_PROTO(const struct xfs_group *xg, void *caller_ip), 5083 TP_ARGS(xg, caller_ip), 5084 TP_STRUCT__entry( 5085 __field(dev_t, dev) 5086 __field(enum xfs_group_type, type) 5087 __field(uint32_t, index) 5088 __field(long, nr_intents) 5089 __field(void *, caller_ip) 5090 ), 5091 TP_fast_assign( 5092 __entry->dev = xg->xg_mount->m_super->s_dev; 5093 __entry->type = xg->xg_type; 5094 __entry->index = xg->xg_gno; 5095 __entry->nr_intents = 5096 atomic_read(&xg->xg_intents_drain.dr_count); 5097 __entry->caller_ip = caller_ip; 5098 ), 5099 TP_printk("dev %d:%d %sno 0x%x intents %ld caller %pS", 5100 MAJOR(__entry->dev), MINOR(__entry->dev), 5101 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 5102 __entry->index, 5103 __entry->nr_intents, 5104 __entry->caller_ip) 5105 ); 5106 5107 #define DEFINE_GROUP_INTENTS_EVENT(name) \ 5108 DEFINE_EVENT(xfs_group_intents_class, name, \ 5109 TP_PROTO(const struct xfs_group *xg, void *caller_ip), \ 5110 TP_ARGS(xg, caller_ip)) 5111 DEFINE_GROUP_INTENTS_EVENT(xfs_group_intent_hold); 5112 DEFINE_GROUP_INTENTS_EVENT(xfs_group_intent_rele); 5113 DEFINE_GROUP_INTENTS_EVENT(xfs_group_wait_intents); 5114 5115 #endif /* CONFIG_XFS_DRAIN_INTENTS */ 5116 5117 #ifdef CONFIG_XFS_MEMORY_BUFS 5118 TRACE_EVENT(xmbuf_create, 5119 TP_PROTO(struct xfs_buftarg *btp), 5120 TP_ARGS(btp), 5121 TP_STRUCT__entry( 5122 __field(dev_t, dev) 5123 __field(unsigned long, ino) 5124 ), 5125 TP_fast_assign( 5126 struct file *file = btp->bt_file; 5127 5128 __entry->dev = btp->bt_mount->m_super->s_dev; 5129 __entry->ino = file_inode(file)->i_ino; 5130 ), 5131 TP_printk("dev %d:%d xmino 0x%lx", 5132 MAJOR(__entry->dev), MINOR(__entry->dev), 5133 __entry->ino) 5134 ); 5135 5136 TRACE_EVENT(xmbuf_free, 5137 TP_PROTO(struct xfs_buftarg *btp), 5138 TP_ARGS(btp), 5139 TP_STRUCT__entry( 5140 __field(dev_t, dev) 5141 __field(unsigned long, ino) 5142 __field(unsigned long long, bytes) 5143 __field(loff_t, size) 5144 ), 5145 TP_fast_assign( 5146 struct file *file = btp->bt_file; 5147 struct inode *inode = file_inode(file); 5148 5149 __entry->dev = btp->bt_mount->m_super->s_dev; 5150 __entry->size = i_size_read(inode); 5151 __entry->bytes = (inode->i_blocks << SECTOR_SHIFT) + inode->i_bytes; 5152 __entry->ino = inode->i_ino; 5153 ), 5154 TP_printk("dev %d:%d xmino 0x%lx mem_bytes 0x%llx isize 0x%llx", 5155 MAJOR(__entry->dev), MINOR(__entry->dev), 5156 __entry->ino, 5157 __entry->bytes, 5158 __entry->size) 5159 ); 5160 #endif /* CONFIG_XFS_MEMORY_BUFS */ 5161 5162 #ifdef CONFIG_XFS_BTREE_IN_MEM 5163 TRACE_EVENT(xfbtree_init, 5164 TP_PROTO(struct xfs_mount *mp, struct xfbtree *xfbt, 5165 const struct xfs_btree_ops *ops), 5166 TP_ARGS(mp, xfbt, ops), 5167 TP_STRUCT__entry( 5168 __field(const void *, btree_ops) 5169 __field(unsigned long, xfino) 5170 __field(unsigned int, leaf_mxr) 5171 __field(unsigned int, leaf_mnr) 5172 __field(unsigned int, node_mxr) 5173 __field(unsigned int, node_mnr) 5174 __field(unsigned long long, owner) 5175 ), 5176 TP_fast_assign( 5177 __entry->btree_ops = ops; 5178 __entry->xfino = file_inode(xfbt->target->bt_file)->i_ino; 5179 __entry->leaf_mxr = xfbt->maxrecs[0]; 5180 __entry->node_mxr = xfbt->maxrecs[1]; 5181 __entry->leaf_mnr = xfbt->minrecs[0]; 5182 __entry->node_mnr = xfbt->minrecs[1]; 5183 __entry->owner = xfbt->owner; 5184 ), 5185 TP_printk("xfino 0x%lx btree_ops %pS owner 0x%llx leaf_mxr %u leaf_mnr %u node_mxr %u node_mnr %u", 5186 __entry->xfino, 5187 __entry->btree_ops, 5188 __entry->owner, 5189 __entry->leaf_mxr, 5190 __entry->leaf_mnr, 5191 __entry->node_mxr, 5192 __entry->node_mnr) 5193 ); 5194 5195 DECLARE_EVENT_CLASS(xfbtree_buf_class, 5196 TP_PROTO(struct xfbtree *xfbt, struct xfs_buf *bp), 5197 TP_ARGS(xfbt, bp), 5198 TP_STRUCT__entry( 5199 __field(unsigned long, xfino) 5200 __field(xfs_daddr_t, bno) 5201 __field(int, nblks) 5202 __field(int, hold) 5203 __field(int, pincount) 5204 __field(unsigned int, lockval) 5205 __field(unsigned int, flags) 5206 ), 5207 TP_fast_assign( 5208 __entry->xfino = file_inode(xfbt->target->bt_file)->i_ino; 5209 __entry->bno = xfs_buf_daddr(bp); 5210 __entry->nblks = bp->b_length; 5211 __entry->hold = bp->b_lockref.count; 5212 __entry->pincount = atomic_read(&bp->b_pin_count); 5213 __entry->lockval = bp->b_sema.count; 5214 __entry->flags = bp->b_flags; 5215 ), 5216 TP_printk("xfino 0x%lx daddr 0x%llx bbcount 0x%x hold %d pincount %d lock %d flags %s", 5217 __entry->xfino, 5218 (unsigned long long)__entry->bno, 5219 __entry->nblks, 5220 __entry->hold, 5221 __entry->pincount, 5222 __entry->lockval, 5223 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS)) 5224 ) 5225 5226 #define DEFINE_XFBTREE_BUF_EVENT(name) \ 5227 DEFINE_EVENT(xfbtree_buf_class, name, \ 5228 TP_PROTO(struct xfbtree *xfbt, struct xfs_buf *bp), \ 5229 TP_ARGS(xfbt, bp)) 5230 DEFINE_XFBTREE_BUF_EVENT(xfbtree_create_root_buf); 5231 DEFINE_XFBTREE_BUF_EVENT(xfbtree_trans_commit_buf); 5232 DEFINE_XFBTREE_BUF_EVENT(xfbtree_trans_cancel_buf); 5233 5234 DECLARE_EVENT_CLASS(xfbtree_freesp_class, 5235 TP_PROTO(struct xfbtree *xfbt, struct xfs_btree_cur *cur, 5236 xfs_fileoff_t fileoff), 5237 TP_ARGS(xfbt, cur, fileoff), 5238 TP_STRUCT__entry( 5239 __field(unsigned long, xfino) 5240 __string(btname, cur->bc_ops->name) 5241 __field(int, nlevels) 5242 __field(xfs_fileoff_t, fileoff) 5243 ), 5244 TP_fast_assign( 5245 __entry->xfino = file_inode(xfbt->target->bt_file)->i_ino; 5246 __assign_str(btname); 5247 __entry->nlevels = cur->bc_nlevels; 5248 __entry->fileoff = fileoff; 5249 ), 5250 TP_printk("xfino 0x%lx %sbt nlevels %d fileoff 0x%llx", 5251 __entry->xfino, 5252 __get_str(btname), 5253 __entry->nlevels, 5254 (unsigned long long)__entry->fileoff) 5255 ) 5256 5257 #define DEFINE_XFBTREE_FREESP_EVENT(name) \ 5258 DEFINE_EVENT(xfbtree_freesp_class, name, \ 5259 TP_PROTO(struct xfbtree *xfbt, struct xfs_btree_cur *cur, \ 5260 xfs_fileoff_t fileoff), \ 5261 TP_ARGS(xfbt, cur, fileoff)) 5262 DEFINE_XFBTREE_FREESP_EVENT(xfbtree_alloc_block); 5263 DEFINE_XFBTREE_FREESP_EVENT(xfbtree_free_block); 5264 #endif /* CONFIG_XFS_BTREE_IN_MEM */ 5265 5266 /* exchmaps tracepoints */ 5267 #define XFS_EXCHMAPS_STRINGS \ 5268 { XFS_EXCHMAPS_ATTR_FORK, "ATTRFORK" }, \ 5269 { XFS_EXCHMAPS_SET_SIZES, "SETSIZES" }, \ 5270 { XFS_EXCHMAPS_INO1_WRITTEN, "INO1_WRITTEN" }, \ 5271 { XFS_EXCHMAPS_CLEAR_INO1_REFLINK, "CLEAR_INO1_REFLINK" }, \ 5272 { XFS_EXCHMAPS_CLEAR_INO2_REFLINK, "CLEAR_INO2_REFLINK" }, \ 5273 { __XFS_EXCHMAPS_INO2_SHORTFORM, "INO2_SF" } 5274 5275 DEFINE_INODE_IREC_EVENT(xfs_exchmaps_mapping1_skip); 5276 DEFINE_INODE_IREC_EVENT(xfs_exchmaps_mapping1); 5277 DEFINE_INODE_IREC_EVENT(xfs_exchmaps_mapping2); 5278 DEFINE_ITRUNC_EVENT(xfs_exchmaps_update_inode_size); 5279 5280 #define XFS_EXCHRANGE_INODES \ 5281 { 1, "file1" }, \ 5282 { 2, "file2" } 5283 5284 DECLARE_EVENT_CLASS(xfs_exchrange_inode_class, 5285 TP_PROTO(struct xfs_inode *ip, int whichfile), 5286 TP_ARGS(ip, whichfile), 5287 TP_STRUCT__entry( 5288 __field(dev_t, dev) 5289 __field(int, whichfile) 5290 __field(xfs_ino_t, ino) 5291 __field(int, format) 5292 __field(xfs_extnum_t, nex) 5293 __field(int, broot_size) 5294 __field(int, fork_off) 5295 ), 5296 TP_fast_assign( 5297 __entry->dev = VFS_I(ip)->i_sb->s_dev; 5298 __entry->whichfile = whichfile; 5299 __entry->ino = ip->i_ino; 5300 __entry->format = ip->i_df.if_format; 5301 __entry->nex = ip->i_df.if_nextents; 5302 __entry->fork_off = xfs_inode_fork_boff(ip); 5303 ), 5304 TP_printk("dev %d:%d ino 0x%llx whichfile %s format %s num_extents %llu forkoff 0x%x", 5305 MAJOR(__entry->dev), MINOR(__entry->dev), 5306 __entry->ino, 5307 __print_symbolic(__entry->whichfile, XFS_EXCHRANGE_INODES), 5308 __print_symbolic(__entry->format, XFS_INODE_FORMAT_STR), 5309 __entry->nex, 5310 __entry->fork_off) 5311 ) 5312 5313 #define DEFINE_EXCHRANGE_INODE_EVENT(name) \ 5314 DEFINE_EVENT(xfs_exchrange_inode_class, name, \ 5315 TP_PROTO(struct xfs_inode *ip, int whichfile), \ 5316 TP_ARGS(ip, whichfile)) 5317 5318 DEFINE_EXCHRANGE_INODE_EVENT(xfs_exchrange_before); 5319 DEFINE_EXCHRANGE_INODE_EVENT(xfs_exchrange_after); 5320 DEFINE_INODE_ERROR_EVENT(xfs_exchrange_error); 5321 5322 #define XFS_EXCHANGE_RANGE_FLAGS_STRS \ 5323 { XFS_EXCHANGE_RANGE_TO_EOF, "TO_EOF" }, \ 5324 { XFS_EXCHANGE_RANGE_DSYNC , "DSYNC" }, \ 5325 { XFS_EXCHANGE_RANGE_DRY_RUN, "DRY_RUN" }, \ 5326 { XFS_EXCHANGE_RANGE_FILE1_WRITTEN, "F1_WRITTEN" }, \ 5327 { __XFS_EXCHANGE_RANGE_UPD_CMTIME1, "CMTIME1" }, \ 5328 { __XFS_EXCHANGE_RANGE_UPD_CMTIME2, "CMTIME2" }, \ 5329 { __XFS_EXCHANGE_RANGE_CHECK_FRESH2, "FRESH2" } 5330 5331 /* file exchange-range tracepoint class */ 5332 DECLARE_EVENT_CLASS(xfs_exchrange_class, 5333 TP_PROTO(const struct xfs_exchrange *fxr, struct xfs_inode *ip1, 5334 struct xfs_inode *ip2), 5335 TP_ARGS(fxr, ip1, ip2), 5336 TP_STRUCT__entry( 5337 __field(dev_t, dev) 5338 __field(xfs_ino_t, ip1_ino) 5339 __field(loff_t, ip1_isize) 5340 __field(loff_t, ip1_disize) 5341 __field(xfs_ino_t, ip2_ino) 5342 __field(loff_t, ip2_isize) 5343 __field(loff_t, ip2_disize) 5344 5345 __field(loff_t, file1_offset) 5346 __field(loff_t, file2_offset) 5347 __field(unsigned long long, length) 5348 __field(unsigned long long, flags) 5349 ), 5350 TP_fast_assign( 5351 __entry->dev = VFS_I(ip1)->i_sb->s_dev; 5352 __entry->ip1_ino = ip1->i_ino; 5353 __entry->ip1_isize = VFS_I(ip1)->i_size; 5354 __entry->ip1_disize = ip1->i_disk_size; 5355 __entry->ip2_ino = ip2->i_ino; 5356 __entry->ip2_isize = VFS_I(ip2)->i_size; 5357 __entry->ip2_disize = ip2->i_disk_size; 5358 5359 __entry->file1_offset = fxr->file1_offset; 5360 __entry->file2_offset = fxr->file2_offset; 5361 __entry->length = fxr->length; 5362 __entry->flags = fxr->flags; 5363 ), 5364 TP_printk("dev %d:%d flags %s bytecount 0x%llx " 5365 "ino1 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx -> " 5366 "ino2 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx", 5367 MAJOR(__entry->dev), MINOR(__entry->dev), 5368 __print_flags_u64(__entry->flags, "|", XFS_EXCHANGE_RANGE_FLAGS_STRS), 5369 __entry->length, 5370 __entry->ip1_ino, 5371 __entry->ip1_isize, 5372 __entry->ip1_disize, 5373 __entry->file1_offset, 5374 __entry->ip2_ino, 5375 __entry->ip2_isize, 5376 __entry->ip2_disize, 5377 __entry->file2_offset) 5378 ) 5379 5380 #define DEFINE_EXCHRANGE_EVENT(name) \ 5381 DEFINE_EVENT(xfs_exchrange_class, name, \ 5382 TP_PROTO(const struct xfs_exchrange *fxr, struct xfs_inode *ip1, \ 5383 struct xfs_inode *ip2), \ 5384 TP_ARGS(fxr, ip1, ip2)) 5385 DEFINE_EXCHRANGE_EVENT(xfs_exchrange_prep); 5386 DEFINE_EXCHRANGE_EVENT(xfs_exchrange_flush); 5387 DEFINE_EXCHRANGE_EVENT(xfs_exchrange_mappings); 5388 5389 TRACE_EVENT(xfs_exchrange_freshness, 5390 TP_PROTO(const struct xfs_exchrange *fxr, struct xfs_inode *ip2), 5391 TP_ARGS(fxr, ip2), 5392 TP_STRUCT__entry( 5393 __field(dev_t, dev) 5394 __field(xfs_ino_t, ip2_ino) 5395 __field(long long, ip2_mtime) 5396 __field(long long, ip2_ctime) 5397 __field(int, ip2_mtime_nsec) 5398 __field(int, ip2_ctime_nsec) 5399 5400 __field(xfs_ino_t, file2_ino) 5401 __field(long long, file2_mtime) 5402 __field(long long, file2_ctime) 5403 __field(int, file2_mtime_nsec) 5404 __field(int, file2_ctime_nsec) 5405 ), 5406 TP_fast_assign( 5407 struct timespec64 ts64; 5408 struct inode *inode2 = VFS_I(ip2); 5409 5410 __entry->dev = inode2->i_sb->s_dev; 5411 __entry->ip2_ino = ip2->i_ino; 5412 5413 ts64 = inode_get_ctime(inode2); 5414 __entry->ip2_ctime = ts64.tv_sec; 5415 __entry->ip2_ctime_nsec = ts64.tv_nsec; 5416 5417 ts64 = inode_get_mtime(inode2); 5418 __entry->ip2_mtime = ts64.tv_sec; 5419 __entry->ip2_mtime_nsec = ts64.tv_nsec; 5420 5421 __entry->file2_ino = fxr->file2_ino; 5422 __entry->file2_mtime = fxr->file2_mtime.tv_sec; 5423 __entry->file2_ctime = fxr->file2_ctime.tv_sec; 5424 __entry->file2_mtime_nsec = fxr->file2_mtime.tv_nsec; 5425 __entry->file2_ctime_nsec = fxr->file2_ctime.tv_nsec; 5426 ), 5427 TP_printk("dev %d:%d " 5428 "ino 0x%llx mtime %lld:%d ctime %lld:%d -> " 5429 "file 0x%llx mtime %lld:%d ctime %lld:%d", 5430 MAJOR(__entry->dev), MINOR(__entry->dev), 5431 __entry->ip2_ino, 5432 __entry->ip2_mtime, 5433 __entry->ip2_mtime_nsec, 5434 __entry->ip2_ctime, 5435 __entry->ip2_ctime_nsec, 5436 __entry->file2_ino, 5437 __entry->file2_mtime, 5438 __entry->file2_mtime_nsec, 5439 __entry->file2_ctime, 5440 __entry->file2_ctime_nsec) 5441 ); 5442 5443 TRACE_EVENT(xfs_exchmaps_overhead, 5444 TP_PROTO(struct xfs_mount *mp, unsigned long long bmbt_blocks, 5445 unsigned long long rmapbt_blocks), 5446 TP_ARGS(mp, bmbt_blocks, rmapbt_blocks), 5447 TP_STRUCT__entry( 5448 __field(dev_t, dev) 5449 __field(unsigned long long, bmbt_blocks) 5450 __field(unsigned long long, rmapbt_blocks) 5451 ), 5452 TP_fast_assign( 5453 __entry->dev = mp->m_super->s_dev; 5454 __entry->bmbt_blocks = bmbt_blocks; 5455 __entry->rmapbt_blocks = rmapbt_blocks; 5456 ), 5457 TP_printk("dev %d:%d bmbt_blocks 0x%llx rmapbt_blocks 0x%llx", 5458 MAJOR(__entry->dev), MINOR(__entry->dev), 5459 __entry->bmbt_blocks, 5460 __entry->rmapbt_blocks) 5461 ); 5462 5463 DECLARE_EVENT_CLASS(xfs_exchmaps_estimate_class, 5464 TP_PROTO(const struct xfs_exchmaps_req *req), 5465 TP_ARGS(req), 5466 TP_STRUCT__entry( 5467 __field(dev_t, dev) 5468 __field(xfs_ino_t, ino1) 5469 __field(xfs_ino_t, ino2) 5470 __field(xfs_fileoff_t, startoff1) 5471 __field(xfs_fileoff_t, startoff2) 5472 __field(xfs_filblks_t, blockcount) 5473 __field(uint64_t, flags) 5474 __field(xfs_filblks_t, ip1_bcount) 5475 __field(xfs_filblks_t, ip2_bcount) 5476 __field(xfs_filblks_t, ip1_rtbcount) 5477 __field(xfs_filblks_t, ip2_rtbcount) 5478 __field(unsigned long long, resblks) 5479 __field(unsigned long long, nr_exchanges) 5480 ), 5481 TP_fast_assign( 5482 __entry->dev = req->ip1->i_mount->m_super->s_dev; 5483 __entry->ino1 = req->ip1->i_ino; 5484 __entry->ino2 = req->ip2->i_ino; 5485 __entry->startoff1 = req->startoff1; 5486 __entry->startoff2 = req->startoff2; 5487 __entry->blockcount = req->blockcount; 5488 __entry->flags = req->flags; 5489 __entry->ip1_bcount = req->ip1_bcount; 5490 __entry->ip2_bcount = req->ip2_bcount; 5491 __entry->ip1_rtbcount = req->ip1_rtbcount; 5492 __entry->ip2_rtbcount = req->ip2_rtbcount; 5493 __entry->resblks = req->resblks; 5494 __entry->nr_exchanges = req->nr_exchanges; 5495 ), 5496 TP_printk("dev %d:%d ino1 0x%llx fileoff1 0x%llx ino2 0x%llx fileoff2 0x%llx fsbcount 0x%llx flags (%s) bcount1 0x%llx rtbcount1 0x%llx bcount2 0x%llx rtbcount2 0x%llx resblks 0x%llx nr_exchanges %llu", 5497 MAJOR(__entry->dev), MINOR(__entry->dev), 5498 __entry->ino1, __entry->startoff1, 5499 __entry->ino2, __entry->startoff2, 5500 __entry->blockcount, 5501 __print_flags_u64(__entry->flags, "|", XFS_EXCHMAPS_STRINGS), 5502 __entry->ip1_bcount, 5503 __entry->ip1_rtbcount, 5504 __entry->ip2_bcount, 5505 __entry->ip2_rtbcount, 5506 __entry->resblks, 5507 __entry->nr_exchanges) 5508 ); 5509 5510 #define DEFINE_EXCHMAPS_ESTIMATE_EVENT(name) \ 5511 DEFINE_EVENT(xfs_exchmaps_estimate_class, name, \ 5512 TP_PROTO(const struct xfs_exchmaps_req *req), \ 5513 TP_ARGS(req)) 5514 DEFINE_EXCHMAPS_ESTIMATE_EVENT(xfs_exchmaps_initial_estimate); 5515 DEFINE_EXCHMAPS_ESTIMATE_EVENT(xfs_exchmaps_final_estimate); 5516 5517 DECLARE_EVENT_CLASS(xfs_exchmaps_intent_class, 5518 TP_PROTO(struct xfs_mount *mp, const struct xfs_exchmaps_intent *xmi), 5519 TP_ARGS(mp, xmi), 5520 TP_STRUCT__entry( 5521 __field(dev_t, dev) 5522 __field(xfs_ino_t, ino1) 5523 __field(xfs_ino_t, ino2) 5524 __field(uint64_t, flags) 5525 __field(xfs_fileoff_t, startoff1) 5526 __field(xfs_fileoff_t, startoff2) 5527 __field(xfs_filblks_t, blockcount) 5528 __field(xfs_fsize_t, isize1) 5529 __field(xfs_fsize_t, isize2) 5530 __field(xfs_fsize_t, new_isize1) 5531 __field(xfs_fsize_t, new_isize2) 5532 ), 5533 TP_fast_assign( 5534 __entry->dev = mp->m_super->s_dev; 5535 __entry->ino1 = xmi->xmi_ip1->i_ino; 5536 __entry->ino2 = xmi->xmi_ip2->i_ino; 5537 __entry->flags = xmi->xmi_flags; 5538 __entry->startoff1 = xmi->xmi_startoff1; 5539 __entry->startoff2 = xmi->xmi_startoff2; 5540 __entry->blockcount = xmi->xmi_blockcount; 5541 __entry->isize1 = xmi->xmi_ip1->i_disk_size; 5542 __entry->isize2 = xmi->xmi_ip2->i_disk_size; 5543 __entry->new_isize1 = xmi->xmi_isize1; 5544 __entry->new_isize2 = xmi->xmi_isize2; 5545 ), 5546 TP_printk("dev %d:%d ino1 0x%llx fileoff1 0x%llx ino2 0x%llx fileoff2 0x%llx fsbcount 0x%llx flags (%s) isize1 0x%llx newisize1 0x%llx isize2 0x%llx newisize2 0x%llx", 5547 MAJOR(__entry->dev), MINOR(__entry->dev), 5548 __entry->ino1, __entry->startoff1, 5549 __entry->ino2, __entry->startoff2, 5550 __entry->blockcount, 5551 __print_flags_u64(__entry->flags, "|", XFS_EXCHMAPS_STRINGS), 5552 __entry->isize1, __entry->new_isize1, 5553 __entry->isize2, __entry->new_isize2) 5554 ); 5555 5556 #define DEFINE_EXCHMAPS_INTENT_EVENT(name) \ 5557 DEFINE_EVENT(xfs_exchmaps_intent_class, name, \ 5558 TP_PROTO(struct xfs_mount *mp, const struct xfs_exchmaps_intent *xmi), \ 5559 TP_ARGS(mp, xmi)) 5560 DEFINE_EXCHMAPS_INTENT_EVENT(xfs_exchmaps_defer); 5561 DEFINE_EXCHMAPS_INTENT_EVENT(xfs_exchmaps_recover); 5562 5563 TRACE_EVENT(xfs_exchmaps_delta_nextents_step, 5564 TP_PROTO(struct xfs_mount *mp, 5565 const struct xfs_bmbt_irec *left, 5566 const struct xfs_bmbt_irec *curr, 5567 const struct xfs_bmbt_irec *new, 5568 const struct xfs_bmbt_irec *right, 5569 int delta, unsigned int state), 5570 TP_ARGS(mp, left, curr, new, right, delta, state), 5571 TP_STRUCT__entry( 5572 __field(dev_t, dev) 5573 __field(xfs_fileoff_t, loff) 5574 __field(xfs_fsblock_t, lstart) 5575 __field(xfs_filblks_t, lcount) 5576 __field(xfs_fileoff_t, coff) 5577 __field(xfs_fsblock_t, cstart) 5578 __field(xfs_filblks_t, ccount) 5579 __field(xfs_fileoff_t, noff) 5580 __field(xfs_fsblock_t, nstart) 5581 __field(xfs_filblks_t, ncount) 5582 __field(xfs_fileoff_t, roff) 5583 __field(xfs_fsblock_t, rstart) 5584 __field(xfs_filblks_t, rcount) 5585 __field(int, delta) 5586 __field(unsigned int, state) 5587 ), 5588 TP_fast_assign( 5589 __entry->dev = mp->m_super->s_dev; 5590 __entry->loff = left->br_startoff; 5591 __entry->lstart = left->br_startblock; 5592 __entry->lcount = left->br_blockcount; 5593 __entry->coff = curr->br_startoff; 5594 __entry->cstart = curr->br_startblock; 5595 __entry->ccount = curr->br_blockcount; 5596 __entry->noff = new->br_startoff; 5597 __entry->nstart = new->br_startblock; 5598 __entry->ncount = new->br_blockcount; 5599 __entry->roff = right->br_startoff; 5600 __entry->rstart = right->br_startblock; 5601 __entry->rcount = right->br_blockcount; 5602 __entry->delta = delta; 5603 __entry->state = state; 5604 ), 5605 TP_printk("dev %d:%d left 0x%llx:0x%llx:0x%llx; curr 0x%llx:0x%llx:0x%llx <- new 0x%llx:0x%llx:0x%llx; right 0x%llx:0x%llx:0x%llx delta %d state 0x%x", 5606 MAJOR(__entry->dev), MINOR(__entry->dev), 5607 __entry->loff, __entry->lstart, __entry->lcount, 5608 __entry->coff, __entry->cstart, __entry->ccount, 5609 __entry->noff, __entry->nstart, __entry->ncount, 5610 __entry->roff, __entry->rstart, __entry->rcount, 5611 __entry->delta, __entry->state) 5612 ); 5613 5614 TRACE_EVENT(xfs_exchmaps_delta_nextents, 5615 TP_PROTO(const struct xfs_exchmaps_req *req, int64_t d_nexts1, 5616 int64_t d_nexts2), 5617 TP_ARGS(req, d_nexts1, d_nexts2), 5618 TP_STRUCT__entry( 5619 __field(dev_t, dev) 5620 __field(xfs_ino_t, ino1) 5621 __field(xfs_ino_t, ino2) 5622 __field(xfs_extnum_t, nexts1) 5623 __field(xfs_extnum_t, nexts2) 5624 __field(int64_t, d_nexts1) 5625 __field(int64_t, d_nexts2) 5626 ), 5627 TP_fast_assign( 5628 int whichfork = xfs_exchmaps_reqfork(req); 5629 5630 __entry->dev = req->ip1->i_mount->m_super->s_dev; 5631 __entry->ino1 = req->ip1->i_ino; 5632 __entry->ino2 = req->ip2->i_ino; 5633 __entry->nexts1 = xfs_ifork_ptr(req->ip1, whichfork)->if_nextents; 5634 __entry->nexts2 = xfs_ifork_ptr(req->ip2, whichfork)->if_nextents; 5635 __entry->d_nexts1 = d_nexts1; 5636 __entry->d_nexts2 = d_nexts2; 5637 ), 5638 TP_printk("dev %d:%d ino1 0x%llx nexts %llu ino2 0x%llx nexts %llu delta1 %lld delta2 %lld", 5639 MAJOR(__entry->dev), MINOR(__entry->dev), 5640 __entry->ino1, __entry->nexts1, 5641 __entry->ino2, __entry->nexts2, 5642 __entry->d_nexts1, __entry->d_nexts2) 5643 ); 5644 5645 DECLARE_EVENT_CLASS(xfs_getparents_rec_class, 5646 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, 5647 const struct xfs_attr_list_context *context, 5648 const struct xfs_getparents_rec *pptr), 5649 TP_ARGS(ip, ppi, context, pptr), 5650 TP_STRUCT__entry( 5651 __field(dev_t, dev) 5652 __field(xfs_ino_t, ino) 5653 __field(unsigned int, firstu) 5654 __field(unsigned short, reclen) 5655 __field(unsigned int, bufsize) 5656 __field(xfs_ino_t, parent_ino) 5657 __field(unsigned int, parent_gen) 5658 __string(name, pptr->gpr_name) 5659 ), 5660 TP_fast_assign( 5661 __entry->dev = ip->i_mount->m_super->s_dev; 5662 __entry->ino = ip->i_ino; 5663 __entry->firstu = context->firstu; 5664 __entry->reclen = pptr->gpr_reclen; 5665 __entry->bufsize = ppi->gp_bufsize; 5666 __entry->parent_ino = pptr->gpr_parent.ha_fid.fid_ino; 5667 __entry->parent_gen = pptr->gpr_parent.ha_fid.fid_gen; 5668 __assign_str(name); 5669 ), 5670 TP_printk("dev %d:%d ino 0x%llx firstu %u reclen %u bufsize %u parent_ino 0x%llx parent_gen 0x%x name '%s'", 5671 MAJOR(__entry->dev), MINOR(__entry->dev), 5672 __entry->ino, 5673 __entry->firstu, 5674 __entry->reclen, 5675 __entry->bufsize, 5676 __entry->parent_ino, 5677 __entry->parent_gen, 5678 __get_str(name)) 5679 ) 5680 #define DEFINE_XFS_GETPARENTS_REC_EVENT(name) \ 5681 DEFINE_EVENT(xfs_getparents_rec_class, name, \ 5682 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, \ 5683 const struct xfs_attr_list_context *context, \ 5684 const struct xfs_getparents_rec *pptr), \ 5685 TP_ARGS(ip, ppi, context, pptr)) 5686 DEFINE_XFS_GETPARENTS_REC_EVENT(xfs_getparents_put_listent); 5687 DEFINE_XFS_GETPARENTS_REC_EVENT(xfs_getparents_expand_lastrec); 5688 5689 DECLARE_EVENT_CLASS(xfs_getparents_class, 5690 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, 5691 const struct xfs_attrlist_cursor_kern *cur), 5692 TP_ARGS(ip, ppi, cur), 5693 TP_STRUCT__entry( 5694 __field(dev_t, dev) 5695 __field(xfs_ino_t, ino) 5696 __field(unsigned short, iflags) 5697 __field(unsigned short, oflags) 5698 __field(unsigned int, bufsize) 5699 __field(unsigned int, hashval) 5700 __field(unsigned int, blkno) 5701 __field(unsigned int, offset) 5702 __field(int, initted) 5703 ), 5704 TP_fast_assign( 5705 __entry->dev = ip->i_mount->m_super->s_dev; 5706 __entry->ino = ip->i_ino; 5707 __entry->iflags = ppi->gp_iflags; 5708 __entry->oflags = ppi->gp_oflags; 5709 __entry->bufsize = ppi->gp_bufsize; 5710 __entry->hashval = cur->hashval; 5711 __entry->blkno = cur->blkno; 5712 __entry->offset = cur->offset; 5713 __entry->initted = cur->initted; 5714 ), 5715 TP_printk("dev %d:%d ino 0x%llx iflags 0x%x oflags 0x%x bufsize %u cur_init? %d hashval 0x%x blkno %u offset %u", 5716 MAJOR(__entry->dev), MINOR(__entry->dev), 5717 __entry->ino, 5718 __entry->iflags, 5719 __entry->oflags, 5720 __entry->bufsize, 5721 __entry->initted, 5722 __entry->hashval, 5723 __entry->blkno, 5724 __entry->offset) 5725 ) 5726 #define DEFINE_XFS_GETPARENTS_EVENT(name) \ 5727 DEFINE_EVENT(xfs_getparents_class, name, \ 5728 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, \ 5729 const struct xfs_attrlist_cursor_kern *cur), \ 5730 TP_ARGS(ip, ppi, cur)) 5731 DEFINE_XFS_GETPARENTS_EVENT(xfs_getparents_begin); 5732 DEFINE_XFS_GETPARENTS_EVENT(xfs_getparents_end); 5733 5734 DECLARE_EVENT_CLASS(xfs_metadir_update_class, 5735 TP_PROTO(const struct xfs_metadir_update *upd), 5736 TP_ARGS(upd), 5737 TP_STRUCT__entry( 5738 __field(dev_t, dev) 5739 __field(xfs_ino_t, dp_ino) 5740 __field(xfs_ino_t, ino) 5741 __string(fname, upd->path) 5742 ), 5743 TP_fast_assign( 5744 __entry->dev = upd->dp->i_mount->m_super->s_dev; 5745 __entry->dp_ino = upd->dp->i_ino; 5746 __entry->ino = upd->ip ? upd->ip->i_ino : NULLFSINO; 5747 __assign_str(fname); 5748 ), 5749 TP_printk("dev %d:%d dp 0x%llx fname '%s' ino 0x%llx", 5750 MAJOR(__entry->dev), MINOR(__entry->dev), 5751 __entry->dp_ino, 5752 __get_str(fname), 5753 __entry->ino) 5754 ) 5755 5756 #define DEFINE_METADIR_UPDATE_EVENT(name) \ 5757 DEFINE_EVENT(xfs_metadir_update_class, name, \ 5758 TP_PROTO(const struct xfs_metadir_update *upd), \ 5759 TP_ARGS(upd)) 5760 DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_start_create); 5761 DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_start_link); 5762 DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_commit); 5763 DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_cancel); 5764 DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_try_create); 5765 DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_create); 5766 DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_link); 5767 5768 DECLARE_EVENT_CLASS(xfs_metadir_update_error_class, 5769 TP_PROTO(const struct xfs_metadir_update *upd, int error), 5770 TP_ARGS(upd, error), 5771 TP_STRUCT__entry( 5772 __field(dev_t, dev) 5773 __field(xfs_ino_t, dp_ino) 5774 __field(xfs_ino_t, ino) 5775 __field(int, error) 5776 __string(fname, upd->path) 5777 ), 5778 TP_fast_assign( 5779 __entry->dev = upd->dp->i_mount->m_super->s_dev; 5780 __entry->dp_ino = upd->dp->i_ino; 5781 __entry->ino = upd->ip ? upd->ip->i_ino : NULLFSINO; 5782 __entry->error = error; 5783 __assign_str(fname); 5784 ), 5785 TP_printk("dev %d:%d dp 0x%llx fname '%s' ino 0x%llx error %d", 5786 MAJOR(__entry->dev), MINOR(__entry->dev), 5787 __entry->dp_ino, 5788 __get_str(fname), 5789 __entry->ino, 5790 __entry->error) 5791 ) 5792 5793 #define DEFINE_METADIR_UPDATE_ERROR_EVENT(name) \ 5794 DEFINE_EVENT(xfs_metadir_update_error_class, name, \ 5795 TP_PROTO(const struct xfs_metadir_update *upd, int error), \ 5796 TP_ARGS(upd, error)) 5797 DEFINE_METADIR_UPDATE_ERROR_EVENT(xfs_metadir_teardown); 5798 5799 DECLARE_EVENT_CLASS(xfs_metadir_class, 5800 TP_PROTO(struct xfs_inode *dp, struct xfs_name *name, 5801 xfs_ino_t ino), 5802 TP_ARGS(dp, name, ino), 5803 TP_STRUCT__entry( 5804 __field(dev_t, dev) 5805 __field(xfs_ino_t, dp_ino) 5806 __field(xfs_ino_t, ino) 5807 __field(int, ftype) 5808 __field(int, namelen) 5809 __dynamic_array(char, name, name->len) 5810 ), 5811 TP_fast_assign( 5812 __entry->dev = VFS_I(dp)->i_sb->s_dev; 5813 __entry->dp_ino = dp->i_ino; 5814 __entry->ino = ino, 5815 __entry->ftype = name->type; 5816 __entry->namelen = name->len; 5817 memcpy(__get_str(name), name->name, name->len); 5818 ), 5819 TP_printk("dev %d:%d dir 0x%llx type %s name '%.*s' ino 0x%llx", 5820 MAJOR(__entry->dev), MINOR(__entry->dev), 5821 __entry->dp_ino, 5822 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 5823 __entry->namelen, 5824 __get_str(name), 5825 __entry->ino) 5826 ) 5827 5828 #define DEFINE_METADIR_EVENT(name) \ 5829 DEFINE_EVENT(xfs_metadir_class, name, \ 5830 TP_PROTO(struct xfs_inode *dp, struct xfs_name *name, \ 5831 xfs_ino_t ino), \ 5832 TP_ARGS(dp, name, ino)) 5833 DEFINE_METADIR_EVENT(xfs_metadir_lookup); 5834 5835 /* metadata inode space reservations */ 5836 5837 DECLARE_EVENT_CLASS(xfs_metafile_resv_class, 5838 TP_PROTO(struct xfs_mount *mp, xfs_filblks_t len), 5839 TP_ARGS(mp, len), 5840 TP_STRUCT__entry( 5841 __field(dev_t, dev) 5842 __field(unsigned long long, freeblks) 5843 __field(unsigned long long, reserved) 5844 __field(unsigned long long, asked) 5845 __field(unsigned long long, used) 5846 __field(unsigned long long, len) 5847 ), 5848 TP_fast_assign( 5849 __entry->dev = mp->m_super->s_dev; 5850 __entry->freeblks = xfs_sum_freecounter_raw(mp, XC_FREE_BLOCKS); 5851 __entry->reserved = mp->m_metafile_resv_avail; 5852 __entry->asked = mp->m_metafile_resv_target; 5853 __entry->used = mp->m_metafile_resv_used; 5854 __entry->len = len; 5855 ), 5856 TP_printk("dev %d:%d freeblks %llu resv %llu ask %llu used %llu len %llu", 5857 MAJOR(__entry->dev), MINOR(__entry->dev), 5858 __entry->freeblks, 5859 __entry->reserved, 5860 __entry->asked, 5861 __entry->used, 5862 __entry->len) 5863 ) 5864 #define DEFINE_METAFILE_RESV_EVENT(name) \ 5865 DEFINE_EVENT(xfs_metafile_resv_class, name, \ 5866 TP_PROTO(struct xfs_mount *mp, xfs_filblks_t len), \ 5867 TP_ARGS(mp, len)) 5868 DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_init); 5869 DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_free); 5870 DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_alloc_space); 5871 DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_free_space); 5872 DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_critical); 5873 DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_init_error); 5874 5875 #ifdef CONFIG_XFS_RT 5876 TRACE_EVENT(xfs_growfs_check_rtgeom, 5877 TP_PROTO(const struct xfs_mount *mp, unsigned int min_logfsbs), 5878 TP_ARGS(mp, min_logfsbs), 5879 TP_STRUCT__entry( 5880 __field(dev_t, dev) 5881 __field(unsigned int, logblocks) 5882 __field(unsigned int, min_logfsbs) 5883 ), 5884 TP_fast_assign( 5885 __entry->dev = mp->m_super->s_dev; 5886 __entry->logblocks = mp->m_sb.sb_logblocks; 5887 __entry->min_logfsbs = min_logfsbs; 5888 ), 5889 TP_printk("dev %d:%d logblocks %u min_logfsbs %u", 5890 MAJOR(__entry->dev), MINOR(__entry->dev), 5891 __entry->logblocks, 5892 __entry->min_logfsbs) 5893 ); 5894 #endif /* CONFIG_XFS_RT */ 5895 5896 TRACE_DEFINE_ENUM(XC_FREE_BLOCKS); 5897 TRACE_DEFINE_ENUM(XC_FREE_RTEXTENTS); 5898 TRACE_DEFINE_ENUM(XC_FREE_RTAVAILABLE); 5899 5900 DECLARE_EVENT_CLASS(xfs_freeblocks_resv_class, 5901 TP_PROTO(struct xfs_mount *mp, enum xfs_free_counter ctr, 5902 uint64_t delta, unsigned long caller_ip), 5903 TP_ARGS(mp, ctr, delta, caller_ip), 5904 TP_STRUCT__entry( 5905 __field(dev_t, dev) 5906 __field(enum xfs_free_counter, ctr) 5907 __field(uint64_t, delta) 5908 __field(uint64_t, avail) 5909 __field(uint64_t, total) 5910 __field(unsigned long, caller_ip) 5911 ), 5912 TP_fast_assign( 5913 __entry->dev = mp->m_super->s_dev; 5914 __entry->ctr = ctr; 5915 __entry->delta = delta; 5916 __entry->avail = mp->m_free[ctr].res_avail; 5917 __entry->total = mp->m_free[ctr].res_total; 5918 __entry->caller_ip = caller_ip; 5919 ), 5920 TP_printk("dev %d:%d ctr %s delta %llu avail %llu total %llu caller %pS", 5921 MAJOR(__entry->dev), MINOR(__entry->dev), 5922 __print_symbolic(__entry->ctr, XFS_FREECOUNTER_STR), 5923 __entry->delta, 5924 __entry->avail, 5925 __entry->total, 5926 (char *)__entry->caller_ip) 5927 ) 5928 #define DEFINE_FREEBLOCKS_RESV_EVENT(name) \ 5929 DEFINE_EVENT(xfs_freeblocks_resv_class, name, \ 5930 TP_PROTO(struct xfs_mount *mp, enum xfs_free_counter ctr, \ 5931 uint64_t delta, unsigned long caller_ip), \ 5932 TP_ARGS(mp, ctr, delta, caller_ip)) 5933 DEFINE_FREEBLOCKS_RESV_EVENT(xfs_freecounter_reserved); 5934 DEFINE_FREEBLOCKS_RESV_EVENT(xfs_freecounter_enospc); 5935 5936 TRACE_EVENT(xfs_healthmon_lost_event, 5937 TP_PROTO(const struct xfs_healthmon *hm), 5938 TP_ARGS(hm), 5939 TP_STRUCT__entry( 5940 __field(dev_t, dev) 5941 __field(unsigned long long, lost_prev) 5942 ), 5943 TP_fast_assign( 5944 __entry->dev = hm->dev; 5945 __entry->lost_prev = hm->lost_prev_event; 5946 ), 5947 TP_printk("dev %d:%d lost_prev %llu", 5948 MAJOR(__entry->dev), MINOR(__entry->dev), 5949 __entry->lost_prev) 5950 ); 5951 5952 #define XFS_HEALTHMON_FLAGS_STRINGS \ 5953 { XFS_HEALTH_MONITOR_VERBOSE, "verbose" } 5954 #define XFS_HEALTHMON_FMT_STRINGS \ 5955 { XFS_HEALTH_MONITOR_FMT_V0, "v0" } 5956 5957 TRACE_EVENT(xfs_healthmon_create, 5958 TP_PROTO(dev_t dev, u64 flags, u8 format), 5959 TP_ARGS(dev, flags, format), 5960 TP_STRUCT__entry( 5961 __field(dev_t, dev) 5962 __field(u64, flags) 5963 __field(u8, format) 5964 ), 5965 TP_fast_assign( 5966 __entry->dev = dev; 5967 __entry->flags = flags; 5968 __entry->format = format; 5969 ), 5970 TP_printk("dev %d:%d flags %s format %s", 5971 MAJOR(__entry->dev), MINOR(__entry->dev), 5972 __print_flags(__entry->flags, "|", XFS_HEALTHMON_FLAGS_STRINGS), 5973 __print_symbolic(__entry->format, XFS_HEALTHMON_FMT_STRINGS)) 5974 ); 5975 5976 TRACE_EVENT(xfs_healthmon_copybuf, 5977 TP_PROTO(const struct xfs_healthmon *hm, const struct iov_iter *iov), 5978 TP_ARGS(hm, iov), 5979 TP_STRUCT__entry( 5980 __field(dev_t, dev) 5981 __field(size_t, bufsize) 5982 __field(size_t, inpos) 5983 __field(size_t, outpos) 5984 __field(size_t, to_copy) 5985 __field(size_t, iter_count) 5986 ), 5987 TP_fast_assign( 5988 __entry->dev = hm->dev; 5989 __entry->bufsize = hm->bufsize; 5990 __entry->inpos = hm->bufhead; 5991 __entry->outpos = hm->buftail; 5992 if (hm->bufhead > hm->buftail) 5993 __entry->to_copy = hm->bufhead - hm->buftail; 5994 else 5995 __entry->to_copy = 0; 5996 __entry->iter_count = iov_iter_count(iov); 5997 ), 5998 TP_printk("dev %d:%d bufsize %zu in_pos %zu out_pos %zu to_copy %zu iter_count %zu", 5999 MAJOR(__entry->dev), MINOR(__entry->dev), 6000 __entry->bufsize, 6001 __entry->inpos, 6002 __entry->outpos, 6003 __entry->to_copy, 6004 __entry->iter_count) 6005 ); 6006 6007 DECLARE_EVENT_CLASS(xfs_healthmon_class, 6008 TP_PROTO(const struct xfs_healthmon *hm), 6009 TP_ARGS(hm), 6010 TP_STRUCT__entry( 6011 __field(dev_t, dev) 6012 __field(unsigned int, events) 6013 __field(unsigned long long, lost_prev) 6014 ), 6015 TP_fast_assign( 6016 __entry->dev = hm->dev; 6017 __entry->events = hm->events; 6018 __entry->lost_prev = hm->lost_prev_event; 6019 ), 6020 TP_printk("dev %d:%d events %u lost_prev? %llu", 6021 MAJOR(__entry->dev), MINOR(__entry->dev), 6022 __entry->events, 6023 __entry->lost_prev) 6024 ); 6025 #define DEFINE_HEALTHMON_EVENT(name) \ 6026 DEFINE_EVENT(xfs_healthmon_class, name, \ 6027 TP_PROTO(const struct xfs_healthmon *hm), \ 6028 TP_ARGS(hm)) 6029 DEFINE_HEALTHMON_EVENT(xfs_healthmon_read_start); 6030 DEFINE_HEALTHMON_EVENT(xfs_healthmon_read_finish); 6031 DEFINE_HEALTHMON_EVENT(xfs_healthmon_release); 6032 DEFINE_HEALTHMON_EVENT(xfs_healthmon_detach); 6033 DEFINE_HEALTHMON_EVENT(xfs_healthmon_report_unmount); 6034 6035 #define XFS_HEALTHMON_TYPE_STRINGS \ 6036 { XFS_HEALTHMON_LOST, "lost" }, \ 6037 { XFS_HEALTHMON_UNMOUNT, "unmount" }, \ 6038 { XFS_HEALTHMON_SICK, "sick" }, \ 6039 { XFS_HEALTHMON_CORRUPT, "corrupt" }, \ 6040 { XFS_HEALTHMON_HEALTHY, "healthy" }, \ 6041 { XFS_HEALTHMON_SHUTDOWN, "shutdown" } 6042 6043 #define XFS_HEALTHMON_DOMAIN_STRINGS \ 6044 { XFS_HEALTHMON_MOUNT, "mount" }, \ 6045 { XFS_HEALTHMON_FS, "fs" }, \ 6046 { XFS_HEALTHMON_AG, "ag" }, \ 6047 { XFS_HEALTHMON_INODE, "inode" }, \ 6048 { XFS_HEALTHMON_RTGROUP, "rtgroup" } 6049 6050 TRACE_DEFINE_ENUM(XFS_HEALTHMON_LOST); 6051 TRACE_DEFINE_ENUM(XFS_HEALTHMON_SHUTDOWN); 6052 TRACE_DEFINE_ENUM(XFS_HEALTHMON_UNMOUNT); 6053 TRACE_DEFINE_ENUM(XFS_HEALTHMON_SICK); 6054 TRACE_DEFINE_ENUM(XFS_HEALTHMON_CORRUPT); 6055 TRACE_DEFINE_ENUM(XFS_HEALTHMON_HEALTHY); 6056 6057 TRACE_DEFINE_ENUM(XFS_HEALTHMON_MOUNT); 6058 TRACE_DEFINE_ENUM(XFS_HEALTHMON_FS); 6059 TRACE_DEFINE_ENUM(XFS_HEALTHMON_AG); 6060 TRACE_DEFINE_ENUM(XFS_HEALTHMON_INODE); 6061 TRACE_DEFINE_ENUM(XFS_HEALTHMON_RTGROUP); 6062 6063 DECLARE_EVENT_CLASS(xfs_healthmon_event_class, 6064 TP_PROTO(const struct xfs_healthmon *hm, 6065 const struct xfs_healthmon_event *event), 6066 TP_ARGS(hm, event), 6067 TP_STRUCT__entry( 6068 __field(dev_t, dev) 6069 __field(unsigned int, type) 6070 __field(unsigned int, domain) 6071 __field(unsigned int, mask) 6072 __field(unsigned long long, ino) 6073 __field(unsigned int, gen) 6074 __field(unsigned int, group) 6075 __field(unsigned long long, offset) 6076 __field(unsigned long long, length) 6077 __field(unsigned long long, lostcount) 6078 ), 6079 TP_fast_assign( 6080 __entry->dev = hm->dev; 6081 __entry->type = event->type; 6082 __entry->domain = event->domain; 6083 __entry->mask = 0; 6084 __entry->group = 0; 6085 __entry->ino = 0; 6086 __entry->gen = 0; 6087 __entry->offset = 0; 6088 __entry->length = 0; 6089 __entry->lostcount = 0; 6090 switch (__entry->domain) { 6091 case XFS_HEALTHMON_MOUNT: 6092 switch (__entry->type) { 6093 case XFS_HEALTHMON_SHUTDOWN: 6094 __entry->mask = event->flags; 6095 break; 6096 case XFS_HEALTHMON_LOST: 6097 __entry->lostcount = event->lostcount; 6098 break; 6099 } 6100 break; 6101 case XFS_HEALTHMON_FS: 6102 __entry->mask = event->fsmask; 6103 break; 6104 case XFS_HEALTHMON_AG: 6105 case XFS_HEALTHMON_RTGROUP: 6106 __entry->mask = event->grpmask; 6107 __entry->group = event->group; 6108 break; 6109 case XFS_HEALTHMON_INODE: 6110 __entry->mask = event->imask; 6111 __entry->ino = event->ino; 6112 __entry->gen = event->gen; 6113 break; 6114 case XFS_HEALTHMON_DATADEV: 6115 case XFS_HEALTHMON_LOGDEV: 6116 case XFS_HEALTHMON_RTDEV: 6117 __entry->offset = event->daddr; 6118 __entry->length = event->bbcount; 6119 break; 6120 case XFS_HEALTHMON_FILERANGE: 6121 __entry->ino = event->fino; 6122 __entry->gen = event->fgen; 6123 __entry->offset = event->fpos; 6124 __entry->length = event->flen; 6125 break; 6126 } 6127 ), 6128 TP_printk("dev %d:%d type %s domain %s mask 0x%x ino 0x%llx gen 0x%x offset 0x%llx len 0x%llx group 0x%x lost %llu", 6129 MAJOR(__entry->dev), MINOR(__entry->dev), 6130 __print_symbolic(__entry->type, XFS_HEALTHMON_TYPE_STRINGS), 6131 __print_symbolic(__entry->domain, XFS_HEALTHMON_DOMAIN_STRINGS), 6132 __entry->mask, 6133 __entry->ino, 6134 __entry->gen, 6135 __entry->offset, 6136 __entry->length, 6137 __entry->group, 6138 __entry->lostcount) 6139 ); 6140 #define DEFINE_HEALTHMONEVENT_EVENT(name) \ 6141 DEFINE_EVENT(xfs_healthmon_event_class, name, \ 6142 TP_PROTO(const struct xfs_healthmon *hm, \ 6143 const struct xfs_healthmon_event *event), \ 6144 TP_ARGS(hm, event)) 6145 DEFINE_HEALTHMONEVENT_EVENT(xfs_healthmon_insert); 6146 DEFINE_HEALTHMONEVENT_EVENT(xfs_healthmon_push); 6147 DEFINE_HEALTHMONEVENT_EVENT(xfs_healthmon_pop); 6148 DEFINE_HEALTHMONEVENT_EVENT(xfs_healthmon_format); 6149 DEFINE_HEALTHMONEVENT_EVENT(xfs_healthmon_format_overflow); 6150 DEFINE_HEALTHMONEVENT_EVENT(xfs_healthmon_drop); 6151 DEFINE_HEALTHMONEVENT_EVENT(xfs_healthmon_merge); 6152 6153 TRACE_EVENT(xfs_healthmon_report_fs, 6154 TP_PROTO(const struct xfs_healthmon *hm, 6155 unsigned int old_mask, unsigned int new_mask, 6156 const struct xfs_healthmon_event *event), 6157 TP_ARGS(hm, old_mask, new_mask, event), 6158 TP_STRUCT__entry( 6159 __field(dev_t, dev) 6160 __field(unsigned int, type) 6161 __field(unsigned int, domain) 6162 __field(unsigned int, old_mask) 6163 __field(unsigned int, new_mask) 6164 __field(unsigned int, fsmask) 6165 ), 6166 TP_fast_assign( 6167 __entry->dev = hm->dev; 6168 __entry->type = event->type; 6169 __entry->domain = event->domain; 6170 __entry->old_mask = old_mask; 6171 __entry->new_mask = new_mask; 6172 __entry->fsmask = event->fsmask; 6173 ), 6174 TP_printk("dev %d:%d type %s domain %s oldmask 0x%x newmask 0x%x fsmask 0x%x", 6175 MAJOR(__entry->dev), MINOR(__entry->dev), 6176 __print_symbolic(__entry->type, XFS_HEALTHMON_TYPE_STRINGS), 6177 __print_symbolic(__entry->domain, XFS_HEALTHMON_DOMAIN_STRINGS), 6178 __entry->old_mask, 6179 __entry->new_mask, 6180 __entry->fsmask) 6181 ); 6182 6183 TRACE_EVENT(xfs_healthmon_report_group, 6184 TP_PROTO(const struct xfs_healthmon *hm, 6185 unsigned int old_mask, unsigned int new_mask, 6186 const struct xfs_healthmon_event *event), 6187 TP_ARGS(hm, old_mask, new_mask, event), 6188 TP_STRUCT__entry( 6189 __field(dev_t, dev) 6190 __field(unsigned int, type) 6191 __field(unsigned int, domain) 6192 __field(unsigned int, old_mask) 6193 __field(unsigned int, new_mask) 6194 __field(unsigned int, grpmask) 6195 __field(unsigned int, group) 6196 ), 6197 TP_fast_assign( 6198 __entry->dev = hm->dev; 6199 __entry->type = event->type; 6200 __entry->domain = event->domain; 6201 __entry->old_mask = old_mask; 6202 __entry->new_mask = new_mask; 6203 __entry->grpmask = event->grpmask; 6204 __entry->group = event->group; 6205 ), 6206 TP_printk("dev %d:%d type %s domain %s oldmask 0x%x newmask 0x%x grpmask 0x%x group 0x%x", 6207 MAJOR(__entry->dev), MINOR(__entry->dev), 6208 __print_symbolic(__entry->type, XFS_HEALTHMON_TYPE_STRINGS), 6209 __print_symbolic(__entry->domain, XFS_HEALTHMON_DOMAIN_STRINGS), 6210 __entry->old_mask, 6211 __entry->new_mask, 6212 __entry->grpmask, 6213 __entry->group) 6214 ); 6215 6216 TRACE_EVENT(xfs_healthmon_report_inode, 6217 TP_PROTO(const struct xfs_healthmon *hm, 6218 unsigned int old_mask, unsigned int new_mask, 6219 const struct xfs_healthmon_event *event), 6220 TP_ARGS(hm, old_mask, new_mask, event), 6221 TP_STRUCT__entry( 6222 __field(dev_t, dev) 6223 __field(unsigned int, type) 6224 __field(unsigned int, domain) 6225 __field(unsigned int, old_mask) 6226 __field(unsigned int, new_mask) 6227 __field(unsigned int, imask) 6228 __field(unsigned long long, ino) 6229 __field(unsigned int, gen) 6230 ), 6231 TP_fast_assign( 6232 __entry->dev = hm->dev; 6233 __entry->type = event->type; 6234 __entry->domain = event->domain; 6235 __entry->old_mask = old_mask; 6236 __entry->new_mask = new_mask; 6237 __entry->imask = event->imask; 6238 __entry->ino = event->ino; 6239 __entry->gen = event->gen; 6240 ), 6241 TP_printk("dev %d:%d type %s domain %s oldmask 0x%x newmask 0x%x imask 0x%x ino 0x%llx gen 0x%x", 6242 MAJOR(__entry->dev), MINOR(__entry->dev), 6243 __print_symbolic(__entry->type, XFS_HEALTHMON_TYPE_STRINGS), 6244 __print_symbolic(__entry->domain, XFS_HEALTHMON_DOMAIN_STRINGS), 6245 __entry->old_mask, 6246 __entry->new_mask, 6247 __entry->imask, 6248 __entry->ino, 6249 __entry->gen) 6250 ); 6251 6252 TRACE_EVENT(xfs_healthmon_report_shutdown, 6253 TP_PROTO(const struct xfs_healthmon *hm, uint32_t shutdown_flags), 6254 TP_ARGS(hm, shutdown_flags), 6255 TP_STRUCT__entry( 6256 __field(dev_t, dev) 6257 __field(uint32_t, shutdown_flags) 6258 ), 6259 TP_fast_assign( 6260 __entry->dev = hm->dev; 6261 __entry->shutdown_flags = shutdown_flags; 6262 ), 6263 TP_printk("dev %d:%d shutdown_flags %s", 6264 MAJOR(__entry->dev), MINOR(__entry->dev), 6265 __print_flags(__entry->shutdown_flags, "|", XFS_SHUTDOWN_STRINGS)) 6266 ); 6267 6268 #define XFS_DEVICE_STRINGS \ 6269 { XFS_DEV_DATA, "datadev" }, \ 6270 { XFS_DEV_RT, "rtdev" }, \ 6271 { XFS_DEV_LOG, "logdev" } 6272 6273 TRACE_DEFINE_ENUM(XFS_DEV_DATA); 6274 TRACE_DEFINE_ENUM(XFS_DEV_RT); 6275 TRACE_DEFINE_ENUM(XFS_DEV_LOG); 6276 6277 TRACE_EVENT(xfs_healthmon_report_media, 6278 TP_PROTO(const struct xfs_healthmon *hm, enum xfs_device fdev, 6279 const struct xfs_healthmon_event *event), 6280 TP_ARGS(hm, fdev, event), 6281 TP_STRUCT__entry( 6282 __field(dev_t, dev) 6283 __field(unsigned int, error_dev) 6284 __field(uint64_t, daddr) 6285 __field(uint64_t, bbcount) 6286 ), 6287 TP_fast_assign( 6288 __entry->dev = hm->dev; 6289 __entry->error_dev = fdev; 6290 __entry->daddr = event->daddr; 6291 __entry->bbcount = event->bbcount; 6292 ), 6293 TP_printk("dev %d:%d %s daddr 0x%llx bbcount 0x%llx", 6294 MAJOR(__entry->dev), MINOR(__entry->dev), 6295 __print_symbolic(__entry->error_dev, XFS_DEVICE_STRINGS), 6296 __entry->daddr, 6297 __entry->bbcount) 6298 ); 6299 6300 #define FS_ERROR_STRINGS \ 6301 { FSERR_BUFFERED_READ, "buffered_read" }, \ 6302 { FSERR_BUFFERED_WRITE, "buffered_write" }, \ 6303 { FSERR_DIRECTIO_READ, "directio_read" }, \ 6304 { FSERR_DIRECTIO_WRITE, "directio_write" }, \ 6305 { FSERR_DATA_LOST, "data_lost" }, \ 6306 { FSERR_METADATA, "metadata" } 6307 6308 TRACE_DEFINE_ENUM(FSERR_BUFFERED_READ); 6309 TRACE_DEFINE_ENUM(FSERR_BUFFERED_WRITE); 6310 TRACE_DEFINE_ENUM(FSERR_DIRECTIO_READ); 6311 TRACE_DEFINE_ENUM(FSERR_DIRECTIO_WRITE); 6312 TRACE_DEFINE_ENUM(FSERR_DATA_LOST); 6313 TRACE_DEFINE_ENUM(FSERR_METADATA); 6314 6315 TRACE_EVENT(xfs_healthmon_report_file_ioerror, 6316 TP_PROTO(const struct xfs_healthmon *hm, 6317 const struct fserror_event *p), 6318 TP_ARGS(hm, p), 6319 TP_STRUCT__entry( 6320 __field(dev_t, dev) 6321 __field(unsigned int, type) 6322 __field(unsigned long long, ino) 6323 __field(unsigned int, gen) 6324 __field(long long, pos) 6325 __field(unsigned long long, len) 6326 __field(int, error) 6327 ), 6328 TP_fast_assign( 6329 __entry->dev = hm->dev; 6330 __entry->type = p->type; 6331 __entry->ino = XFS_I(p->inode)->i_ino; 6332 __entry->gen = p->inode->i_generation; 6333 __entry->pos = p->pos; 6334 __entry->len = p->len; 6335 __entry->error = p->error; 6336 ), 6337 TP_printk("dev %d:%d ino 0x%llx gen 0x%x op %s pos 0x%llx bytecount 0x%llx error %d", 6338 MAJOR(__entry->dev), MINOR(__entry->dev), 6339 __entry->ino, 6340 __entry->gen, 6341 __print_symbolic(__entry->type, FS_ERROR_STRINGS), 6342 __entry->pos, 6343 __entry->len, 6344 __entry->error) 6345 ); 6346 6347 TRACE_EVENT(xfs_verify_media, 6348 TP_PROTO(const struct xfs_mount *mp, const struct xfs_verify_media *me, 6349 dev_t fdev, xfs_daddr_t daddr, uint64_t bbcount, 6350 const struct folio *folio), 6351 TP_ARGS(mp, me, fdev, daddr, bbcount, folio), 6352 TP_STRUCT__entry( 6353 __field(dev_t, dev) 6354 __field(dev_t, fdev) 6355 __field(xfs_daddr_t, start_daddr) 6356 __field(xfs_daddr_t, end_daddr) 6357 __field(unsigned int, flags) 6358 __field(xfs_daddr_t, daddr) 6359 __field(uint64_t, bbcount) 6360 __field(unsigned int, bufsize) 6361 ), 6362 TP_fast_assign( 6363 __entry->dev = mp->m_ddev_targp->bt_dev; 6364 __entry->fdev = fdev; 6365 __entry->start_daddr = me->me_start_daddr; 6366 __entry->end_daddr = me->me_end_daddr; 6367 __entry->flags = me->me_flags; 6368 __entry->daddr = daddr; 6369 __entry->bbcount = bbcount; 6370 __entry->bufsize = folio_size(folio); 6371 ), 6372 TP_printk("dev %d:%d fdev %d:%d start_daddr 0x%llx end_daddr 0x%llx flags 0x%x daddr 0x%llx bbcount 0x%llx bufsize 0x%x", 6373 MAJOR(__entry->dev), MINOR(__entry->dev), 6374 MAJOR(__entry->fdev), MINOR(__entry->fdev), 6375 __entry->start_daddr, 6376 __entry->end_daddr, 6377 __entry->flags, 6378 __entry->daddr, 6379 __entry->bbcount, 6380 __entry->bufsize) 6381 ); 6382 6383 TRACE_EVENT(xfs_verify_media_end, 6384 TP_PROTO(const struct xfs_mount *mp, const struct xfs_verify_media *me, 6385 dev_t fdev), 6386 TP_ARGS(mp, me, fdev), 6387 TP_STRUCT__entry( 6388 __field(dev_t, dev) 6389 __field(dev_t, fdev) 6390 __field(xfs_daddr_t, start_daddr) 6391 __field(xfs_daddr_t, end_daddr) 6392 __field(int, ioerror) 6393 ), 6394 TP_fast_assign( 6395 __entry->dev = mp->m_ddev_targp->bt_dev; 6396 __entry->fdev = fdev; 6397 __entry->start_daddr = me->me_start_daddr; 6398 __entry->end_daddr = me->me_end_daddr; 6399 __entry->ioerror = me->me_ioerror; 6400 ), 6401 TP_printk("dev %d:%d fdev %d:%d start_daddr 0x%llx end_daddr 0x%llx ioerror %d", 6402 MAJOR(__entry->dev), MINOR(__entry->dev), 6403 MAJOR(__entry->fdev), MINOR(__entry->fdev), 6404 __entry->start_daddr, 6405 __entry->end_daddr, 6406 __entry->ioerror) 6407 ); 6408 6409 TRACE_EVENT(xfs_verify_media_error, 6410 TP_PROTO(const struct xfs_mount *mp, const struct xfs_verify_media *me, 6411 dev_t fdev, xfs_daddr_t daddr, uint64_t bbcount, 6412 blk_status_t status), 6413 TP_ARGS(mp, me, fdev, daddr, bbcount, status), 6414 TP_STRUCT__entry( 6415 __field(dev_t, dev) 6416 __field(dev_t, fdev) 6417 __field(xfs_daddr_t, start_daddr) 6418 __field(xfs_daddr_t, end_daddr) 6419 __field(unsigned int, flags) 6420 __field(xfs_daddr_t, daddr) 6421 __field(uint64_t, bbcount) 6422 __field(int, error) 6423 ), 6424 TP_fast_assign( 6425 __entry->dev = mp->m_ddev_targp->bt_dev; 6426 __entry->fdev = fdev; 6427 __entry->start_daddr = me->me_start_daddr; 6428 __entry->end_daddr = me->me_end_daddr; 6429 __entry->flags = me->me_flags; 6430 __entry->daddr = daddr; 6431 __entry->bbcount = bbcount; 6432 __entry->error = blk_status_to_errno(status); 6433 ), 6434 TP_printk("dev %d:%d fdev %d:%d start_daddr 0x%llx end_daddr 0x%llx flags 0x%x daddr 0x%llx bbcount 0x%llx error %d", 6435 MAJOR(__entry->dev), MINOR(__entry->dev), 6436 MAJOR(__entry->fdev), MINOR(__entry->fdev), 6437 __entry->start_daddr, 6438 __entry->end_daddr, 6439 __entry->flags, 6440 __entry->daddr, 6441 __entry->bbcount, 6442 __entry->error) 6443 ); 6444 6445 #endif /* _TRACE_XFS_H */ 6446 6447 #undef TRACE_INCLUDE_PATH 6448 #define TRACE_INCLUDE_PATH . 6449 #define TRACE_INCLUDE_FILE xfs_trace 6450 #include <trace/define_trace.h> 6451