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