fs/xfs/xfs_trace.h

   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>