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