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