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