fs/xfs/xfs_trace.h

   1 /*
   2  * Copyright (c) 2009, Christoph Hellwig
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #undef TRACE_SYSTEM
  19 #define TRACE_SYSTEM xfs
  20
  21 #if !defined(_TRACE_XFS_H) || defined(TRACE_HEADER_MULTI_READ)
  22 #define _TRACE_XFS_H
  23
  24 #include <linux/tracepoint.h>
  25
  26 struct xfs_agf;
  27 struct xfs_alloc_arg;
  28 struct xfs_attr_list_context;
  29 struct xfs_buf_log_item;
  30 struct xfs_da_args;
  31 struct xfs_da_node_entry;
  32 struct xfs_dquot;
  33 struct xfs_log_item;
  34 struct xlog;
  35 struct xlog_ticket;
  36 struct xlog_recover;
  37 struct xlog_recover_item;
  38 struct xfs_buf_log_format;
  39 struct xfs_inode_log_format;
  40 struct xfs_bmbt_irec;
  41 struct xfs_btree_cur;
  42 struct xfs_refcount_irec;
  43
  44 DECLARE_EVENT_CLASS(xfs_attr_list_class,
  45         TP_PROTO(struct xfs_attr_list_context *ctx),
  46         TP_ARGS(ctx),
  47         TP_STRUCT__entry(
  48                 __field(dev_t, dev)
  49                 __field(xfs_ino_t, ino)
  50                 __field(u32, hashval)
  51                 __field(u32, blkno)
  52                 __field(u32, offset)
  53                 __field(void *, alist)
  54                 __field(int, bufsize)
  55                 __field(int, count)
  56                 __field(int, firstu)
  57                 __field(int, dupcnt)
  58                 __field(int, flags)
  59         ),
  60         TP_fast_assign(
  61                 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
  62                 __entry->ino = ctx->dp->i_ino;
  63                 __entry->hashval = ctx->cursor->hashval;
  64                 __entry->blkno = ctx->cursor->blkno;
  65                 __entry->offset = ctx->cursor->offset;
  66                 __entry->alist = ctx->alist;
  67                 __entry->bufsize = ctx->bufsize;
  68                 __entry->count = ctx->count;
  69                 __entry->firstu = ctx->firstu;
  70                 __entry->flags = ctx->flags;
  71         ),
  72         TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
  73                   "alist 0x%p size %u count %u firstu %u flags %d %s",
  74                   MAJOR(__entry->dev), MINOR(__entry->dev),
  75                    __entry->ino,
  76                    __entry->hashval,
  77                    __entry->blkno,
  78                    __entry->offset,
  79                    __entry->dupcnt,
  80                    __entry->alist,
  81                    __entry->bufsize,
  82                    __entry->count,
  83                    __entry->firstu,
  84                    __entry->flags,
  85                    __print_flags(__entry->flags, "|", XFS_ATTR_FLAGS)
  86         )
  87 )
  88
  89 #define DEFINE_ATTR_LIST_EVENT(name) \
  90 DEFINE_EVENT(xfs_attr_list_class, name, \
  91         TP_PROTO(struct xfs_attr_list_context *ctx), \
  92         TP_ARGS(ctx))
  93 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf);
  94 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all);
  95 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf);
  96 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf_end);
  97 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_full);
  98 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_add);
  99 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_wrong_blk);
 100 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_notfound);
 101 DEFINE_ATTR_LIST_EVENT(xfs_attr_leaf_list);
 102 DEFINE_ATTR_LIST_EVENT(xfs_attr_node_list);
 103
 104 DECLARE_EVENT_CLASS(xfs_perag_class,
 105         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int refcount,
 106                  unsigned long caller_ip),
 107         TP_ARGS(mp, agno, refcount, caller_ip),
 108         TP_STRUCT__entry(
 109                 __field(dev_t, dev)
 110                 __field(xfs_agnumber_t, agno)
 111                 __field(int, refcount)
 112                 __field(unsigned long, caller_ip)
 113         ),
 114         TP_fast_assign(
 115                 __entry->dev = mp->m_super->s_dev;
 116                 __entry->agno = agno;
 117                 __entry->refcount = refcount;
 118                 __entry->caller_ip = caller_ip;
 119         ),
 120         TP_printk("dev %d:%d agno %u refcount %d caller %ps",
 121                   MAJOR(__entry->dev), MINOR(__entry->dev),
 122                   __entry->agno,
 123                   __entry->refcount,
 124                   (char *)__entry->caller_ip)
 125 );
 126
 127 #define DEFINE_PERAG_REF_EVENT(name)    \
 128 DEFINE_EVENT(xfs_perag_class, name,     \
 129         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int refcount,       \
 130                  unsigned long caller_ip),                                      \
 131         TP_ARGS(mp, agno, refcount, caller_ip))
 132 DEFINE_PERAG_REF_EVENT(xfs_perag_get);
 133 DEFINE_PERAG_REF_EVENT(xfs_perag_get_tag);
 134 DEFINE_PERAG_REF_EVENT(xfs_perag_put);
 135 DEFINE_PERAG_REF_EVENT(xfs_perag_set_reclaim);
 136 DEFINE_PERAG_REF_EVENT(xfs_perag_clear_reclaim);
 137 DEFINE_PERAG_REF_EVENT(xfs_perag_set_eofblocks);
 138 DEFINE_PERAG_REF_EVENT(xfs_perag_clear_eofblocks);
 139 DEFINE_PERAG_REF_EVENT(xfs_perag_set_cowblocks);
 140 DEFINE_PERAG_REF_EVENT(xfs_perag_clear_cowblocks);
 141
 142 DECLARE_EVENT_CLASS(xfs_ag_class,
 143         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno),
 144         TP_ARGS(mp, agno),
 145         TP_STRUCT__entry(
 146                 __field(dev_t, dev)
 147                 __field(xfs_agnumber_t, agno)
 148         ),
 149         TP_fast_assign(
 150                 __entry->dev = mp->m_super->s_dev;
 151                 __entry->agno = agno;
 152         ),
 153         TP_printk("dev %d:%d agno %u",
 154                   MAJOR(__entry->dev), MINOR(__entry->dev),
 155                   __entry->agno)
 156 );
 157 #define DEFINE_AG_EVENT(name)   \
 158 DEFINE_EVENT(xfs_ag_class, name,        \
 159         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno),    \
 160         TP_ARGS(mp, agno))
 161
 162 DEFINE_AG_EVENT(xfs_read_agf);
 163 DEFINE_AG_EVENT(xfs_alloc_read_agf);
 164 DEFINE_AG_EVENT(xfs_read_agi);
 165 DEFINE_AG_EVENT(xfs_ialloc_read_agi);
 166
 167 TRACE_EVENT(xfs_attr_list_node_descend,
 168         TP_PROTO(struct xfs_attr_list_context *ctx,
 169                  struct xfs_da_node_entry *btree),
 170         TP_ARGS(ctx, btree),
 171         TP_STRUCT__entry(
 172                 __field(dev_t, dev)
 173                 __field(xfs_ino_t, ino)
 174                 __field(u32, hashval)
 175                 __field(u32, blkno)
 176                 __field(u32, offset)
 177                 __field(void *, alist)
 178                 __field(int, bufsize)
 179                 __field(int, count)
 180                 __field(int, firstu)
 181                 __field(int, dupcnt)
 182                 __field(int, flags)
 183                 __field(u32, bt_hashval)
 184                 __field(u32, bt_before)
 185         ),
 186         TP_fast_assign(
 187                 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
 188                 __entry->ino = ctx->dp->i_ino;
 189                 __entry->hashval = ctx->cursor->hashval;
 190                 __entry->blkno = ctx->cursor->blkno;
 191                 __entry->offset = ctx->cursor->offset;
 192                 __entry->alist = ctx->alist;
 193                 __entry->bufsize = ctx->bufsize;
 194                 __entry->count = ctx->count;
 195                 __entry->firstu = ctx->firstu;
 196                 __entry->flags = ctx->flags;
 197                 __entry->bt_hashval = be32_to_cpu(btree->hashval);
 198                 __entry->bt_before = be32_to_cpu(btree->before);
 199         ),
 200         TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
 201                   "alist 0x%p size %u count %u firstu %u flags %d %s "
 202                   "node hashval %u, node before %u",
 203                   MAJOR(__entry->dev), MINOR(__entry->dev),
 204                    __entry->ino,
 205                    __entry->hashval,
 206                    __entry->blkno,
 207                    __entry->offset,
 208                    __entry->dupcnt,
 209                    __entry->alist,
 210                    __entry->bufsize,
 211                    __entry->count,
 212                    __entry->firstu,
 213                    __entry->flags,
 214                    __print_flags(__entry->flags, "|", XFS_ATTR_FLAGS),
 215                    __entry->bt_hashval,
 216                    __entry->bt_before)
 217 );
 218
 219 TRACE_EVENT(xfs_iext_insert,
 220         TP_PROTO(struct xfs_inode *ip, xfs_extnum_t idx,
 221                  struct xfs_bmbt_irec *r, int state, unsigned long caller_ip),
 222         TP_ARGS(ip, idx, r, state, caller_ip),
 223         TP_STRUCT__entry(
 224                 __field(dev_t, dev)
 225                 __field(xfs_ino_t, ino)
 226                 __field(xfs_extnum_t, idx)
 227                 __field(xfs_fileoff_t, startoff)
 228                 __field(xfs_fsblock_t, startblock)
 229                 __field(xfs_filblks_t, blockcount)
 230                 __field(xfs_exntst_t, state)
 231                 __field(int, bmap_state)
 232                 __field(unsigned long, caller_ip)
 233         ),
 234         TP_fast_assign(
 235                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 236                 __entry->ino = ip->i_ino;
 237                 __entry->idx = idx;
 238                 __entry->startoff = r->br_startoff;
 239                 __entry->startblock = r->br_startblock;
 240                 __entry->blockcount = r->br_blockcount;
 241                 __entry->state = r->br_state;
 242                 __entry->bmap_state = state;
 243                 __entry->caller_ip = caller_ip;
 244         ),
 245         TP_printk("dev %d:%d ino 0x%llx state %s idx %ld "
 246                   "offset %lld block %lld count %lld flag %d caller %ps",
 247                   MAJOR(__entry->dev), MINOR(__entry->dev),
 248                   __entry->ino,
 249                   __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS),
 250                   (long)__entry->idx,
 251                   __entry->startoff,
 252                   (__int64_t)__entry->startblock,
 253                   __entry->blockcount,
 254                   __entry->state,
 255                   (char *)__entry->caller_ip)
 256 );
 257
 258 DECLARE_EVENT_CLASS(xfs_bmap_class,
 259         TP_PROTO(struct xfs_inode *ip, xfs_extnum_t idx, int state,
 260                  unsigned long caller_ip),
 261         TP_ARGS(ip, idx, state, caller_ip),
 262         TP_STRUCT__entry(
 263                 __field(dev_t, dev)
 264                 __field(xfs_ino_t, ino)
 265                 __field(xfs_extnum_t, idx)
 266                 __field(xfs_fileoff_t, startoff)
 267                 __field(xfs_fsblock_t, startblock)
 268                 __field(xfs_filblks_t, blockcount)
 269                 __field(xfs_exntst_t, state)
 270                 __field(int, bmap_state)
 271                 __field(unsigned long, caller_ip)
 272         ),
 273         TP_fast_assign(
 274                 struct xfs_ifork        *ifp;
 275                 struct xfs_bmbt_irec    r;
 276
 277                 ifp = xfs_iext_state_to_fork(ip, state);
 278                 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, idx), &r);
 279                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 280                 __entry->ino = ip->i_ino;
 281                 __entry->idx = idx;
 282                 __entry->startoff = r.br_startoff;
 283                 __entry->startblock = r.br_startblock;
 284                 __entry->blockcount = r.br_blockcount;
 285                 __entry->state = r.br_state;
 286                 __entry->bmap_state = state;
 287                 __entry->caller_ip = caller_ip;
 288         ),
 289         TP_printk("dev %d:%d ino 0x%llx state %s idx %ld "
 290                   "offset %lld block %lld count %lld flag %d caller %ps",
 291                   MAJOR(__entry->dev), MINOR(__entry->dev),
 292                   __entry->ino,
 293                   __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS),
 294                   (long)__entry->idx,
 295                   __entry->startoff,
 296                   (__int64_t)__entry->startblock,
 297                   __entry->blockcount,
 298                   __entry->state,
 299                   (char *)__entry->caller_ip)
 300 )
 301
 302 #define DEFINE_BMAP_EVENT(name) \
 303 DEFINE_EVENT(xfs_bmap_class, name, \
 304         TP_PROTO(struct xfs_inode *ip, xfs_extnum_t idx, int state, \
 305                  unsigned long caller_ip), \
 306         TP_ARGS(ip, idx, state, caller_ip))
 307 DEFINE_BMAP_EVENT(xfs_iext_remove);
 308 DEFINE_BMAP_EVENT(xfs_bmap_pre_update);
 309 DEFINE_BMAP_EVENT(xfs_bmap_post_update);
 310 DEFINE_BMAP_EVENT(xfs_extlist);
 311
 312 DECLARE_EVENT_CLASS(xfs_buf_class,
 313         TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip),
 314         TP_ARGS(bp, caller_ip),
 315         TP_STRUCT__entry(
 316                 __field(dev_t, dev)
 317                 __field(xfs_daddr_t, bno)
 318                 __field(int, nblks)
 319                 __field(int, hold)
 320                 __field(int, pincount)
 321                 __field(unsigned, lockval)
 322                 __field(unsigned, flags)
 323                 __field(unsigned long, caller_ip)
 324         ),
 325         TP_fast_assign(
 326                 __entry->dev = bp->b_target->bt_dev;
 327                 __entry->bno = bp->b_bn;
 328                 __entry->nblks = bp->b_length;
 329                 __entry->hold = atomic_read(&bp->b_hold);
 330                 __entry->pincount = atomic_read(&bp->b_pin_count);
 331                 __entry->lockval = bp->b_sema.count;
 332                 __entry->flags = bp->b_flags;
 333                 __entry->caller_ip = caller_ip;
 334         ),
 335         TP_printk("dev %d:%d bno 0x%llx nblks 0x%x hold %d pincount %d "
 336                   "lock %d flags %s caller %ps",
 337                   MAJOR(__entry->dev), MINOR(__entry->dev),
 338                   (unsigned long long)__entry->bno,
 339                   __entry->nblks,
 340                   __entry->hold,
 341                   __entry->pincount,
 342                   __entry->lockval,
 343                   __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
 344                   (void *)__entry->caller_ip)
 345 )
 346
 347 #define DEFINE_BUF_EVENT(name) \
 348 DEFINE_EVENT(xfs_buf_class, name, \
 349         TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \
 350         TP_ARGS(bp, caller_ip))
 351 DEFINE_BUF_EVENT(xfs_buf_init);
 352 DEFINE_BUF_EVENT(xfs_buf_free);
 353 DEFINE_BUF_EVENT(xfs_buf_hold);
 354 DEFINE_BUF_EVENT(xfs_buf_rele);
 355 DEFINE_BUF_EVENT(xfs_buf_iodone);
 356 DEFINE_BUF_EVENT(xfs_buf_submit);
 357 DEFINE_BUF_EVENT(xfs_buf_submit_wait);
 358 DEFINE_BUF_EVENT(xfs_buf_bawrite);
 359 DEFINE_BUF_EVENT(xfs_buf_lock);
 360 DEFINE_BUF_EVENT(xfs_buf_lock_done);
 361 DEFINE_BUF_EVENT(xfs_buf_trylock_fail);
 362 DEFINE_BUF_EVENT(xfs_buf_trylock);
 363 DEFINE_BUF_EVENT(xfs_buf_unlock);
 364 DEFINE_BUF_EVENT(xfs_buf_iowait);
 365 DEFINE_BUF_EVENT(xfs_buf_iowait_done);
 366 DEFINE_BUF_EVENT(xfs_buf_delwri_queue);
 367 DEFINE_BUF_EVENT(xfs_buf_delwri_queued);
 368 DEFINE_BUF_EVENT(xfs_buf_delwri_split);
 369 DEFINE_BUF_EVENT(xfs_buf_get_uncached);
 370 DEFINE_BUF_EVENT(xfs_bdstrat_shut);
 371 DEFINE_BUF_EVENT(xfs_buf_item_relse);
 372 DEFINE_BUF_EVENT(xfs_buf_item_iodone_async);
 373 DEFINE_BUF_EVENT(xfs_buf_error_relse);
 374 DEFINE_BUF_EVENT(xfs_buf_wait_buftarg);
 375 DEFINE_BUF_EVENT(xfs_trans_read_buf_io);
 376 DEFINE_BUF_EVENT(xfs_trans_read_buf_shut);
 377
 378 /* not really buffer traces, but the buf provides useful information */
 379 DEFINE_BUF_EVENT(xfs_btree_corrupt);
 380 DEFINE_BUF_EVENT(xfs_da_btree_corrupt);
 381 DEFINE_BUF_EVENT(xfs_reset_dqcounts);
 382 DEFINE_BUF_EVENT(xfs_inode_item_push);
 383
 384 /* pass flags explicitly */
 385 DECLARE_EVENT_CLASS(xfs_buf_flags_class,
 386         TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip),
 387         TP_ARGS(bp, flags, caller_ip),
 388         TP_STRUCT__entry(
 389                 __field(dev_t, dev)
 390                 __field(xfs_daddr_t, bno)
 391                 __field(size_t, buffer_length)
 392                 __field(int, hold)
 393                 __field(int, pincount)
 394                 __field(unsigned, lockval)
 395                 __field(unsigned, flags)
 396                 __field(unsigned long, caller_ip)
 397         ),
 398         TP_fast_assign(
 399                 __entry->dev = bp->b_target->bt_dev;
 400                 __entry->bno = bp->b_bn;
 401                 __entry->buffer_length = BBTOB(bp->b_length);
 402                 __entry->flags = flags;
 403                 __entry->hold = atomic_read(&bp->b_hold);
 404                 __entry->pincount = atomic_read(&bp->b_pin_count);
 405                 __entry->lockval = bp->b_sema.count;
 406                 __entry->caller_ip = caller_ip;
 407         ),
 408         TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
 409                   "lock %d flags %s caller %ps",
 410                   MAJOR(__entry->dev), MINOR(__entry->dev),
 411                   (unsigned long long)__entry->bno,
 412                   __entry->buffer_length,
 413                   __entry->hold,
 414                   __entry->pincount,
 415                   __entry->lockval,
 416                   __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
 417                   (void *)__entry->caller_ip)
 418 )
 419
 420 #define DEFINE_BUF_FLAGS_EVENT(name) \
 421 DEFINE_EVENT(xfs_buf_flags_class, name, \
 422         TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \
 423         TP_ARGS(bp, flags, caller_ip))
 424 DEFINE_BUF_FLAGS_EVENT(xfs_buf_find);
 425 DEFINE_BUF_FLAGS_EVENT(xfs_buf_get);
 426 DEFINE_BUF_FLAGS_EVENT(xfs_buf_read);
 427
 428 TRACE_EVENT(xfs_buf_ioerror,
 429         TP_PROTO(struct xfs_buf *bp, int error, unsigned long caller_ip),
 430         TP_ARGS(bp, error, caller_ip),
 431         TP_STRUCT__entry(
 432                 __field(dev_t, dev)
 433                 __field(xfs_daddr_t, bno)
 434                 __field(size_t, buffer_length)
 435                 __field(unsigned, flags)
 436                 __field(int, hold)
 437                 __field(int, pincount)
 438                 __field(unsigned, lockval)
 439                 __field(int, error)
 440                 __field(unsigned long, caller_ip)
 441         ),
 442         TP_fast_assign(
 443                 __entry->dev = bp->b_target->bt_dev;
 444                 __entry->bno = bp->b_bn;
 445                 __entry->buffer_length = BBTOB(bp->b_length);
 446                 __entry->hold = atomic_read(&bp->b_hold);
 447                 __entry->pincount = atomic_read(&bp->b_pin_count);
 448                 __entry->lockval = bp->b_sema.count;
 449                 __entry->error = error;
 450                 __entry->flags = bp->b_flags;
 451                 __entry->caller_ip = caller_ip;
 452         ),
 453         TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
 454                   "lock %d error %d flags %s caller %ps",
 455                   MAJOR(__entry->dev), MINOR(__entry->dev),
 456                   (unsigned long long)__entry->bno,
 457                   __entry->buffer_length,
 458                   __entry->hold,
 459                   __entry->pincount,
 460                   __entry->lockval,
 461                   __entry->error,
 462                   __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
 463                   (void *)__entry->caller_ip)
 464 );
 465
 466 DECLARE_EVENT_CLASS(xfs_buf_item_class,
 467         TP_PROTO(struct xfs_buf_log_item *bip),
 468         TP_ARGS(bip),
 469         TP_STRUCT__entry(
 470                 __field(dev_t, dev)
 471                 __field(xfs_daddr_t, buf_bno)
 472                 __field(size_t, buf_len)
 473                 __field(int, buf_hold)
 474                 __field(int, buf_pincount)
 475                 __field(int, buf_lockval)
 476                 __field(unsigned, buf_flags)
 477                 __field(unsigned, bli_recur)
 478                 __field(int, bli_refcount)
 479                 __field(unsigned, bli_flags)
 480                 __field(void *, li_desc)
 481                 __field(unsigned, li_flags)
 482         ),
 483         TP_fast_assign(
 484                 __entry->dev = bip->bli_buf->b_target->bt_dev;
 485                 __entry->bli_flags = bip->bli_flags;
 486                 __entry->bli_recur = bip->bli_recur;
 487                 __entry->bli_refcount = atomic_read(&bip->bli_refcount);
 488                 __entry->buf_bno = bip->bli_buf->b_bn;
 489                 __entry->buf_len = BBTOB(bip->bli_buf->b_length);
 490                 __entry->buf_flags = bip->bli_buf->b_flags;
 491                 __entry->buf_hold = atomic_read(&bip->bli_buf->b_hold);
 492                 __entry->buf_pincount = atomic_read(&bip->bli_buf->b_pin_count);
 493                 __entry->buf_lockval = bip->bli_buf->b_sema.count;
 494                 __entry->li_desc = bip->bli_item.li_desc;
 495                 __entry->li_flags = bip->bli_item.li_flags;
 496         ),
 497         TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
 498                   "lock %d flags %s recur %d refcount %d bliflags %s "
 499                   "lidesc 0x%p liflags %s",
 500                   MAJOR(__entry->dev), MINOR(__entry->dev),
 501                   (unsigned long long)__entry->buf_bno,
 502                   __entry->buf_len,
 503                   __entry->buf_hold,
 504                   __entry->buf_pincount,
 505                   __entry->buf_lockval,
 506                   __print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS),
 507                   __entry->bli_recur,
 508                   __entry->bli_refcount,
 509                   __print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS),
 510                   __entry->li_desc,
 511                   __print_flags(__entry->li_flags, "|", XFS_LI_FLAGS))
 512 )
 513
 514 #define DEFINE_BUF_ITEM_EVENT(name) \
 515 DEFINE_EVENT(xfs_buf_item_class, name, \
 516         TP_PROTO(struct xfs_buf_log_item *bip), \
 517         TP_ARGS(bip))
 518 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size);
 519 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_ordered);
 520 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale);
 521 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format);
 522 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_ordered);
 523 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_stale);
 524 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_ordered);
 525 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_pin);
 526 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin);
 527 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin_stale);
 528 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unlock);
 529 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unlock_stale);
 530 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_committed);
 531 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_push);
 532 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf);
 533 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf_recur);
 534 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb);
 535 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb_recur);
 536 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf);
 537 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf_recur);
 538 DEFINE_BUF_ITEM_EVENT(xfs_trans_log_buf);
 539 DEFINE_BUF_ITEM_EVENT(xfs_trans_brelse);
 540 DEFINE_BUF_ITEM_EVENT(xfs_trans_bjoin);
 541 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold);
 542 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release);
 543 DEFINE_BUF_ITEM_EVENT(xfs_trans_binval);
 544 DEFINE_BUF_ITEM_EVENT(xfs_trans_buf_ordered);
 545
 546 DECLARE_EVENT_CLASS(xfs_filestream_class,
 547         TP_PROTO(struct xfs_inode *ip, xfs_agnumber_t agno),
 548         TP_ARGS(ip, agno),
 549         TP_STRUCT__entry(
 550                 __field(dev_t, dev)
 551                 __field(xfs_ino_t, ino)
 552                 __field(xfs_agnumber_t, agno)
 553                 __field(int, streams)
 554         ),
 555         TP_fast_assign(
 556                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 557                 __entry->ino = ip->i_ino;
 558                 __entry->agno = agno;
 559                 __entry->streams = xfs_filestream_peek_ag(ip->i_mount, agno);
 560         ),
 561         TP_printk("dev %d:%d ino 0x%llx agno %u streams %d",
 562                   MAJOR(__entry->dev), MINOR(__entry->dev),
 563                   __entry->ino,
 564                   __entry->agno,
 565                   __entry->streams)
 566 )
 567 #define DEFINE_FILESTREAM_EVENT(name) \
 568 DEFINE_EVENT(xfs_filestream_class, name, \
 569         TP_PROTO(struct xfs_inode *ip, xfs_agnumber_t agno), \
 570         TP_ARGS(ip, agno))
 571 DEFINE_FILESTREAM_EVENT(xfs_filestream_free);
 572 DEFINE_FILESTREAM_EVENT(xfs_filestream_lookup);
 573 DEFINE_FILESTREAM_EVENT(xfs_filestream_scan);
 574
 575 TRACE_EVENT(xfs_filestream_pick,
 576         TP_PROTO(struct xfs_inode *ip, xfs_agnumber_t agno,
 577                  xfs_extlen_t free, int nscan),
 578         TP_ARGS(ip, agno, free, nscan),
 579         TP_STRUCT__entry(
 580                 __field(dev_t, dev)
 581                 __field(xfs_ino_t, ino)
 582                 __field(xfs_agnumber_t, agno)
 583                 __field(int, streams)
 584                 __field(xfs_extlen_t, free)
 585                 __field(int, nscan)
 586         ),
 587         TP_fast_assign(
 588                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 589                 __entry->ino = ip->i_ino;
 590                 __entry->agno = agno;
 591                 __entry->streams = xfs_filestream_peek_ag(ip->i_mount, agno);
 592                 __entry->free = free;
 593                 __entry->nscan = nscan;
 594         ),
 595         TP_printk("dev %d:%d ino 0x%llx agno %u streams %d free %d nscan %d",
 596                   MAJOR(__entry->dev), MINOR(__entry->dev),
 597                   __entry->ino,
 598                   __entry->agno,
 599                   __entry->streams,
 600                   __entry->free,
 601                   __entry->nscan)
 602 );
 603
 604 DECLARE_EVENT_CLASS(xfs_lock_class,
 605         TP_PROTO(struct xfs_inode *ip, unsigned lock_flags,
 606                  unsigned long caller_ip),
 607         TP_ARGS(ip,  lock_flags, caller_ip),
 608         TP_STRUCT__entry(
 609                 __field(dev_t, dev)
 610                 __field(xfs_ino_t, ino)
 611                 __field(int, lock_flags)
 612                 __field(unsigned long, caller_ip)
 613         ),
 614         TP_fast_assign(
 615                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 616                 __entry->ino = ip->i_ino;
 617                 __entry->lock_flags = lock_flags;
 618                 __entry->caller_ip = caller_ip;
 619         ),
 620         TP_printk("dev %d:%d ino 0x%llx flags %s caller %ps",
 621                   MAJOR(__entry->dev), MINOR(__entry->dev),
 622                   __entry->ino,
 623                   __print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS),
 624                   (void *)__entry->caller_ip)
 625 )
 626
 627 #define DEFINE_LOCK_EVENT(name) \
 628 DEFINE_EVENT(xfs_lock_class, name, \
 629         TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \
 630                  unsigned long caller_ip), \
 631         TP_ARGS(ip,  lock_flags, caller_ip))
 632 DEFINE_LOCK_EVENT(xfs_ilock);
 633 DEFINE_LOCK_EVENT(xfs_ilock_nowait);
 634 DEFINE_LOCK_EVENT(xfs_ilock_demote);
 635 DEFINE_LOCK_EVENT(xfs_iunlock);
 636
 637 DECLARE_EVENT_CLASS(xfs_inode_class,
 638         TP_PROTO(struct xfs_inode *ip),
 639         TP_ARGS(ip),
 640         TP_STRUCT__entry(
 641                 __field(dev_t, dev)
 642                 __field(xfs_ino_t, ino)
 643         ),
 644         TP_fast_assign(
 645                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 646                 __entry->ino = ip->i_ino;
 647         ),
 648         TP_printk("dev %d:%d ino 0x%llx",
 649                   MAJOR(__entry->dev), MINOR(__entry->dev),
 650                   __entry->ino)
 651 )
 652
 653 #define DEFINE_INODE_EVENT(name) \
 654 DEFINE_EVENT(xfs_inode_class, name, \
 655         TP_PROTO(struct xfs_inode *ip), \
 656         TP_ARGS(ip))
 657 DEFINE_INODE_EVENT(xfs_iget_skip);
 658 DEFINE_INODE_EVENT(xfs_iget_reclaim);
 659 DEFINE_INODE_EVENT(xfs_iget_reclaim_fail);
 660 DEFINE_INODE_EVENT(xfs_iget_hit);
 661 DEFINE_INODE_EVENT(xfs_iget_miss);
 662
 663 DEFINE_INODE_EVENT(xfs_getattr);
 664 DEFINE_INODE_EVENT(xfs_setattr);
 665 DEFINE_INODE_EVENT(xfs_readlink);
 666 DEFINE_INODE_EVENT(xfs_inactive_symlink);
 667 DEFINE_INODE_EVENT(xfs_alloc_file_space);
 668 DEFINE_INODE_EVENT(xfs_free_file_space);
 669 DEFINE_INODE_EVENT(xfs_zero_file_space);
 670 DEFINE_INODE_EVENT(xfs_collapse_file_space);
 671 DEFINE_INODE_EVENT(xfs_insert_file_space);
 672 DEFINE_INODE_EVENT(xfs_readdir);
 673 #ifdef CONFIG_XFS_POSIX_ACL
 674 DEFINE_INODE_EVENT(xfs_get_acl);
 675 #endif
 676 DEFINE_INODE_EVENT(xfs_vm_bmap);
 677 DEFINE_INODE_EVENT(xfs_file_ioctl);
 678 DEFINE_INODE_EVENT(xfs_file_compat_ioctl);
 679 DEFINE_INODE_EVENT(xfs_ioctl_setattr);
 680 DEFINE_INODE_EVENT(xfs_dir_fsync);
 681 DEFINE_INODE_EVENT(xfs_file_fsync);
 682 DEFINE_INODE_EVENT(xfs_destroy_inode);
 683 DEFINE_INODE_EVENT(xfs_evict_inode);
 684 DEFINE_INODE_EVENT(xfs_update_time);
 685
 686 DEFINE_INODE_EVENT(xfs_dquot_dqalloc);
 687 DEFINE_INODE_EVENT(xfs_dquot_dqdetach);
 688
 689 DEFINE_INODE_EVENT(xfs_inode_set_eofblocks_tag);
 690 DEFINE_INODE_EVENT(xfs_inode_clear_eofblocks_tag);
 691 DEFINE_INODE_EVENT(xfs_inode_free_eofblocks_invalid);
 692 DEFINE_INODE_EVENT(xfs_inode_set_cowblocks_tag);
 693 DEFINE_INODE_EVENT(xfs_inode_clear_cowblocks_tag);
 694 DEFINE_INODE_EVENT(xfs_inode_free_cowblocks_invalid);
 695
 696 DEFINE_INODE_EVENT(xfs_filemap_fault);
 697 DEFINE_INODE_EVENT(xfs_filemap_pmd_fault);
 698 DEFINE_INODE_EVENT(xfs_filemap_page_mkwrite);
 699 DEFINE_INODE_EVENT(xfs_filemap_pfn_mkwrite);
 700
 701 DECLARE_EVENT_CLASS(xfs_iref_class,
 702         TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip),
 703         TP_ARGS(ip, caller_ip),
 704         TP_STRUCT__entry(
 705                 __field(dev_t, dev)
 706                 __field(xfs_ino_t, ino)
 707                 __field(int, count)
 708                 __field(int, pincount)
 709                 __field(unsigned long, caller_ip)
 710         ),
 711         TP_fast_assign(
 712                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 713                 __entry->ino = ip->i_ino;
 714                 __entry->count = atomic_read(&VFS_I(ip)->i_count);
 715                 __entry->pincount = atomic_read(&ip->i_pincount);
 716                 __entry->caller_ip = caller_ip;
 717         ),
 718         TP_printk("dev %d:%d ino 0x%llx count %d pincount %d caller %ps",
 719                   MAJOR(__entry->dev), MINOR(__entry->dev),
 720                   __entry->ino,
 721                   __entry->count,
 722                   __entry->pincount,
 723                   (char *)__entry->caller_ip)
 724 )
 725
 726 TRACE_EVENT(xfs_iomap_prealloc_size,
 727         TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t blocks, int shift,
 728                  unsigned int writeio_blocks),
 729         TP_ARGS(ip, blocks, shift, writeio_blocks),
 730         TP_STRUCT__entry(
 731                 __field(dev_t, dev)
 732                 __field(xfs_ino_t, ino)
 733                 __field(xfs_fsblock_t, blocks)
 734                 __field(int, shift)
 735                 __field(unsigned int, writeio_blocks)
 736         ),
 737         TP_fast_assign(
 738                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 739                 __entry->ino = ip->i_ino;
 740                 __entry->blocks = blocks;
 741                 __entry->shift = shift;
 742                 __entry->writeio_blocks = writeio_blocks;
 743         ),
 744         TP_printk("dev %d:%d ino 0x%llx prealloc blocks %llu shift %d "
 745                   "m_writeio_blocks %u",
 746                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino,
 747                   __entry->blocks, __entry->shift, __entry->writeio_blocks)
 748 )
 749
 750 TRACE_EVENT(xfs_irec_merge_pre,
 751         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agino_t agino,
 752                  uint16_t holemask, xfs_agino_t nagino, uint16_t nholemask),
 753         TP_ARGS(mp, agno, agino, holemask, nagino, nholemask),
 754         TP_STRUCT__entry(
 755                 __field(dev_t, dev)
 756                 __field(xfs_agnumber_t, agno)
 757                 __field(xfs_agino_t, agino)
 758                 __field(uint16_t, holemask)
 759                 __field(xfs_agino_t, nagino)
 760                 __field(uint16_t, nholemask)
 761         ),
 762         TP_fast_assign(
 763                 __entry->dev = mp->m_super->s_dev;
 764                 __entry->agno = agno;
 765                 __entry->agino = agino;
 766                 __entry->holemask = holemask;
 767                 __entry->nagino = nagino;
 768                 __entry->nholemask = holemask;
 769         ),
 770         TP_printk("dev %d:%d agno %d inobt (%u:0x%x) new (%u:0x%x)",
 771                   MAJOR(__entry->dev), MINOR(__entry->dev), __entry->agno,
 772                   __entry->agino, __entry->holemask, __entry->nagino,
 773                   __entry->nholemask)
 774 )
 775
 776 TRACE_EVENT(xfs_irec_merge_post,
 777         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agino_t agino,
 778                  uint16_t holemask),
 779         TP_ARGS(mp, agno, agino, holemask),
 780         TP_STRUCT__entry(
 781                 __field(dev_t, dev)
 782                 __field(xfs_agnumber_t, agno)
 783                 __field(xfs_agino_t, agino)
 784                 __field(uint16_t, holemask)
 785         ),
 786         TP_fast_assign(
 787                 __entry->dev = mp->m_super->s_dev;
 788                 __entry->agno = agno;
 789                 __entry->agino = agino;
 790                 __entry->holemask = holemask;
 791         ),
 792         TP_printk("dev %d:%d agno %d inobt (%u:0x%x)", MAJOR(__entry->dev),
 793                   MINOR(__entry->dev), __entry->agno, __entry->agino,
 794                   __entry->holemask)
 795 )
 796
 797 #define DEFINE_IREF_EVENT(name) \
 798 DEFINE_EVENT(xfs_iref_class, name, \
 799         TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \
 800         TP_ARGS(ip, caller_ip))
 801 DEFINE_IREF_EVENT(xfs_ihold);
 802 DEFINE_IREF_EVENT(xfs_irele);
 803 DEFINE_IREF_EVENT(xfs_inode_pin);
 804 DEFINE_IREF_EVENT(xfs_inode_unpin);
 805 DEFINE_IREF_EVENT(xfs_inode_unpin_nowait);
 806
 807 DECLARE_EVENT_CLASS(xfs_namespace_class,
 808         TP_PROTO(struct xfs_inode *dp, struct xfs_name *name),
 809         TP_ARGS(dp, name),
 810         TP_STRUCT__entry(
 811                 __field(dev_t, dev)
 812                 __field(xfs_ino_t, dp_ino)
 813                 __field(int, namelen)
 814                 __dynamic_array(char, name, name->len)
 815         ),
 816         TP_fast_assign(
 817                 __entry->dev = VFS_I(dp)->i_sb->s_dev;
 818                 __entry->dp_ino = dp->i_ino;
 819                 __entry->namelen = name->len;
 820                 memcpy(__get_str(name), name->name, name->len);
 821         ),
 822         TP_printk("dev %d:%d dp ino 0x%llx name %.*s",
 823                   MAJOR(__entry->dev), MINOR(__entry->dev),
 824                   __entry->dp_ino,
 825                   __entry->namelen,
 826                   __get_str(name))
 827 )
 828
 829 #define DEFINE_NAMESPACE_EVENT(name) \
 830 DEFINE_EVENT(xfs_namespace_class, name, \
 831         TP_PROTO(struct xfs_inode *dp, struct xfs_name *name), \
 832         TP_ARGS(dp, name))
 833 DEFINE_NAMESPACE_EVENT(xfs_remove);
 834 DEFINE_NAMESPACE_EVENT(xfs_link);
 835 DEFINE_NAMESPACE_EVENT(xfs_lookup);
 836 DEFINE_NAMESPACE_EVENT(xfs_create);
 837 DEFINE_NAMESPACE_EVENT(xfs_symlink);
 838
 839 TRACE_EVENT(xfs_rename,
 840         TP_PROTO(struct xfs_inode *src_dp, struct xfs_inode *target_dp,
 841                  struct xfs_name *src_name, struct xfs_name *target_name),
 842         TP_ARGS(src_dp, target_dp, src_name, target_name),
 843         TP_STRUCT__entry(
 844                 __field(dev_t, dev)
 845                 __field(xfs_ino_t, src_dp_ino)
 846                 __field(xfs_ino_t, target_dp_ino)
 847                 __field(int, src_namelen)
 848                 __field(int, target_namelen)
 849                 __dynamic_array(char, src_name, src_name->len)
 850                 __dynamic_array(char, target_name, target_name->len)
 851         ),
 852         TP_fast_assign(
 853                 __entry->dev = VFS_I(src_dp)->i_sb->s_dev;
 854                 __entry->src_dp_ino = src_dp->i_ino;
 855                 __entry->target_dp_ino = target_dp->i_ino;
 856                 __entry->src_namelen = src_name->len;
 857                 __entry->target_namelen = target_name->len;
 858                 memcpy(__get_str(src_name), src_name->name, src_name->len);
 859                 memcpy(__get_str(target_name), target_name->name,
 860                         target_name->len);
 861         ),
 862         TP_printk("dev %d:%d src dp ino 0x%llx target dp ino 0x%llx"
 863                   " src name %.*s target name %.*s",
 864                   MAJOR(__entry->dev), MINOR(__entry->dev),
 865                   __entry->src_dp_ino,
 866                   __entry->target_dp_ino,
 867                   __entry->src_namelen,
 868                   __get_str(src_name),
 869                   __entry->target_namelen,
 870                   __get_str(target_name))
 871 )
 872
 873 DECLARE_EVENT_CLASS(xfs_dquot_class,
 874         TP_PROTO(struct xfs_dquot *dqp),
 875         TP_ARGS(dqp),
 876         TP_STRUCT__entry(
 877                 __field(dev_t, dev)
 878                 __field(u32, id)
 879                 __field(unsigned, flags)
 880                 __field(unsigned, nrefs)
 881                 __field(unsigned long long, res_bcount)
 882                 __field(unsigned long long, bcount)
 883                 __field(unsigned long long, icount)
 884                 __field(unsigned long long, blk_hardlimit)
 885                 __field(unsigned long long, blk_softlimit)
 886                 __field(unsigned long long, ino_hardlimit)
 887                 __field(unsigned long long, ino_softlimit)
 888         ), \
 889         TP_fast_assign(
 890                 __entry->dev = dqp->q_mount->m_super->s_dev;
 891                 __entry->id = be32_to_cpu(dqp->q_core.d_id);
 892                 __entry->flags = dqp->dq_flags;
 893                 __entry->nrefs = dqp->q_nrefs;
 894                 __entry->res_bcount = dqp->q_res_bcount;
 895                 __entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
 896                 __entry->icount = be64_to_cpu(dqp->q_core.d_icount);
 897                 __entry->blk_hardlimit =
 898                         be64_to_cpu(dqp->q_core.d_blk_hardlimit);
 899                 __entry->blk_softlimit =
 900                         be64_to_cpu(dqp->q_core.d_blk_softlimit);
 901                 __entry->ino_hardlimit =
 902                         be64_to_cpu(dqp->q_core.d_ino_hardlimit);
 903                 __entry->ino_softlimit =
 904                         be64_to_cpu(dqp->q_core.d_ino_softlimit);
 905         ),
 906         TP_printk("dev %d:%d id 0x%x flags %s nrefs %u res_bc 0x%llx "
 907                   "bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx "
 908                   "icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]",
 909                   MAJOR(__entry->dev), MINOR(__entry->dev),
 910                   __entry->id,
 911                   __print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
 912                   __entry->nrefs,
 913                   __entry->res_bcount,
 914                   __entry->bcount,
 915                   __entry->blk_hardlimit,
 916                   __entry->blk_softlimit,
 917                   __entry->icount,
 918                   __entry->ino_hardlimit,
 919                   __entry->ino_softlimit)
 920 )
 921
 922 #define DEFINE_DQUOT_EVENT(name) \
 923 DEFINE_EVENT(xfs_dquot_class, name, \
 924         TP_PROTO(struct xfs_dquot *dqp), \
 925         TP_ARGS(dqp))
 926 DEFINE_DQUOT_EVENT(xfs_dqadjust);
 927 DEFINE_DQUOT_EVENT(xfs_dqreclaim_want);
 928 DEFINE_DQUOT_EVENT(xfs_dqreclaim_dirty);
 929 DEFINE_DQUOT_EVENT(xfs_dqreclaim_busy);
 930 DEFINE_DQUOT_EVENT(xfs_dqreclaim_done);
 931 DEFINE_DQUOT_EVENT(xfs_dqattach_found);
 932 DEFINE_DQUOT_EVENT(xfs_dqattach_get);
 933 DEFINE_DQUOT_EVENT(xfs_dqalloc);
 934 DEFINE_DQUOT_EVENT(xfs_dqtobp_read);
 935 DEFINE_DQUOT_EVENT(xfs_dqread);
 936 DEFINE_DQUOT_EVENT(xfs_dqread_fail);
 937 DEFINE_DQUOT_EVENT(xfs_dqget_hit);
 938 DEFINE_DQUOT_EVENT(xfs_dqget_miss);
 939 DEFINE_DQUOT_EVENT(xfs_dqget_freeing);
 940 DEFINE_DQUOT_EVENT(xfs_dqget_dup);
 941 DEFINE_DQUOT_EVENT(xfs_dqput);
 942 DEFINE_DQUOT_EVENT(xfs_dqput_wait);
 943 DEFINE_DQUOT_EVENT(xfs_dqput_free);
 944 DEFINE_DQUOT_EVENT(xfs_dqrele);
 945 DEFINE_DQUOT_EVENT(xfs_dqflush);
 946 DEFINE_DQUOT_EVENT(xfs_dqflush_force);
 947 DEFINE_DQUOT_EVENT(xfs_dqflush_done);
 948
 949 DECLARE_EVENT_CLASS(xfs_loggrant_class,
 950         TP_PROTO(struct xlog *log, struct xlog_ticket *tic),
 951         TP_ARGS(log, tic),
 952         TP_STRUCT__entry(
 953                 __field(dev_t, dev)
 954                 __field(char, ocnt)
 955                 __field(char, cnt)
 956                 __field(int, curr_res)
 957                 __field(int, unit_res)
 958                 __field(unsigned int, flags)
 959                 __field(int, reserveq)
 960                 __field(int, writeq)
 961                 __field(int, grant_reserve_cycle)
 962                 __field(int, grant_reserve_bytes)
 963                 __field(int, grant_write_cycle)
 964                 __field(int, grant_write_bytes)
 965                 __field(int, curr_cycle)
 966                 __field(int, curr_block)
 967                 __field(xfs_lsn_t, tail_lsn)
 968         ),
 969         TP_fast_assign(
 970                 __entry->dev = log->l_mp->m_super->s_dev;
 971                 __entry->ocnt = tic->t_ocnt;
 972                 __entry->cnt = tic->t_cnt;
 973                 __entry->curr_res = tic->t_curr_res;
 974                 __entry->unit_res = tic->t_unit_res;
 975                 __entry->flags = tic->t_flags;
 976                 __entry->reserveq = list_empty(&log->l_reserve_head.waiters);
 977                 __entry->writeq = list_empty(&log->l_write_head.waiters);
 978                 xlog_crack_grant_head(&log->l_reserve_head.grant,
 979                                 &__entry->grant_reserve_cycle,
 980                                 &__entry->grant_reserve_bytes);
 981                 xlog_crack_grant_head(&log->l_write_head.grant,
 982                                 &__entry->grant_write_cycle,
 983                                 &__entry->grant_write_bytes);
 984                 __entry->curr_cycle = log->l_curr_cycle;
 985                 __entry->curr_block = log->l_curr_block;
 986                 __entry->tail_lsn = atomic64_read(&log->l_tail_lsn);
 987         ),
 988         TP_printk("dev %d:%d t_ocnt %u t_cnt %u t_curr_res %u "
 989                   "t_unit_res %u t_flags %s reserveq %s "
 990                   "writeq %s grant_reserve_cycle %d "
 991                   "grant_reserve_bytes %d grant_write_cycle %d "
 992                   "grant_write_bytes %d curr_cycle %d curr_block %d "
 993                   "tail_cycle %d tail_block %d",
 994                   MAJOR(__entry->dev), MINOR(__entry->dev),
 995                   __entry->ocnt,
 996                   __entry->cnt,
 997                   __entry->curr_res,
 998                   __entry->unit_res,
 999                   __print_flags(__entry->flags, "|", XLOG_TIC_FLAGS),
1000                   __entry->reserveq ? "empty" : "active",
1001                   __entry->writeq ? "empty" : "active",
1002                   __entry->grant_reserve_cycle,
1003                   __entry->grant_reserve_bytes,
1004                   __entry->grant_write_cycle,
1005                   __entry->grant_write_bytes,
1006                   __entry->curr_cycle,
1007                   __entry->curr_block,
1008                   CYCLE_LSN(__entry->tail_lsn),
1009                   BLOCK_LSN(__entry->tail_lsn)
1010         )
1011 )
1012
1013 #define DEFINE_LOGGRANT_EVENT(name) \
1014 DEFINE_EVENT(xfs_loggrant_class, name, \
1015         TP_PROTO(struct xlog *log, struct xlog_ticket *tic), \
1016         TP_ARGS(log, tic))
1017 DEFINE_LOGGRANT_EVENT(xfs_log_done_nonperm);
1018 DEFINE_LOGGRANT_EVENT(xfs_log_done_perm);
1019 DEFINE_LOGGRANT_EVENT(xfs_log_umount_write);
1020 DEFINE_LOGGRANT_EVENT(xfs_log_grant_sleep);
1021 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake);
1022 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake_up);
1023 DEFINE_LOGGRANT_EVENT(xfs_log_reserve);
1024 DEFINE_LOGGRANT_EVENT(xfs_log_reserve_exit);
1025 DEFINE_LOGGRANT_EVENT(xfs_log_regrant);
1026 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_exit);
1027 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_reserve_enter);
1028 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_reserve_exit);
1029 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_reserve_sub);
1030 DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_enter);
1031 DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_exit);
1032 DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_sub);
1033
1034 DECLARE_EVENT_CLASS(xfs_log_item_class,
1035         TP_PROTO(struct xfs_log_item *lip),
1036         TP_ARGS(lip),
1037         TP_STRUCT__entry(
1038                 __field(dev_t, dev)
1039                 __field(void *, lip)
1040                 __field(uint, type)
1041                 __field(uint, flags)
1042                 __field(xfs_lsn_t, lsn)
1043         ),
1044         TP_fast_assign(
1045                 __entry->dev = lip->li_mountp->m_super->s_dev;
1046                 __entry->lip = lip;
1047                 __entry->type = lip->li_type;
1048                 __entry->flags = lip->li_flags;
1049                 __entry->lsn = lip->li_lsn;
1050         ),
1051         TP_printk("dev %d:%d lip 0x%p lsn %d/%d type %s flags %s",
1052                   MAJOR(__entry->dev), MINOR(__entry->dev),
1053                   __entry->lip,
1054                   CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn),
1055                   __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
1056                   __print_flags(__entry->flags, "|", XFS_LI_FLAGS))
1057 )
1058
1059 TRACE_EVENT(xfs_log_force,
1060         TP_PROTO(struct xfs_mount *mp, xfs_lsn_t lsn, unsigned long caller_ip),
1061         TP_ARGS(mp, lsn, caller_ip),
1062         TP_STRUCT__entry(
1063                 __field(dev_t, dev)
1064                 __field(xfs_lsn_t, lsn)
1065                 __field(unsigned long, caller_ip)
1066         ),
1067         TP_fast_assign(
1068                 __entry->dev = mp->m_super->s_dev;
1069                 __entry->lsn = lsn;
1070                 __entry->caller_ip = caller_ip;
1071         ),
1072         TP_printk("dev %d:%d lsn 0x%llx caller %ps",
1073                   MAJOR(__entry->dev), MINOR(__entry->dev),
1074                   __entry->lsn, (void *)__entry->caller_ip)
1075 )
1076
1077 #define DEFINE_LOG_ITEM_EVENT(name) \
1078 DEFINE_EVENT(xfs_log_item_class, name, \
1079         TP_PROTO(struct xfs_log_item *lip), \
1080         TP_ARGS(lip))
1081 DEFINE_LOG_ITEM_EVENT(xfs_ail_push);
1082 DEFINE_LOG_ITEM_EVENT(xfs_ail_pinned);
1083 DEFINE_LOG_ITEM_EVENT(xfs_ail_locked);
1084 DEFINE_LOG_ITEM_EVENT(xfs_ail_flushing);
1085
1086 DECLARE_EVENT_CLASS(xfs_ail_class,
1087         TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn),
1088         TP_ARGS(lip, old_lsn, new_lsn),
1089         TP_STRUCT__entry(
1090                 __field(dev_t, dev)
1091                 __field(void *, lip)
1092                 __field(uint, type)
1093                 __field(uint, flags)
1094                 __field(xfs_lsn_t, old_lsn)
1095                 __field(xfs_lsn_t, new_lsn)
1096         ),
1097         TP_fast_assign(
1098                 __entry->dev = lip->li_mountp->m_super->s_dev;
1099                 __entry->lip = lip;
1100                 __entry->type = lip->li_type;
1101                 __entry->flags = lip->li_flags;
1102                 __entry->old_lsn = old_lsn;
1103                 __entry->new_lsn = new_lsn;
1104         ),
1105         TP_printk("dev %d:%d lip 0x%p old lsn %d/%d new lsn %d/%d type %s flags %s",
1106                   MAJOR(__entry->dev), MINOR(__entry->dev),
1107                   __entry->lip,
1108                   CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn),
1109                   CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn),
1110                   __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
1111                   __print_flags(__entry->flags, "|", XFS_LI_FLAGS))
1112 )
1113
1114 #define DEFINE_AIL_EVENT(name) \
1115 DEFINE_EVENT(xfs_ail_class, name, \
1116         TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), \
1117         TP_ARGS(lip, old_lsn, new_lsn))
1118 DEFINE_AIL_EVENT(xfs_ail_insert);
1119 DEFINE_AIL_EVENT(xfs_ail_move);
1120 DEFINE_AIL_EVENT(xfs_ail_delete);
1121
1122 TRACE_EVENT(xfs_log_assign_tail_lsn,
1123         TP_PROTO(struct xlog *log, xfs_lsn_t new_lsn),
1124         TP_ARGS(log, new_lsn),
1125         TP_STRUCT__entry(
1126                 __field(dev_t, dev)
1127                 __field(xfs_lsn_t, new_lsn)
1128                 __field(xfs_lsn_t, old_lsn)
1129                 __field(xfs_lsn_t, last_sync_lsn)
1130         ),
1131         TP_fast_assign(
1132                 __entry->dev = log->l_mp->m_super->s_dev;
1133                 __entry->new_lsn = new_lsn;
1134                 __entry->old_lsn = atomic64_read(&log->l_tail_lsn);
1135                 __entry->last_sync_lsn = atomic64_read(&log->l_last_sync_lsn);
1136         ),
1137         TP_printk("dev %d:%d new tail lsn %d/%d, old lsn %d/%d, last sync %d/%d",
1138                   MAJOR(__entry->dev), MINOR(__entry->dev),
1139                   CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn),
1140                   CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn),
1141                   CYCLE_LSN(__entry->last_sync_lsn), BLOCK_LSN(__entry->last_sync_lsn))
1142 )
1143
1144 DECLARE_EVENT_CLASS(xfs_file_class,
1145         TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset),
1146         TP_ARGS(ip, count, offset),
1147         TP_STRUCT__entry(
1148                 __field(dev_t, dev)
1149                 __field(xfs_ino_t, ino)
1150                 __field(xfs_fsize_t, size)
1151                 __field(loff_t, offset)
1152                 __field(size_t, count)
1153         ),
1154         TP_fast_assign(
1155                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1156                 __entry->ino = ip->i_ino;
1157                 __entry->size = ip->i_d.di_size;
1158                 __entry->offset = offset;
1159                 __entry->count = count;
1160         ),
1161         TP_printk("dev %d:%d ino 0x%llx size 0x%llx offset 0x%llx count 0x%zx",
1162                   MAJOR(__entry->dev), MINOR(__entry->dev),
1163                   __entry->ino,
1164                   __entry->size,
1165                   __entry->offset,
1166                   __entry->count)
1167 )
1168
1169 #define DEFINE_RW_EVENT(name)           \
1170 DEFINE_EVENT(xfs_file_class, name,      \
1171         TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset),    \
1172         TP_ARGS(ip, count, offset))
1173 DEFINE_RW_EVENT(xfs_file_buffered_read);
1174 DEFINE_RW_EVENT(xfs_file_direct_read);
1175 DEFINE_RW_EVENT(xfs_file_dax_read);
1176 DEFINE_RW_EVENT(xfs_file_buffered_write);
1177 DEFINE_RW_EVENT(xfs_file_direct_write);
1178 DEFINE_RW_EVENT(xfs_file_dax_write);
1179 DEFINE_RW_EVENT(xfs_file_splice_read);
1180
1181 DECLARE_EVENT_CLASS(xfs_page_class,
1182         TP_PROTO(struct inode *inode, struct page *page, unsigned long off,
1183                  unsigned int len),
1184         TP_ARGS(inode, page, off, len),
1185         TP_STRUCT__entry(
1186                 __field(dev_t, dev)
1187                 __field(xfs_ino_t, ino)
1188                 __field(pgoff_t, pgoff)
1189                 __field(loff_t, size)
1190                 __field(unsigned long, offset)
1191                 __field(unsigned int, length)
1192                 __field(int, delalloc)
1193                 __field(int, unwritten)
1194         ),
1195         TP_fast_assign(
1196                 int delalloc = -1, unwritten = -1;
1197
1198                 if (page_has_buffers(page))
1199                         xfs_count_page_state(page, &delalloc, &unwritten);
1200                 __entry->dev = inode->i_sb->s_dev;
1201                 __entry->ino = XFS_I(inode)->i_ino;
1202                 __entry->pgoff = page_offset(page);
1203                 __entry->size = i_size_read(inode);
1204                 __entry->offset = off;
1205                 __entry->length = len;
1206                 __entry->delalloc = delalloc;
1207                 __entry->unwritten = unwritten;
1208         ),
1209         TP_printk("dev %d:%d ino 0x%llx pgoff 0x%lx size 0x%llx offset %lx "
1210                   "length %x delalloc %d unwritten %d",
1211                   MAJOR(__entry->dev), MINOR(__entry->dev),
1212                   __entry->ino,
1213                   __entry->pgoff,
1214                   __entry->size,
1215                   __entry->offset,
1216                   __entry->length,
1217                   __entry->delalloc,
1218                   __entry->unwritten)
1219 )
1220
1221 #define DEFINE_PAGE_EVENT(name)         \
1222 DEFINE_EVENT(xfs_page_class, name,      \
1223         TP_PROTO(struct inode *inode, struct page *page, unsigned long off, \
1224                  unsigned int len),     \
1225         TP_ARGS(inode, page, off, len))
1226 DEFINE_PAGE_EVENT(xfs_writepage);
1227 DEFINE_PAGE_EVENT(xfs_releasepage);
1228 DEFINE_PAGE_EVENT(xfs_invalidatepage);
1229
1230 DECLARE_EVENT_CLASS(xfs_readpage_class,
1231         TP_PROTO(struct inode *inode, int nr_pages),
1232         TP_ARGS(inode, nr_pages),
1233         TP_STRUCT__entry(
1234                 __field(dev_t, dev)
1235                 __field(xfs_ino_t, ino)
1236                 __field(int, nr_pages)
1237         ),
1238         TP_fast_assign(
1239                 __entry->dev = inode->i_sb->s_dev;
1240                 __entry->ino = inode->i_ino;
1241                 __entry->nr_pages = nr_pages;
1242         ),
1243         TP_printk("dev %d:%d ino 0x%llx nr_pages %d",
1244                   MAJOR(__entry->dev), MINOR(__entry->dev),
1245                   __entry->ino,
1246                   __entry->nr_pages)
1247 )
1248
1249 #define DEFINE_READPAGE_EVENT(name)             \
1250 DEFINE_EVENT(xfs_readpage_class, name,  \
1251         TP_PROTO(struct inode *inode, int nr_pages), \
1252         TP_ARGS(inode, nr_pages))
1253 DEFINE_READPAGE_EVENT(xfs_vm_readpage);
1254 DEFINE_READPAGE_EVENT(xfs_vm_readpages);
1255
1256 DECLARE_EVENT_CLASS(xfs_imap_class,
1257         TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count,
1258                  int type, struct xfs_bmbt_irec *irec),
1259         TP_ARGS(ip, offset, count, type, irec),
1260         TP_STRUCT__entry(
1261                 __field(dev_t, dev)
1262                 __field(xfs_ino_t, ino)
1263                 __field(loff_t, size)
1264                 __field(loff_t, offset)
1265                 __field(size_t, count)
1266                 __field(int, type)
1267                 __field(xfs_fileoff_t, startoff)
1268                 __field(xfs_fsblock_t, startblock)
1269                 __field(xfs_filblks_t, blockcount)
1270         ),
1271         TP_fast_assign(
1272                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1273                 __entry->ino = ip->i_ino;
1274                 __entry->size = ip->i_d.di_size;
1275                 __entry->offset = offset;
1276                 __entry->count = count;
1277                 __entry->type = type;
1278                 __entry->startoff = irec ? irec->br_startoff : 0;
1279                 __entry->startblock = irec ? irec->br_startblock : 0;
1280                 __entry->blockcount = irec ? irec->br_blockcount : 0;
1281         ),
1282         TP_printk("dev %d:%d ino 0x%llx size 0x%llx offset 0x%llx count %zd "
1283                   "type %s startoff 0x%llx startblock %lld blockcount 0x%llx",
1284                   MAJOR(__entry->dev), MINOR(__entry->dev),
1285                   __entry->ino,
1286                   __entry->size,
1287                   __entry->offset,
1288                   __entry->count,
1289                   __print_symbolic(__entry->type, XFS_IO_TYPES),
1290                   __entry->startoff,
1291                   (__int64_t)__entry->startblock,
1292                   __entry->blockcount)
1293 )
1294
1295 #define DEFINE_IOMAP_EVENT(name)        \
1296 DEFINE_EVENT(xfs_imap_class, name,      \
1297         TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, \
1298                  int type, struct xfs_bmbt_irec *irec),         \
1299         TP_ARGS(ip, offset, count, type, irec))
1300 DEFINE_IOMAP_EVENT(xfs_map_blocks_found);
1301 DEFINE_IOMAP_EVENT(xfs_map_blocks_alloc);
1302 DEFINE_IOMAP_EVENT(xfs_get_blocks_found);
1303 DEFINE_IOMAP_EVENT(xfs_get_blocks_alloc);
1304 DEFINE_IOMAP_EVENT(xfs_get_blocks_map_direct);
1305 DEFINE_IOMAP_EVENT(xfs_iomap_alloc);
1306 DEFINE_IOMAP_EVENT(xfs_iomap_found);
1307
1308 DECLARE_EVENT_CLASS(xfs_simple_io_class,
1309         TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count),
1310         TP_ARGS(ip, offset, count),
1311         TP_STRUCT__entry(
1312                 __field(dev_t, dev)
1313                 __field(xfs_ino_t, ino)
1314                 __field(loff_t, isize)
1315                 __field(loff_t, disize)
1316                 __field(loff_t, offset)
1317                 __field(size_t, count)
1318         ),
1319         TP_fast_assign(
1320                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1321                 __entry->ino = ip->i_ino;
1322                 __entry->isize = VFS_I(ip)->i_size;
1323                 __entry->disize = ip->i_d.di_size;
1324                 __entry->offset = offset;
1325                 __entry->count = count;
1326         ),
1327         TP_printk("dev %d:%d ino 0x%llx isize 0x%llx disize 0x%llx "
1328                   "offset 0x%llx count %zd",
1329                   MAJOR(__entry->dev), MINOR(__entry->dev),
1330                   __entry->ino,
1331                   __entry->isize,
1332                   __entry->disize,
1333                   __entry->offset,
1334                   __entry->count)
1335 );
1336
1337 #define DEFINE_SIMPLE_IO_EVENT(name)    \
1338 DEFINE_EVENT(xfs_simple_io_class, name, \
1339         TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count),        \
1340         TP_ARGS(ip, offset, count))
1341 DEFINE_SIMPLE_IO_EVENT(xfs_delalloc_enospc);
1342 DEFINE_SIMPLE_IO_EVENT(xfs_unwritten_convert);
1343 DEFINE_SIMPLE_IO_EVENT(xfs_get_blocks_notfound);
1344 DEFINE_SIMPLE_IO_EVENT(xfs_setfilesize);
1345 DEFINE_SIMPLE_IO_EVENT(xfs_zero_eof);
1346 DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write);
1347 DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write_unwritten);
1348 DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write_append);
1349
1350 DECLARE_EVENT_CLASS(xfs_itrunc_class,
1351         TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size),
1352         TP_ARGS(ip, new_size),
1353         TP_STRUCT__entry(
1354                 __field(dev_t, dev)
1355                 __field(xfs_ino_t, ino)
1356                 __field(xfs_fsize_t, size)
1357                 __field(xfs_fsize_t, new_size)
1358         ),
1359         TP_fast_assign(
1360                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1361                 __entry->ino = ip->i_ino;
1362                 __entry->size = ip->i_d.di_size;
1363                 __entry->new_size = new_size;
1364         ),
1365         TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx",
1366                   MAJOR(__entry->dev), MINOR(__entry->dev),
1367                   __entry->ino,
1368                   __entry->size,
1369                   __entry->new_size)
1370 )
1371
1372 #define DEFINE_ITRUNC_EVENT(name) \
1373 DEFINE_EVENT(xfs_itrunc_class, name, \
1374         TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \
1375         TP_ARGS(ip, new_size))
1376 DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_start);
1377 DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_end);
1378
1379 TRACE_EVENT(xfs_pagecache_inval,
1380         TP_PROTO(struct xfs_inode *ip, xfs_off_t start, xfs_off_t finish),
1381         TP_ARGS(ip, start, finish),
1382         TP_STRUCT__entry(
1383                 __field(dev_t, dev)
1384                 __field(xfs_ino_t, ino)
1385                 __field(xfs_fsize_t, size)
1386                 __field(xfs_off_t, start)
1387                 __field(xfs_off_t, finish)
1388         ),
1389         TP_fast_assign(
1390                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1391                 __entry->ino = ip->i_ino;
1392                 __entry->size = ip->i_d.di_size;
1393                 __entry->start = start;
1394                 __entry->finish = finish;
1395         ),
1396         TP_printk("dev %d:%d ino 0x%llx size 0x%llx start 0x%llx finish 0x%llx",
1397                   MAJOR(__entry->dev), MINOR(__entry->dev),
1398                   __entry->ino,
1399                   __entry->size,
1400                   __entry->start,
1401                   __entry->finish)
1402 );
1403
1404 TRACE_EVENT(xfs_bunmap,
1405         TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t bno, xfs_filblks_t len,
1406                  int flags, unsigned long caller_ip),
1407         TP_ARGS(ip, bno, len, flags, caller_ip),
1408         TP_STRUCT__entry(
1409                 __field(dev_t, dev)
1410                 __field(xfs_ino_t, ino)
1411                 __field(xfs_fsize_t, size)
1412                 __field(xfs_fileoff_t, bno)
1413                 __field(xfs_filblks_t, len)
1414                 __field(unsigned long, caller_ip)
1415                 __field(int, flags)
1416         ),
1417         TP_fast_assign(
1418                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1419                 __entry->ino = ip->i_ino;
1420                 __entry->size = ip->i_d.di_size;
1421                 __entry->bno = bno;
1422                 __entry->len = len;
1423                 __entry->caller_ip = caller_ip;
1424                 __entry->flags = flags;
1425         ),
1426         TP_printk("dev %d:%d ino 0x%llx size 0x%llx bno 0x%llx len 0x%llx"
1427                   "flags %s caller %ps",
1428                   MAJOR(__entry->dev), MINOR(__entry->dev),
1429                   __entry->ino,
1430                   __entry->size,
1431                   __entry->bno,
1432                   __entry->len,
1433                   __print_flags(__entry->flags, "|", XFS_BMAPI_FLAGS),
1434                   (void *)__entry->caller_ip)
1435
1436 );
1437
1438 DECLARE_EVENT_CLASS(xfs_extent_busy_class,
1439         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1440                  xfs_agblock_t agbno, xfs_extlen_t len),
1441         TP_ARGS(mp, agno, agbno, len),
1442         TP_STRUCT__entry(
1443                 __field(dev_t, dev)
1444                 __field(xfs_agnumber_t, agno)
1445                 __field(xfs_agblock_t, agbno)
1446                 __field(xfs_extlen_t, len)
1447         ),
1448         TP_fast_assign(
1449                 __entry->dev = mp->m_super->s_dev;
1450                 __entry->agno = agno;
1451                 __entry->agbno = agbno;
1452                 __entry->len = len;
1453         ),
1454         TP_printk("dev %d:%d agno %u agbno %u len %u",
1455                   MAJOR(__entry->dev), MINOR(__entry->dev),
1456                   __entry->agno,
1457                   __entry->agbno,
1458                   __entry->len)
1459 );
1460 #define DEFINE_BUSY_EVENT(name) \
1461 DEFINE_EVENT(xfs_extent_busy_class, name, \
1462         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
1463                  xfs_agblock_t agbno, xfs_extlen_t len), \
1464         TP_ARGS(mp, agno, agbno, len))
1465 DEFINE_BUSY_EVENT(xfs_extent_busy);
1466 DEFINE_BUSY_EVENT(xfs_extent_busy_enomem);
1467 DEFINE_BUSY_EVENT(xfs_extent_busy_force);
1468 DEFINE_BUSY_EVENT(xfs_extent_busy_reuse);
1469 DEFINE_BUSY_EVENT(xfs_extent_busy_clear);
1470
1471 TRACE_EVENT(xfs_extent_busy_trim,
1472         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1473                  xfs_agblock_t agbno, xfs_extlen_t len,
1474                  xfs_agblock_t tbno, xfs_extlen_t tlen),
1475         TP_ARGS(mp, agno, agbno, len, tbno, tlen),
1476         TP_STRUCT__entry(
1477                 __field(dev_t, dev)
1478                 __field(xfs_agnumber_t, agno)
1479                 __field(xfs_agblock_t, agbno)
1480                 __field(xfs_extlen_t, len)
1481                 __field(xfs_agblock_t, tbno)
1482                 __field(xfs_extlen_t, tlen)
1483         ),
1484         TP_fast_assign(
1485                 __entry->dev = mp->m_super->s_dev;
1486                 __entry->agno = agno;
1487                 __entry->agbno = agbno;
1488                 __entry->len = len;
1489                 __entry->tbno = tbno;
1490                 __entry->tlen = tlen;
1491         ),
1492         TP_printk("dev %d:%d agno %u agbno %u len %u tbno %u tlen %u",
1493                   MAJOR(__entry->dev), MINOR(__entry->dev),
1494                   __entry->agno,
1495                   __entry->agbno,
1496                   __entry->len,
1497                   __entry->tbno,
1498                   __entry->tlen)
1499 );
1500
1501 TRACE_EVENT(xfs_trans_commit_lsn,
1502         TP_PROTO(struct xfs_trans *trans),
1503         TP_ARGS(trans),
1504         TP_STRUCT__entry(
1505                 __field(dev_t, dev)
1506                 __field(struct xfs_trans *, tp)
1507                 __field(xfs_lsn_t, lsn)
1508         ),
1509         TP_fast_assign(
1510                 __entry->dev = trans->t_mountp->m_super->s_dev;
1511                 __entry->tp = trans;
1512                 __entry->lsn = trans->t_commit_lsn;
1513         ),
1514         TP_printk("dev %d:%d trans 0x%p commit_lsn 0x%llx",
1515                   MAJOR(__entry->dev), MINOR(__entry->dev),
1516                   __entry->tp,
1517                   __entry->lsn)
1518 );
1519
1520 TRACE_EVENT(xfs_agf,
1521         TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags,
1522                  unsigned long caller_ip),
1523         TP_ARGS(mp, agf, flags, caller_ip),
1524         TP_STRUCT__entry(
1525                 __field(dev_t, dev)
1526                 __field(xfs_agnumber_t, agno)
1527                 __field(int, flags)
1528                 __field(__u32, length)
1529                 __field(__u32, bno_root)
1530                 __field(__u32, cnt_root)
1531                 __field(__u32, bno_level)
1532                 __field(__u32, cnt_level)
1533                 __field(__u32, flfirst)
1534                 __field(__u32, fllast)
1535                 __field(__u32, flcount)
1536                 __field(__u32, freeblks)
1537                 __field(__u32, longest)
1538                 __field(unsigned long, caller_ip)
1539         ),
1540         TP_fast_assign(
1541                 __entry->dev = mp->m_super->s_dev;
1542                 __entry->agno = be32_to_cpu(agf->agf_seqno),
1543                 __entry->flags = flags;
1544                 __entry->length = be32_to_cpu(agf->agf_length),
1545                 __entry->bno_root = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]),
1546                 __entry->cnt_root = be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]),
1547                 __entry->bno_level =
1548                                 be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]),
1549                 __entry->cnt_level =
1550                                 be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]),
1551                 __entry->flfirst = be32_to_cpu(agf->agf_flfirst),
1552                 __entry->fllast = be32_to_cpu(agf->agf_fllast),
1553                 __entry->flcount = be32_to_cpu(agf->agf_flcount),
1554                 __entry->freeblks = be32_to_cpu(agf->agf_freeblks),
1555                 __entry->longest = be32_to_cpu(agf->agf_longest);
1556                 __entry->caller_ip = caller_ip;
1557         ),
1558         TP_printk("dev %d:%d agno %u flags %s length %u roots b %u c %u "
1559                   "levels b %u c %u flfirst %u fllast %u flcount %u "
1560                   "freeblks %u longest %u caller %ps",
1561                   MAJOR(__entry->dev), MINOR(__entry->dev),
1562                   __entry->agno,
1563                   __print_flags(__entry->flags, "|", XFS_AGF_FLAGS),
1564                   __entry->length,
1565                   __entry->bno_root,
1566                   __entry->cnt_root,
1567                   __entry->bno_level,
1568                   __entry->cnt_level,
1569                   __entry->flfirst,
1570                   __entry->fllast,
1571                   __entry->flcount,
1572                   __entry->freeblks,
1573                   __entry->longest,
1574                   (void *)__entry->caller_ip)
1575 );
1576
1577 TRACE_EVENT(xfs_free_extent,
1578         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
1579                  xfs_extlen_t len, enum xfs_ag_resv_type resv, int haveleft,
1580                  int haveright),
1581         TP_ARGS(mp, agno, agbno, len, resv, haveleft, haveright),
1582         TP_STRUCT__entry(
1583                 __field(dev_t, dev)
1584                 __field(xfs_agnumber_t, agno)
1585                 __field(xfs_agblock_t, agbno)
1586                 __field(xfs_extlen_t, len)
1587                 __field(int, resv)
1588                 __field(int, haveleft)
1589                 __field(int, haveright)
1590         ),
1591         TP_fast_assign(
1592                 __entry->dev = mp->m_super->s_dev;
1593                 __entry->agno = agno;
1594                 __entry->agbno = agbno;
1595                 __entry->len = len;
1596                 __entry->resv = resv;
1597                 __entry->haveleft = haveleft;
1598                 __entry->haveright = haveright;
1599         ),
1600         TP_printk("dev %d:%d agno %u agbno %u len %u resv %d %s",
1601                   MAJOR(__entry->dev), MINOR(__entry->dev),
1602                   __entry->agno,
1603                   __entry->agbno,
1604                   __entry->len,
1605                   __entry->resv,
1606                   __entry->haveleft ?
1607                         (__entry->haveright ? "both" : "left") :
1608                         (__entry->haveright ? "right" : "none"))
1609
1610 );
1611
1612 DECLARE_EVENT_CLASS(xfs_alloc_class,
1613         TP_PROTO(struct xfs_alloc_arg *args),
1614         TP_ARGS(args),
1615         TP_STRUCT__entry(
1616                 __field(dev_t, dev)
1617                 __field(xfs_agnumber_t, agno)
1618                 __field(xfs_agblock_t, agbno)
1619                 __field(xfs_extlen_t, minlen)
1620                 __field(xfs_extlen_t, maxlen)
1621                 __field(xfs_extlen_t, mod)
1622                 __field(xfs_extlen_t, prod)
1623                 __field(xfs_extlen_t, minleft)
1624                 __field(xfs_extlen_t, total)
1625                 __field(xfs_extlen_t, alignment)
1626                 __field(xfs_extlen_t, minalignslop)
1627                 __field(xfs_extlen_t, len)
1628                 __field(short, type)
1629                 __field(short, otype)
1630                 __field(char, wasdel)
1631                 __field(char, wasfromfl)
1632                 __field(int, resv)
1633                 __field(int, datatype)
1634                 __field(xfs_fsblock_t, firstblock)
1635         ),
1636         TP_fast_assign(
1637                 __entry->dev = args->mp->m_super->s_dev;
1638                 __entry->agno = args->agno;
1639                 __entry->agbno = args->agbno;
1640                 __entry->minlen = args->minlen;
1641                 __entry->maxlen = args->maxlen;
1642                 __entry->mod = args->mod;
1643                 __entry->prod = args->prod;
1644                 __entry->minleft = args->minleft;
1645                 __entry->total = args->total;
1646                 __entry->alignment = args->alignment;
1647                 __entry->minalignslop = args->minalignslop;
1648                 __entry->len = args->len;
1649                 __entry->type = args->type;
1650                 __entry->otype = args->otype;
1651                 __entry->wasdel = args->wasdel;
1652                 __entry->wasfromfl = args->wasfromfl;
1653                 __entry->resv = args->resv;
1654                 __entry->datatype = args->datatype;
1655                 __entry->firstblock = args->firstblock;
1656         ),
1657         TP_printk("dev %d:%d agno %u agbno %u minlen %u maxlen %u mod %u "
1658                   "prod %u minleft %u total %u alignment %u minalignslop %u "
1659                   "len %u type %s otype %s wasdel %d wasfromfl %d resv %d "
1660                   "datatype 0x%x firstblock 0x%llx",
1661                   MAJOR(__entry->dev), MINOR(__entry->dev),
1662                   __entry->agno,
1663                   __entry->agbno,
1664                   __entry->minlen,
1665                   __entry->maxlen,
1666                   __entry->mod,
1667                   __entry->prod,
1668                   __entry->minleft,
1669                   __entry->total,
1670                   __entry->alignment,
1671                   __entry->minalignslop,
1672                   __entry->len,
1673                   __print_symbolic(__entry->type, XFS_ALLOC_TYPES),
1674                   __print_symbolic(__entry->otype, XFS_ALLOC_TYPES),
1675                   __entry->wasdel,
1676                   __entry->wasfromfl,
1677                   __entry->resv,
1678                   __entry->datatype,
1679                   (unsigned long long)__entry->firstblock)
1680 )
1681
1682 #define DEFINE_ALLOC_EVENT(name) \
1683 DEFINE_EVENT(xfs_alloc_class, name, \
1684         TP_PROTO(struct xfs_alloc_arg *args), \
1685         TP_ARGS(args))
1686 DEFINE_ALLOC_EVENT(xfs_alloc_exact_done);
1687 DEFINE_ALLOC_EVENT(xfs_alloc_exact_notfound);
1688 DEFINE_ALLOC_EVENT(xfs_alloc_exact_error);
1689 DEFINE_ALLOC_EVENT(xfs_alloc_near_nominleft);
1690 DEFINE_ALLOC_EVENT(xfs_alloc_near_first);
1691 DEFINE_ALLOC_EVENT(xfs_alloc_near_greater);
1692 DEFINE_ALLOC_EVENT(xfs_alloc_near_lesser);
1693 DEFINE_ALLOC_EVENT(xfs_alloc_near_error);
1694 DEFINE_ALLOC_EVENT(xfs_alloc_near_noentry);
1695 DEFINE_ALLOC_EVENT(xfs_alloc_near_busy);
1696 DEFINE_ALLOC_EVENT(xfs_alloc_size_neither);
1697 DEFINE_ALLOC_EVENT(xfs_alloc_size_noentry);
1698 DEFINE_ALLOC_EVENT(xfs_alloc_size_nominleft);
1699 DEFINE_ALLOC_EVENT(xfs_alloc_size_done);
1700 DEFINE_ALLOC_EVENT(xfs_alloc_size_error);
1701 DEFINE_ALLOC_EVENT(xfs_alloc_size_busy);
1702 DEFINE_ALLOC_EVENT(xfs_alloc_small_freelist);
1703 DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough);
1704 DEFINE_ALLOC_EVENT(xfs_alloc_small_done);
1705 DEFINE_ALLOC_EVENT(xfs_alloc_small_error);
1706 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_badargs);
1707 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_nofix);
1708 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp);
1709 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed);
1710 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed);
1711
1712 DECLARE_EVENT_CLASS(xfs_da_class,
1713         TP_PROTO(struct xfs_da_args *args),
1714         TP_ARGS(args),
1715         TP_STRUCT__entry(
1716                 __field(dev_t, dev)
1717                 __field(xfs_ino_t, ino)
1718                 __dynamic_array(char, name, args->namelen)
1719                 __field(int, namelen)
1720                 __field(xfs_dahash_t, hashval)
1721                 __field(xfs_ino_t, inumber)
1722                 __field(int, op_flags)
1723         ),
1724         TP_fast_assign(
1725                 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1726                 __entry->ino = args->dp->i_ino;
1727                 if (args->namelen)
1728                         memcpy(__get_str(name), args->name, args->namelen);
1729                 __entry->namelen = args->namelen;
1730                 __entry->hashval = args->hashval;
1731                 __entry->inumber = args->inumber;
1732                 __entry->op_flags = args->op_flags;
1733         ),
1734         TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x "
1735                   "inumber 0x%llx op_flags %s",
1736                   MAJOR(__entry->dev), MINOR(__entry->dev),
1737                   __entry->ino,
1738                   __entry->namelen,
1739                   __entry->namelen ? __get_str(name) : NULL,
1740                   __entry->namelen,
1741                   __entry->hashval,
1742                   __entry->inumber,
1743                   __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS))
1744 )
1745
1746 #define DEFINE_DIR2_EVENT(name) \
1747 DEFINE_EVENT(xfs_da_class, name, \
1748         TP_PROTO(struct xfs_da_args *args), \
1749         TP_ARGS(args))
1750 DEFINE_DIR2_EVENT(xfs_dir2_sf_addname);
1751 DEFINE_DIR2_EVENT(xfs_dir2_sf_create);
1752 DEFINE_DIR2_EVENT(xfs_dir2_sf_lookup);
1753 DEFINE_DIR2_EVENT(xfs_dir2_sf_replace);
1754 DEFINE_DIR2_EVENT(xfs_dir2_sf_removename);
1755 DEFINE_DIR2_EVENT(xfs_dir2_sf_toino4);
1756 DEFINE_DIR2_EVENT(xfs_dir2_sf_toino8);
1757 DEFINE_DIR2_EVENT(xfs_dir2_sf_to_block);
1758 DEFINE_DIR2_EVENT(xfs_dir2_block_addname);
1759 DEFINE_DIR2_EVENT(xfs_dir2_block_lookup);
1760 DEFINE_DIR2_EVENT(xfs_dir2_block_replace);
1761 DEFINE_DIR2_EVENT(xfs_dir2_block_removename);
1762 DEFINE_DIR2_EVENT(xfs_dir2_block_to_sf);
1763 DEFINE_DIR2_EVENT(xfs_dir2_block_to_leaf);
1764 DEFINE_DIR2_EVENT(xfs_dir2_leaf_addname);
1765 DEFINE_DIR2_EVENT(xfs_dir2_leaf_lookup);
1766 DEFINE_DIR2_EVENT(xfs_dir2_leaf_replace);
1767 DEFINE_DIR2_EVENT(xfs_dir2_leaf_removename);
1768 DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_block);
1769 DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_node);
1770 DEFINE_DIR2_EVENT(xfs_dir2_node_addname);
1771 DEFINE_DIR2_EVENT(xfs_dir2_node_lookup);
1772 DEFINE_DIR2_EVENT(xfs_dir2_node_replace);
1773 DEFINE_DIR2_EVENT(xfs_dir2_node_removename);
1774 DEFINE_DIR2_EVENT(xfs_dir2_node_to_leaf);
1775
1776 DECLARE_EVENT_CLASS(xfs_attr_class,
1777         TP_PROTO(struct xfs_da_args *args),
1778         TP_ARGS(args),
1779         TP_STRUCT__entry(
1780                 __field(dev_t, dev)
1781                 __field(xfs_ino_t, ino)
1782                 __dynamic_array(char, name, args->namelen)
1783                 __field(int, namelen)
1784                 __field(int, valuelen)
1785                 __field(xfs_dahash_t, hashval)
1786                 __field(int, op_flags)
1787         ),
1788         TP_fast_assign(
1789                 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1790                 __entry->ino = args->dp->i_ino;
1791                 if (args->namelen)
1792                         memcpy(__get_str(name), args->name, args->namelen);
1793                 __entry->namelen = args->namelen;
1794                 __entry->valuelen = args->valuelen;
1795                 __entry->hashval = args->hashval;
1796                 __entry->op_flags = args->op_flags;
1797         ),
1798         TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d valuelen %d "
1799                   "hashval 0x%x op_flags %s",
1800                   MAJOR(__entry->dev), MINOR(__entry->dev),
1801                   __entry->ino,
1802                   __entry->namelen,
1803                   __entry->namelen ? __get_str(name) : NULL,
1804                   __entry->namelen,
1805                   __entry->valuelen,
1806                   __entry->hashval,
1807                   __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS))
1808 )
1809
1810 #define DEFINE_ATTR_EVENT(name) \
1811 DEFINE_EVENT(xfs_attr_class, name, \
1812         TP_PROTO(struct xfs_da_args *args), \
1813         TP_ARGS(args))
1814 DEFINE_ATTR_EVENT(xfs_attr_sf_add);
1815 DEFINE_ATTR_EVENT(xfs_attr_sf_addname);
1816 DEFINE_ATTR_EVENT(xfs_attr_sf_create);
1817 DEFINE_ATTR_EVENT(xfs_attr_sf_lookup);
1818 DEFINE_ATTR_EVENT(xfs_attr_sf_remove);
1819 DEFINE_ATTR_EVENT(xfs_attr_sf_removename);
1820 DEFINE_ATTR_EVENT(xfs_attr_sf_to_leaf);
1821
1822 DEFINE_ATTR_EVENT(xfs_attr_leaf_add);
1823 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_old);
1824 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_new);
1825 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_work);
1826 DEFINE_ATTR_EVENT(xfs_attr_leaf_addname);
1827 DEFINE_ATTR_EVENT(xfs_attr_leaf_create);
1828 DEFINE_ATTR_EVENT(xfs_attr_leaf_compact);
1829 DEFINE_ATTR_EVENT(xfs_attr_leaf_get);
1830 DEFINE_ATTR_EVENT(xfs_attr_leaf_lookup);
1831 DEFINE_ATTR_EVENT(xfs_attr_leaf_replace);
1832 DEFINE_ATTR_EVENT(xfs_attr_leaf_remove);
1833 DEFINE_ATTR_EVENT(xfs_attr_leaf_removename);
1834 DEFINE_ATTR_EVENT(xfs_attr_leaf_split);
1835 DEFINE_ATTR_EVENT(xfs_attr_leaf_split_before);
1836 DEFINE_ATTR_EVENT(xfs_attr_leaf_split_after);
1837 DEFINE_ATTR_EVENT(xfs_attr_leaf_clearflag);
1838 DEFINE_ATTR_EVENT(xfs_attr_leaf_setflag);
1839 DEFINE_ATTR_EVENT(xfs_attr_leaf_flipflags);
1840 DEFINE_ATTR_EVENT(xfs_attr_leaf_to_sf);
1841 DEFINE_ATTR_EVENT(xfs_attr_leaf_to_node);
1842 DEFINE_ATTR_EVENT(xfs_attr_leaf_rebalance);
1843 DEFINE_ATTR_EVENT(xfs_attr_leaf_unbalance);
1844 DEFINE_ATTR_EVENT(xfs_attr_leaf_toosmall);
1845
1846 DEFINE_ATTR_EVENT(xfs_attr_node_addname);
1847 DEFINE_ATTR_EVENT(xfs_attr_node_get);
1848 DEFINE_ATTR_EVENT(xfs_attr_node_lookup);
1849 DEFINE_ATTR_EVENT(xfs_attr_node_replace);
1850 DEFINE_ATTR_EVENT(xfs_attr_node_removename);
1851
1852 DEFINE_ATTR_EVENT(xfs_attr_fillstate);
1853 DEFINE_ATTR_EVENT(xfs_attr_refillstate);
1854
1855 DEFINE_ATTR_EVENT(xfs_attr_rmtval_get);
1856 DEFINE_ATTR_EVENT(xfs_attr_rmtval_set);
1857 DEFINE_ATTR_EVENT(xfs_attr_rmtval_remove);
1858
1859 #define DEFINE_DA_EVENT(name) \
1860 DEFINE_EVENT(xfs_da_class, name, \
1861         TP_PROTO(struct xfs_da_args *args), \
1862         TP_ARGS(args))
1863 DEFINE_DA_EVENT(xfs_da_split);
1864 DEFINE_DA_EVENT(xfs_da_join);
1865 DEFINE_DA_EVENT(xfs_da_link_before);
1866 DEFINE_DA_EVENT(xfs_da_link_after);
1867 DEFINE_DA_EVENT(xfs_da_unlink_back);
1868 DEFINE_DA_EVENT(xfs_da_unlink_forward);
1869 DEFINE_DA_EVENT(xfs_da_root_split);
1870 DEFINE_DA_EVENT(xfs_da_root_join);
1871 DEFINE_DA_EVENT(xfs_da_node_add);
1872 DEFINE_DA_EVENT(xfs_da_node_create);
1873 DEFINE_DA_EVENT(xfs_da_node_split);
1874 DEFINE_DA_EVENT(xfs_da_node_remove);
1875 DEFINE_DA_EVENT(xfs_da_node_rebalance);
1876 DEFINE_DA_EVENT(xfs_da_node_unbalance);
1877 DEFINE_DA_EVENT(xfs_da_node_toosmall);
1878 DEFINE_DA_EVENT(xfs_da_swap_lastblock);
1879 DEFINE_DA_EVENT(xfs_da_grow_inode);
1880 DEFINE_DA_EVENT(xfs_da_shrink_inode);
1881 DEFINE_DA_EVENT(xfs_da_fixhashpath);
1882 DEFINE_DA_EVENT(xfs_da_path_shift);
1883
1884 DECLARE_EVENT_CLASS(xfs_dir2_space_class,
1885         TP_PROTO(struct xfs_da_args *args, int idx),
1886         TP_ARGS(args, idx),
1887         TP_STRUCT__entry(
1888                 __field(dev_t, dev)
1889                 __field(xfs_ino_t, ino)
1890                 __field(int, op_flags)
1891                 __field(int, idx)
1892         ),
1893         TP_fast_assign(
1894                 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1895                 __entry->ino = args->dp->i_ino;
1896                 __entry->op_flags = args->op_flags;
1897                 __entry->idx = idx;
1898         ),
1899         TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d",
1900                   MAJOR(__entry->dev), MINOR(__entry->dev),
1901                   __entry->ino,
1902                   __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS),
1903                   __entry->idx)
1904 )
1905
1906 #define DEFINE_DIR2_SPACE_EVENT(name) \
1907 DEFINE_EVENT(xfs_dir2_space_class, name, \
1908         TP_PROTO(struct xfs_da_args *args, int idx), \
1909         TP_ARGS(args, idx))
1910 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_add);
1911 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_remove);
1912 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_grow_inode);
1913 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_shrink_inode);
1914
1915 TRACE_EVENT(xfs_dir2_leafn_moveents,
1916         TP_PROTO(struct xfs_da_args *args, int src_idx, int dst_idx, int count),
1917         TP_ARGS(args, src_idx, dst_idx, count),
1918         TP_STRUCT__entry(
1919                 __field(dev_t, dev)
1920                 __field(xfs_ino_t, ino)
1921                 __field(int, op_flags)
1922                 __field(int, src_idx)
1923                 __field(int, dst_idx)
1924                 __field(int, count)
1925         ),
1926         TP_fast_assign(
1927                 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1928                 __entry->ino = args->dp->i_ino;
1929                 __entry->op_flags = args->op_flags;
1930                 __entry->src_idx = src_idx;
1931                 __entry->dst_idx = dst_idx;
1932                 __entry->count = count;
1933         ),
1934         TP_printk("dev %d:%d ino 0x%llx op_flags %s "
1935                   "src_idx %d dst_idx %d count %d",
1936                   MAJOR(__entry->dev), MINOR(__entry->dev),
1937                   __entry->ino,
1938                   __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS),
1939                   __entry->src_idx,
1940                   __entry->dst_idx,
1941                   __entry->count)
1942 );
1943
1944 #define XFS_SWAPEXT_INODES \
1945         { 0,    "target" }, \
1946         { 1,    "temp" }
1947
1948 #define XFS_INODE_FORMAT_STR \
1949         { 0,    "invalid" }, \
1950         { 1,    "local" }, \
1951         { 2,    "extent" }, \
1952         { 3,    "btree" }
1953
1954 DECLARE_EVENT_CLASS(xfs_swap_extent_class,
1955         TP_PROTO(struct xfs_inode *ip, int which),
1956         TP_ARGS(ip, which),
1957         TP_STRUCT__entry(
1958                 __field(dev_t, dev)
1959                 __field(int, which)
1960                 __field(xfs_ino_t, ino)
1961                 __field(int, format)
1962                 __field(int, nex)
1963                 __field(int, broot_size)
1964                 __field(int, fork_off)
1965         ),
1966         TP_fast_assign(
1967                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1968                 __entry->which = which;
1969                 __entry->ino = ip->i_ino;
1970                 __entry->format = ip->i_d.di_format;
1971                 __entry->nex = ip->i_d.di_nextents;
1972                 __entry->broot_size = ip->i_df.if_broot_bytes;
1973                 __entry->fork_off = XFS_IFORK_BOFF(ip);
1974         ),
1975         TP_printk("dev %d:%d ino 0x%llx (%s), %s format, num_extents %d, "
1976                   "broot size %d, fork offset %d",
1977                   MAJOR(__entry->dev), MINOR(__entry->dev),
1978                   __entry->ino,
1979                   __print_symbolic(__entry->which, XFS_SWAPEXT_INODES),
1980                   __print_symbolic(__entry->format, XFS_INODE_FORMAT_STR),
1981                   __entry->nex,
1982                   __entry->broot_size,
1983                   __entry->fork_off)
1984 )
1985
1986 #define DEFINE_SWAPEXT_EVENT(name) \
1987 DEFINE_EVENT(xfs_swap_extent_class, name, \
1988         TP_PROTO(struct xfs_inode *ip, int which), \
1989         TP_ARGS(ip, which))
1990
1991 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_before);
1992 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_after);
1993
1994 TRACE_EVENT(xfs_log_recover_record,
1995         TP_PROTO(struct xlog *log, struct xlog_rec_header *rhead, int pass),
1996         TP_ARGS(log, rhead, pass),
1997         TP_STRUCT__entry(
1998                 __field(dev_t, dev)
1999                 __field(xfs_lsn_t, lsn)
2000                 __field(int, len)
2001                 __field(int, num_logops)
2002                 __field(int, pass)
2003         ),
2004         TP_fast_assign(
2005                 __entry->dev = log->l_mp->m_super->s_dev;
2006                 __entry->lsn = be64_to_cpu(rhead->h_lsn);
2007                 __entry->len = be32_to_cpu(rhead->h_len);
2008                 __entry->num_logops = be32_to_cpu(rhead->h_num_logops);
2009                 __entry->pass = pass;
2010         ),
2011         TP_printk("dev %d:%d lsn 0x%llx len 0x%x num_logops 0x%x pass %d",
2012                   MAJOR(__entry->dev), MINOR(__entry->dev),
2013                   __entry->lsn, __entry->len, __entry->num_logops,
2014                    __entry->pass)
2015 )
2016
2017 DECLARE_EVENT_CLASS(xfs_log_recover_item_class,
2018         TP_PROTO(struct xlog *log, struct xlog_recover *trans,
2019                 struct xlog_recover_item *item, int pass),
2020         TP_ARGS(log, trans, item, pass),
2021         TP_STRUCT__entry(
2022                 __field(dev_t, dev)
2023                 __field(unsigned long, item)
2024                 __field(xlog_tid_t, tid)
2025                 __field(xfs_lsn_t, lsn)
2026                 __field(int, type)
2027                 __field(int, pass)
2028                 __field(int, count)
2029                 __field(int, total)
2030         ),
2031         TP_fast_assign(
2032                 __entry->dev = log->l_mp->m_super->s_dev;
2033                 __entry->item = (unsigned long)item;
2034                 __entry->tid = trans->r_log_tid;
2035                 __entry->lsn = trans->r_lsn;
2036                 __entry->type = ITEM_TYPE(item);
2037                 __entry->pass = pass;
2038                 __entry->count = item->ri_cnt;
2039                 __entry->total = item->ri_total;
2040         ),
2041         TP_printk("dev %d:%d tid 0x%x lsn 0x%llx, pass %d, item 0x%p, "
2042                   "item type %s item region count/total %d/%d",
2043                   MAJOR(__entry->dev), MINOR(__entry->dev),
2044                   __entry->tid,
2045                   __entry->lsn,
2046                   __entry->pass,
2047                   (void *)__entry->item,
2048                   __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
2049                   __entry->count,
2050                   __entry->total)
2051 )
2052
2053 #define DEFINE_LOG_RECOVER_ITEM(name) \
2054 DEFINE_EVENT(xfs_log_recover_item_class, name, \
2055         TP_PROTO(struct xlog *log, struct xlog_recover *trans, \
2056                 struct xlog_recover_item *item, int pass), \
2057         TP_ARGS(log, trans, item, pass))
2058
2059 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add);
2060 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add_cont);
2061 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_head);
2062 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_tail);
2063 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_recover);
2064
2065 DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class,
2066         TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f),
2067         TP_ARGS(log, buf_f),
2068         TP_STRUCT__entry(
2069                 __field(dev_t, dev)
2070                 __field(__int64_t, blkno)
2071                 __field(unsigned short, len)
2072                 __field(unsigned short, flags)
2073                 __field(unsigned short, size)
2074                 __field(unsigned int, map_size)
2075         ),
2076         TP_fast_assign(
2077                 __entry->dev = log->l_mp->m_super->s_dev;
2078                 __entry->blkno = buf_f->blf_blkno;
2079                 __entry->len = buf_f->blf_len;
2080                 __entry->flags = buf_f->blf_flags;
2081                 __entry->size = buf_f->blf_size;
2082                 __entry->map_size = buf_f->blf_map_size;
2083         ),
2084         TP_printk("dev %d:%d blkno 0x%llx, len %u, flags 0x%x, size %d, "
2085                         "map_size %d",
2086                   MAJOR(__entry->dev), MINOR(__entry->dev),
2087                   __entry->blkno,
2088                   __entry->len,
2089                   __entry->flags,
2090                   __entry->size,
2091                   __entry->map_size)
2092 )
2093
2094 #define DEFINE_LOG_RECOVER_BUF_ITEM(name) \
2095 DEFINE_EVENT(xfs_log_recover_buf_item_class, name, \
2096         TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), \
2097         TP_ARGS(log, buf_f))
2098
2099 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_not_cancel);
2100 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel);
2101 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_add);
2102 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_ref_inc);
2103 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_recover);
2104 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_skip);
2105 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_inode_buf);
2106 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_reg_buf);
2107 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_dquot_buf);
2108
2109 DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class,
2110         TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f),
2111         TP_ARGS(log, in_f),
2112         TP_STRUCT__entry(
2113                 __field(dev_t, dev)
2114                 __field(xfs_ino_t, ino)
2115                 __field(unsigned short, size)
2116                 __field(int, fields)
2117                 __field(unsigned short, asize)
2118                 __field(unsigned short, dsize)
2119                 __field(__int64_t, blkno)
2120                 __field(int, len)
2121                 __field(int, boffset)
2122         ),
2123         TP_fast_assign(
2124                 __entry->dev = log->l_mp->m_super->s_dev;
2125                 __entry->ino = in_f->ilf_ino;
2126                 __entry->size = in_f->ilf_size;
2127                 __entry->fields = in_f->ilf_fields;
2128                 __entry->asize = in_f->ilf_asize;
2129                 __entry->dsize = in_f->ilf_dsize;
2130                 __entry->blkno = in_f->ilf_blkno;
2131                 __entry->len = in_f->ilf_len;
2132                 __entry->boffset = in_f->ilf_boffset;
2133         ),
2134         TP_printk("dev %d:%d ino 0x%llx, size %u, fields 0x%x, asize %d, "
2135                         "dsize %d, blkno 0x%llx, len %d, boffset %d",
2136                   MAJOR(__entry->dev), MINOR(__entry->dev),
2137                   __entry->ino,
2138                   __entry->size,
2139                   __entry->fields,
2140                   __entry->asize,
2141                   __entry->dsize,
2142                   __entry->blkno,
2143                   __entry->len,
2144                   __entry->boffset)
2145 )
2146 #define DEFINE_LOG_RECOVER_INO_ITEM(name) \
2147 DEFINE_EVENT(xfs_log_recover_ino_item_class, name, \
2148         TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), \
2149         TP_ARGS(log, in_f))
2150
2151 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover);
2152 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_cancel);
2153 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_skip);
2154
2155 DECLARE_EVENT_CLASS(xfs_log_recover_icreate_item_class,
2156         TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f),
2157         TP_ARGS(log, in_f),
2158         TP_STRUCT__entry(
2159                 __field(dev_t, dev)
2160                 __field(xfs_agnumber_t, agno)
2161                 __field(xfs_agblock_t, agbno)
2162                 __field(unsigned int, count)
2163                 __field(unsigned int, isize)
2164                 __field(xfs_agblock_t, length)
2165                 __field(unsigned int, gen)
2166         ),
2167         TP_fast_assign(
2168                 __entry->dev = log->l_mp->m_super->s_dev;
2169                 __entry->agno = be32_to_cpu(in_f->icl_ag);
2170                 __entry->agbno = be32_to_cpu(in_f->icl_agbno);
2171                 __entry->count = be32_to_cpu(in_f->icl_count);
2172                 __entry->isize = be32_to_cpu(in_f->icl_isize);
2173                 __entry->length = be32_to_cpu(in_f->icl_length);
2174                 __entry->gen = be32_to_cpu(in_f->icl_gen);
2175         ),
2176         TP_printk("dev %d:%d agno %u agbno %u count %u isize %u length %u "
2177                   "gen %u", MAJOR(__entry->dev), MINOR(__entry->dev),
2178                   __entry->agno, __entry->agbno, __entry->count, __entry->isize,
2179                   __entry->length, __entry->gen)
2180 )
2181 #define DEFINE_LOG_RECOVER_ICREATE_ITEM(name) \
2182 DEFINE_EVENT(xfs_log_recover_icreate_item_class, name, \
2183         TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), \
2184         TP_ARGS(log, in_f))
2185
2186 DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_cancel);
2187 DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_recover);
2188
2189 DECLARE_EVENT_CLASS(xfs_discard_class,
2190         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2191                  xfs_agblock_t agbno, xfs_extlen_t len),
2192         TP_ARGS(mp, agno, agbno, len),
2193         TP_STRUCT__entry(
2194                 __field(dev_t, dev)
2195                 __field(xfs_agnumber_t, agno)
2196                 __field(xfs_agblock_t, agbno)
2197                 __field(xfs_extlen_t, len)
2198         ),
2199         TP_fast_assign(
2200                 __entry->dev = mp->m_super->s_dev;
2201                 __entry->agno = agno;
2202                 __entry->agbno = agbno;
2203                 __entry->len = len;
2204         ),
2205         TP_printk("dev %d:%d agno %u agbno %u len %u\n",
2206                   MAJOR(__entry->dev), MINOR(__entry->dev),
2207                   __entry->agno,
2208                   __entry->agbno,
2209                   __entry->len)
2210 )
2211
2212 #define DEFINE_DISCARD_EVENT(name) \
2213 DEFINE_EVENT(xfs_discard_class, name, \
2214         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2215                  xfs_agblock_t agbno, xfs_extlen_t len), \
2216         TP_ARGS(mp, agno, agbno, len))
2217 DEFINE_DISCARD_EVENT(xfs_discard_extent);
2218 DEFINE_DISCARD_EVENT(xfs_discard_toosmall);
2219 DEFINE_DISCARD_EVENT(xfs_discard_exclude);
2220 DEFINE_DISCARD_EVENT(xfs_discard_busy);
2221
2222 /* btree cursor events */
2223 DECLARE_EVENT_CLASS(xfs_btree_cur_class,
2224         TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp),
2225         TP_ARGS(cur, level, bp),
2226         TP_STRUCT__entry(
2227                 __field(dev_t, dev)
2228                 __field(xfs_btnum_t, btnum)
2229                 __field(int, level)
2230                 __field(int, nlevels)
2231                 __field(int, ptr)
2232                 __field(xfs_daddr_t, daddr)
2233         ),
2234         TP_fast_assign(
2235                 __entry->dev = cur->bc_mp->m_super->s_dev;
2236                 __entry->btnum = cur->bc_btnum;
2237                 __entry->level = level;
2238                 __entry->nlevels = cur->bc_nlevels;
2239                 __entry->ptr = cur->bc_ptrs[level];
2240                 __entry->daddr = bp ? bp->b_bn : -1;
2241         ),
2242         TP_printk("dev %d:%d btnum %d level %d/%d ptr %d daddr 0x%llx",
2243                   MAJOR(__entry->dev), MINOR(__entry->dev),
2244                   __entry->btnum,
2245                   __entry->level,
2246                   __entry->nlevels,
2247                   __entry->ptr,
2248                   (unsigned long long)__entry->daddr)
2249 )
2250
2251 #define DEFINE_BTREE_CUR_EVENT(name) \
2252 DEFINE_EVENT(xfs_btree_cur_class, name, \
2253         TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), \
2254         TP_ARGS(cur, level, bp))
2255 DEFINE_BTREE_CUR_EVENT(xfs_btree_updkeys);
2256 DEFINE_BTREE_CUR_EVENT(xfs_btree_overlapped_query_range);
2257
2258 /* deferred ops */
2259 struct xfs_defer_pending;
2260 struct xfs_defer_intake;
2261 struct xfs_defer_ops;
2262
2263 DECLARE_EVENT_CLASS(xfs_defer_class,
2264         TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop),
2265         TP_ARGS(mp, dop),
2266         TP_STRUCT__entry(
2267                 __field(dev_t, dev)
2268                 __field(void *, dop)
2269                 __field(bool, committed)
2270                 __field(bool, low)
2271         ),
2272         TP_fast_assign(
2273                 __entry->dev = mp ? mp->m_super->s_dev : 0;
2274                 __entry->dop = dop;
2275                 __entry->committed = dop->dop_committed;
2276                 __entry->low = dop->dop_low;
2277         ),
2278         TP_printk("dev %d:%d ops %p committed %d low %d\n",
2279                   MAJOR(__entry->dev), MINOR(__entry->dev),
2280                   __entry->dop,
2281                   __entry->committed,
2282                   __entry->low)
2283 )
2284 #define DEFINE_DEFER_EVENT(name) \
2285 DEFINE_EVENT(xfs_defer_class, name, \
2286         TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop), \
2287         TP_ARGS(mp, dop))
2288
2289 DECLARE_EVENT_CLASS(xfs_defer_error_class,
2290         TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop, int error),
2291         TP_ARGS(mp, dop, error),
2292         TP_STRUCT__entry(
2293                 __field(dev_t, dev)
2294                 __field(void *, dop)
2295                 __field(bool, committed)
2296                 __field(bool, low)
2297                 __field(int, error)
2298         ),
2299         TP_fast_assign(
2300                 __entry->dev = mp ? mp->m_super->s_dev : 0;
2301                 __entry->dop = dop;
2302                 __entry->committed = dop->dop_committed;
2303                 __entry->low = dop->dop_low;
2304                 __entry->error = error;
2305         ),
2306         TP_printk("dev %d:%d ops %p committed %d low %d err %d\n",
2307                   MAJOR(__entry->dev), MINOR(__entry->dev),
2308                   __entry->dop,
2309                   __entry->committed,
2310                   __entry->low,
2311                   __entry->error)
2312 )
2313 #define DEFINE_DEFER_ERROR_EVENT(name) \
2314 DEFINE_EVENT(xfs_defer_error_class, name, \
2315         TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop, int error), \
2316         TP_ARGS(mp, dop, error))
2317
2318 DECLARE_EVENT_CLASS(xfs_defer_pending_class,
2319         TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp),
2320         TP_ARGS(mp, dfp),
2321         TP_STRUCT__entry(
2322                 __field(dev_t, dev)
2323                 __field(int, type)
2324                 __field(void *, intent)
2325                 __field(bool, committed)
2326                 __field(int, nr)
2327         ),
2328         TP_fast_assign(
2329                 __entry->dev = mp ? mp->m_super->s_dev : 0;
2330                 __entry->type = dfp->dfp_type->type;
2331                 __entry->intent = dfp->dfp_intent;
2332                 __entry->committed = dfp->dfp_done != NULL;
2333                 __entry->nr = dfp->dfp_count;
2334         ),
2335         TP_printk("dev %d:%d optype %d intent %p committed %d nr %d\n",
2336                   MAJOR(__entry->dev), MINOR(__entry->dev),
2337                   __entry->type,
2338                   __entry->intent,
2339                   __entry->committed,
2340                   __entry->nr)
2341 )
2342 #define DEFINE_DEFER_PENDING_EVENT(name) \
2343 DEFINE_EVENT(xfs_defer_pending_class, name, \
2344         TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), \
2345         TP_ARGS(mp, dfp))
2346
2347 DECLARE_EVENT_CLASS(xfs_phys_extent_deferred_class,
2348         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2349                  int type, xfs_agblock_t agbno, xfs_extlen_t len),
2350         TP_ARGS(mp, agno, type, agbno, len),
2351         TP_STRUCT__entry(
2352                 __field(dev_t, dev)
2353                 __field(xfs_agnumber_t, agno)
2354                 __field(int, type)
2355                 __field(xfs_agblock_t, agbno)
2356                 __field(xfs_extlen_t, len)
2357         ),
2358         TP_fast_assign(
2359                 __entry->dev = mp->m_super->s_dev;
2360                 __entry->agno = agno;
2361                 __entry->type = type;
2362                 __entry->agbno = agbno;
2363                 __entry->len = len;
2364         ),
2365         TP_printk("dev %d:%d op %d agno %u agbno %u len %u",
2366                   MAJOR(__entry->dev), MINOR(__entry->dev),
2367                   __entry->type,
2368                   __entry->agno,
2369                   __entry->agbno,
2370                   __entry->len)
2371 );
2372 #define DEFINE_PHYS_EXTENT_DEFERRED_EVENT(name) \
2373 DEFINE_EVENT(xfs_phys_extent_deferred_class, name, \
2374         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2375                  int type, \
2376                  xfs_agblock_t bno, \
2377                  xfs_extlen_t len), \
2378         TP_ARGS(mp, agno, type, bno, len))
2379
2380 DECLARE_EVENT_CLASS(xfs_map_extent_deferred_class,
2381         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2382                  int op,
2383                  xfs_agblock_t agbno,
2384                  xfs_ino_t ino,
2385                  int whichfork,
2386                  xfs_fileoff_t offset,
2387                  xfs_filblks_t len,
2388                  xfs_exntst_t state),
2389         TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state),
2390         TP_STRUCT__entry(
2391                 __field(dev_t, dev)
2392                 __field(xfs_agnumber_t, agno)
2393                 __field(xfs_ino_t, ino)
2394                 __field(xfs_agblock_t, agbno)
2395                 __field(int, whichfork)
2396                 __field(xfs_fileoff_t, l_loff)
2397                 __field(xfs_filblks_t, l_len)
2398                 __field(xfs_exntst_t, l_state)
2399                 __field(int, op)
2400         ),
2401         TP_fast_assign(
2402                 __entry->dev = mp->m_super->s_dev;
2403                 __entry->agno = agno;
2404                 __entry->ino = ino;
2405                 __entry->agbno = agbno;
2406                 __entry->whichfork = whichfork;
2407                 __entry->l_loff = offset;
2408                 __entry->l_len = len;
2409                 __entry->l_state = state;
2410                 __entry->op = op;
2411         ),
2412         TP_printk("dev %d:%d op %d agno %u agbno %u owner %lld %s offset %llu len %llu state %d",
2413                   MAJOR(__entry->dev), MINOR(__entry->dev),
2414                   __entry->op,
2415                   __entry->agno,
2416                   __entry->agbno,
2417                   __entry->ino,
2418                   __entry->whichfork == XFS_ATTR_FORK ? "attr" : "data",
2419                   __entry->l_loff,
2420                   __entry->l_len,
2421                   __entry->l_state)
2422 );
2423 #define DEFINE_MAP_EXTENT_DEFERRED_EVENT(name) \
2424 DEFINE_EVENT(xfs_map_extent_deferred_class, name, \
2425         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2426                  int op, \
2427                  xfs_agblock_t agbno, \
2428                  xfs_ino_t ino, \
2429                  int whichfork, \
2430                  xfs_fileoff_t offset, \
2431                  xfs_filblks_t len, \
2432                  xfs_exntst_t state), \
2433         TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state))
2434
2435 DEFINE_DEFER_EVENT(xfs_defer_init);
2436 DEFINE_DEFER_EVENT(xfs_defer_cancel);
2437 DEFINE_DEFER_EVENT(xfs_defer_trans_roll);
2438 DEFINE_DEFER_EVENT(xfs_defer_trans_abort);
2439 DEFINE_DEFER_EVENT(xfs_defer_finish);
2440 DEFINE_DEFER_EVENT(xfs_defer_finish_done);
2441
2442 DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error);
2443 DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error);
2444 DEFINE_DEFER_ERROR_EVENT(xfs_defer_op_finish_error);
2445
2446 DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_work);
2447 DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_cancel);
2448 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_commit);
2449 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_cancel);
2450 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish);
2451 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort);
2452
2453 #define DEFINE_BMAP_FREE_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT
2454 DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_defer);
2455 DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_deferred);
2456
2457 /* rmap tracepoints */
2458 DECLARE_EVENT_CLASS(xfs_rmap_class,
2459         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2460                  xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten,
2461                  struct xfs_owner_info *oinfo),
2462         TP_ARGS(mp, agno, agbno, len, unwritten, oinfo),
2463         TP_STRUCT__entry(
2464                 __field(dev_t, dev)
2465                 __field(xfs_agnumber_t, agno)
2466                 __field(xfs_agblock_t, agbno)
2467                 __field(xfs_extlen_t, len)
2468                 __field(uint64_t, owner)
2469                 __field(uint64_t, offset)
2470                 __field(unsigned long, flags)
2471         ),
2472         TP_fast_assign(
2473                 __entry->dev = mp->m_super->s_dev;
2474                 __entry->agno = agno;
2475                 __entry->agbno = agbno;
2476                 __entry->len = len;
2477                 __entry->owner = oinfo->oi_owner;
2478                 __entry->offset = oinfo->oi_offset;
2479                 __entry->flags = oinfo->oi_flags;
2480                 if (unwritten)
2481                         __entry->flags |= XFS_RMAP_UNWRITTEN;
2482         ),
2483         TP_printk("dev %d:%d agno %u agbno %u len %u owner %lld offset %llu flags 0x%lx",
2484                   MAJOR(__entry->dev), MINOR(__entry->dev),
2485                   __entry->agno,
2486                   __entry->agbno,
2487                   __entry->len,
2488                   __entry->owner,
2489                   __entry->offset,
2490                   __entry->flags)
2491 );
2492 #define DEFINE_RMAP_EVENT(name) \
2493 DEFINE_EVENT(xfs_rmap_class, name, \
2494         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2495                  xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten, \
2496                  struct xfs_owner_info *oinfo), \
2497         TP_ARGS(mp, agno, agbno, len, unwritten, oinfo))
2498
2499 /* simple AG-based error/%ip tracepoint class */
2500 DECLARE_EVENT_CLASS(xfs_ag_error_class,
2501         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int error,
2502                  unsigned long caller_ip),
2503         TP_ARGS(mp, agno, error, caller_ip),
2504         TP_STRUCT__entry(
2505                 __field(dev_t, dev)
2506                 __field(xfs_agnumber_t, agno)
2507                 __field(int, error)
2508                 __field(unsigned long, caller_ip)
2509         ),
2510         TP_fast_assign(
2511                 __entry->dev = mp->m_super->s_dev;
2512                 __entry->agno = agno;
2513                 __entry->error = error;
2514                 __entry->caller_ip = caller_ip;
2515         ),
2516         TP_printk("dev %d:%d agno %u error %d caller %ps",
2517                   MAJOR(__entry->dev), MINOR(__entry->dev),
2518                   __entry->agno,
2519                   __entry->error,
2520                   (char *)__entry->caller_ip)
2521 );
2522
2523 #define DEFINE_AG_ERROR_EVENT(name) \
2524 DEFINE_EVENT(xfs_ag_error_class, name, \
2525         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int error, \
2526                  unsigned long caller_ip), \
2527         TP_ARGS(mp, agno, error, caller_ip))
2528
2529 DEFINE_RMAP_EVENT(xfs_rmap_unmap);
2530 DEFINE_RMAP_EVENT(xfs_rmap_unmap_done);
2531 DEFINE_AG_ERROR_EVENT(xfs_rmap_unmap_error);
2532 DEFINE_RMAP_EVENT(xfs_rmap_map);
2533 DEFINE_RMAP_EVENT(xfs_rmap_map_done);
2534 DEFINE_AG_ERROR_EVENT(xfs_rmap_map_error);
2535 DEFINE_RMAP_EVENT(xfs_rmap_convert);
2536 DEFINE_RMAP_EVENT(xfs_rmap_convert_done);
2537 DEFINE_AG_ERROR_EVENT(xfs_rmap_convert_error);
2538 DEFINE_AG_ERROR_EVENT(xfs_rmap_convert_state);
2539
2540 DECLARE_EVENT_CLASS(xfs_rmapbt_class,
2541         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2542                  xfs_agblock_t agbno, xfs_extlen_t len,
2543                  uint64_t owner, uint64_t offset, unsigned int flags),
2544         TP_ARGS(mp, agno, agbno, len, owner, offset, flags),
2545         TP_STRUCT__entry(
2546                 __field(dev_t, dev)
2547                 __field(xfs_agnumber_t, agno)
2548                 __field(xfs_agblock_t, agbno)
2549                 __field(xfs_extlen_t, len)
2550                 __field(uint64_t, owner)
2551                 __field(uint64_t, offset)
2552                 __field(unsigned int, flags)
2553         ),
2554         TP_fast_assign(
2555                 __entry->dev = mp->m_super->s_dev;
2556                 __entry->agno = agno;
2557                 __entry->agbno = agbno;
2558                 __entry->len = len;
2559                 __entry->owner = owner;
2560                 __entry->offset = offset;
2561                 __entry->flags = flags;
2562         ),
2563         TP_printk("dev %d:%d agno %u agbno %u len %u owner %lld offset %llu flags 0x%x",
2564                   MAJOR(__entry->dev), MINOR(__entry->dev),
2565                   __entry->agno,
2566                   __entry->agbno,
2567                   __entry->len,
2568                   __entry->owner,
2569                   __entry->offset,
2570                   __entry->flags)
2571 );
2572 #define DEFINE_RMAPBT_EVENT(name) \
2573 DEFINE_EVENT(xfs_rmapbt_class, name, \
2574         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2575                  xfs_agblock_t agbno, xfs_extlen_t len, \
2576                  uint64_t owner, uint64_t offset, unsigned int flags), \
2577         TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
2578
2579 #define DEFINE_RMAP_DEFERRED_EVENT DEFINE_MAP_EXTENT_DEFERRED_EVENT
2580 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_defer);
2581 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_deferred);
2582
2583 DEFINE_BUSY_EVENT(xfs_rmapbt_alloc_block);
2584 DEFINE_BUSY_EVENT(xfs_rmapbt_free_block);
2585 DEFINE_RMAPBT_EVENT(xfs_rmap_update);
2586 DEFINE_RMAPBT_EVENT(xfs_rmap_insert);
2587 DEFINE_RMAPBT_EVENT(xfs_rmap_delete);
2588 DEFINE_AG_ERROR_EVENT(xfs_rmap_insert_error);
2589 DEFINE_AG_ERROR_EVENT(xfs_rmap_delete_error);
2590 DEFINE_AG_ERROR_EVENT(xfs_rmap_update_error);
2591
2592 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_candidate);
2593 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_query);
2594 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_candidate);
2595 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range);
2596 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_result);
2597 DEFINE_RMAPBT_EVENT(xfs_rmap_find_right_neighbor_result);
2598 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_result);
2599
2600 /* deferred bmbt updates */
2601 #define DEFINE_BMAP_DEFERRED_EVENT      DEFINE_RMAP_DEFERRED_EVENT
2602 DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_defer);
2603 DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_deferred);
2604
2605 /* per-AG reservation */
2606 DECLARE_EVENT_CLASS(xfs_ag_resv_class,
2607         TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type resv,
2608                  xfs_extlen_t len),
2609         TP_ARGS(pag, resv, len),
2610         TP_STRUCT__entry(
2611                 __field(dev_t, dev)
2612                 __field(xfs_agnumber_t, agno)
2613                 __field(int, resv)
2614                 __field(xfs_extlen_t, freeblks)
2615                 __field(xfs_extlen_t, flcount)
2616                 __field(xfs_extlen_t, reserved)
2617                 __field(xfs_extlen_t, asked)
2618                 __field(xfs_extlen_t, len)
2619         ),
2620         TP_fast_assign(
2621                 struct xfs_ag_resv      *r = xfs_perag_resv(pag, resv);
2622
2623                 __entry->dev = pag->pag_mount->m_super->s_dev;
2624                 __entry->agno = pag->pag_agno;
2625                 __entry->resv = resv;
2626                 __entry->freeblks = pag->pagf_freeblks;
2627                 __entry->flcount = pag->pagf_flcount;
2628                 __entry->reserved = r ? r->ar_reserved : 0;
2629                 __entry->asked = r ? r->ar_asked : 0;
2630                 __entry->len = len;
2631         ),
2632         TP_printk("dev %d:%d agno %u resv %d freeblks %u flcount %u resv %u ask %u len %u\n",
2633                   MAJOR(__entry->dev), MINOR(__entry->dev),
2634                   __entry->agno,
2635                   __entry->resv,
2636                   __entry->freeblks,
2637                   __entry->flcount,
2638                   __entry->reserved,
2639                   __entry->asked,
2640                   __entry->len)
2641 )
2642 #define DEFINE_AG_RESV_EVENT(name) \
2643 DEFINE_EVENT(xfs_ag_resv_class, name, \
2644         TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type type, \
2645                  xfs_extlen_t len), \
2646         TP_ARGS(pag, type, len))
2647
2648 /* per-AG reservation tracepoints */
2649 DEFINE_AG_RESV_EVENT(xfs_ag_resv_init);
2650 DEFINE_AG_RESV_EVENT(xfs_ag_resv_free);
2651 DEFINE_AG_RESV_EVENT(xfs_ag_resv_alloc_extent);
2652 DEFINE_AG_RESV_EVENT(xfs_ag_resv_free_extent);
2653 DEFINE_AG_RESV_EVENT(xfs_ag_resv_critical);
2654 DEFINE_AG_RESV_EVENT(xfs_ag_resv_needed);
2655
2656 DEFINE_AG_ERROR_EVENT(xfs_ag_resv_free_error);
2657 DEFINE_AG_ERROR_EVENT(xfs_ag_resv_init_error);
2658
2659 /* refcount tracepoint classes */
2660
2661 /* reuse the discard trace class for agbno/aglen-based traces */
2662 #define DEFINE_AG_EXTENT_EVENT(name) DEFINE_DISCARD_EVENT(name)
2663
2664 /* ag btree lookup tracepoint class */
2665 #define XFS_AG_BTREE_CMP_FORMAT_STR \
2666         { XFS_LOOKUP_EQ,        "eq" }, \
2667         { XFS_LOOKUP_LE,        "le" }, \
2668         { XFS_LOOKUP_GE,        "ge" }
2669 DECLARE_EVENT_CLASS(xfs_ag_btree_lookup_class,
2670         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2671                  xfs_agblock_t agbno, xfs_lookup_t dir),
2672         TP_ARGS(mp, agno, agbno, dir),
2673         TP_STRUCT__entry(
2674                 __field(dev_t, dev)
2675                 __field(xfs_agnumber_t, agno)
2676                 __field(xfs_agblock_t, agbno)
2677                 __field(xfs_lookup_t, dir)
2678         ),
2679         TP_fast_assign(
2680                 __entry->dev = mp->m_super->s_dev;
2681                 __entry->agno = agno;
2682                 __entry->agbno = agbno;
2683                 __entry->dir = dir;
2684         ),
2685         TP_printk("dev %d:%d agno %u agbno %u cmp %s(%d)\n",
2686                   MAJOR(__entry->dev), MINOR(__entry->dev),
2687                   __entry->agno,
2688                   __entry->agbno,
2689                   __print_symbolic(__entry->dir, XFS_AG_BTREE_CMP_FORMAT_STR),
2690                   __entry->dir)
2691 )
2692
2693 #define DEFINE_AG_BTREE_LOOKUP_EVENT(name) \
2694 DEFINE_EVENT(xfs_ag_btree_lookup_class, name, \
2695         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2696                  xfs_agblock_t agbno, xfs_lookup_t dir), \
2697         TP_ARGS(mp, agno, agbno, dir))
2698
2699 /* single-rcext tracepoint class */
2700 DECLARE_EVENT_CLASS(xfs_refcount_extent_class,
2701         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2702                  struct xfs_refcount_irec *irec),
2703         TP_ARGS(mp, agno, irec),
2704         TP_STRUCT__entry(
2705                 __field(dev_t, dev)
2706                 __field(xfs_agnumber_t, agno)
2707                 __field(xfs_agblock_t, startblock)
2708                 __field(xfs_extlen_t, blockcount)
2709                 __field(xfs_nlink_t, refcount)
2710         ),
2711         TP_fast_assign(
2712                 __entry->dev = mp->m_super->s_dev;
2713                 __entry->agno = agno;
2714                 __entry->startblock = irec->rc_startblock;
2715                 __entry->blockcount = irec->rc_blockcount;
2716                 __entry->refcount = irec->rc_refcount;
2717         ),
2718         TP_printk("dev %d:%d agno %u agbno %u len %u refcount %u\n",
2719                   MAJOR(__entry->dev), MINOR(__entry->dev),
2720                   __entry->agno,
2721                   __entry->startblock,
2722                   __entry->blockcount,
2723                   __entry->refcount)
2724 )
2725
2726 #define DEFINE_REFCOUNT_EXTENT_EVENT(name) \
2727 DEFINE_EVENT(xfs_refcount_extent_class, name, \
2728         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2729                  struct xfs_refcount_irec *irec), \
2730         TP_ARGS(mp, agno, irec))
2731
2732 /* single-rcext and an agbno tracepoint class */
2733 DECLARE_EVENT_CLASS(xfs_refcount_extent_at_class,
2734         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2735                  struct xfs_refcount_irec *irec, xfs_agblock_t agbno),
2736         TP_ARGS(mp, agno, irec, agbno),
2737         TP_STRUCT__entry(
2738                 __field(dev_t, dev)
2739                 __field(xfs_agnumber_t, agno)
2740                 __field(xfs_agblock_t, startblock)
2741                 __field(xfs_extlen_t, blockcount)
2742                 __field(xfs_nlink_t, refcount)
2743                 __field(xfs_agblock_t, agbno)
2744         ),
2745         TP_fast_assign(
2746                 __entry->dev = mp->m_super->s_dev;
2747                 __entry->agno = agno;
2748                 __entry->startblock = irec->rc_startblock;
2749                 __entry->blockcount = irec->rc_blockcount;
2750                 __entry->refcount = irec->rc_refcount;
2751                 __entry->agbno = agbno;
2752         ),
2753         TP_printk("dev %d:%d agno %u agbno %u len %u refcount %u @ agbno %u\n",
2754                   MAJOR(__entry->dev), MINOR(__entry->dev),
2755                   __entry->agno,
2756                   __entry->startblock,
2757                   __entry->blockcount,
2758                   __entry->refcount,
2759                   __entry->agbno)
2760 )
2761
2762 #define DEFINE_REFCOUNT_EXTENT_AT_EVENT(name) \
2763 DEFINE_EVENT(xfs_refcount_extent_at_class, name, \
2764         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2765                  struct xfs_refcount_irec *irec, xfs_agblock_t agbno), \
2766         TP_ARGS(mp, agno, irec, agbno))
2767
2768 /* double-rcext tracepoint class */
2769 DECLARE_EVENT_CLASS(xfs_refcount_double_extent_class,
2770         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2771                  struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2),
2772         TP_ARGS(mp, agno, i1, i2),
2773         TP_STRUCT__entry(
2774                 __field(dev_t, dev)
2775                 __field(xfs_agnumber_t, agno)
2776                 __field(xfs_agblock_t, i1_startblock)
2777                 __field(xfs_extlen_t, i1_blockcount)
2778                 __field(xfs_nlink_t, i1_refcount)
2779                 __field(xfs_agblock_t, i2_startblock)
2780                 __field(xfs_extlen_t, i2_blockcount)
2781                 __field(xfs_nlink_t, i2_refcount)
2782         ),
2783         TP_fast_assign(
2784                 __entry->dev = mp->m_super->s_dev;
2785                 __entry->agno = agno;
2786                 __entry->i1_startblock = i1->rc_startblock;
2787                 __entry->i1_blockcount = i1->rc_blockcount;
2788                 __entry->i1_refcount = i1->rc_refcount;
2789                 __entry->i2_startblock = i2->rc_startblock;
2790                 __entry->i2_blockcount = i2->rc_blockcount;
2791                 __entry->i2_refcount = i2->rc_refcount;
2792         ),
2793         TP_printk("dev %d:%d agno %u agbno %u len %u refcount %u -- "
2794                   "agbno %u len %u refcount %u\n",
2795                   MAJOR(__entry->dev), MINOR(__entry->dev),
2796                   __entry->agno,
2797                   __entry->i1_startblock,
2798                   __entry->i1_blockcount,
2799                   __entry->i1_refcount,
2800                   __entry->i2_startblock,
2801                   __entry->i2_blockcount,
2802                   __entry->i2_refcount)
2803 )
2804
2805 #define DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(name) \
2806 DEFINE_EVENT(xfs_refcount_double_extent_class, name, \
2807         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2808                  struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2), \
2809         TP_ARGS(mp, agno, i1, i2))
2810
2811 /* double-rcext and an agbno tracepoint class */
2812 DECLARE_EVENT_CLASS(xfs_refcount_double_extent_at_class,
2813         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2814                  struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2,
2815                  xfs_agblock_t agbno),
2816         TP_ARGS(mp, agno, i1, i2, agbno),
2817         TP_STRUCT__entry(
2818                 __field(dev_t, dev)
2819                 __field(xfs_agnumber_t, agno)
2820                 __field(xfs_agblock_t, i1_startblock)
2821                 __field(xfs_extlen_t, i1_blockcount)
2822                 __field(xfs_nlink_t, i1_refcount)
2823                 __field(xfs_agblock_t, i2_startblock)
2824                 __field(xfs_extlen_t, i2_blockcount)
2825                 __field(xfs_nlink_t, i2_refcount)
2826                 __field(xfs_agblock_t, agbno)
2827         ),
2828         TP_fast_assign(
2829                 __entry->dev = mp->m_super->s_dev;
2830                 __entry->agno = agno;
2831                 __entry->i1_startblock = i1->rc_startblock;
2832                 __entry->i1_blockcount = i1->rc_blockcount;
2833                 __entry->i1_refcount = i1->rc_refcount;
2834                 __entry->i2_startblock = i2->rc_startblock;
2835                 __entry->i2_blockcount = i2->rc_blockcount;
2836                 __entry->i2_refcount = i2->rc_refcount;
2837                 __entry->agbno = agbno;
2838         ),
2839         TP_printk("dev %d:%d agno %u agbno %u len %u refcount %u -- "
2840                   "agbno %u len %u refcount %u @ agbno %u\n",
2841                   MAJOR(__entry->dev), MINOR(__entry->dev),
2842                   __entry->agno,
2843                   __entry->i1_startblock,
2844                   __entry->i1_blockcount,
2845                   __entry->i1_refcount,
2846                   __entry->i2_startblock,
2847                   __entry->i2_blockcount,
2848                   __entry->i2_refcount,
2849                   __entry->agbno)
2850 )
2851
2852 #define DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(name) \
2853 DEFINE_EVENT(xfs_refcount_double_extent_at_class, name, \
2854         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2855                  struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2, \
2856                  xfs_agblock_t agbno), \
2857         TP_ARGS(mp, agno, i1, i2, agbno))
2858
2859 /* triple-rcext tracepoint class */
2860 DECLARE_EVENT_CLASS(xfs_refcount_triple_extent_class,
2861         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2862                  struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2,
2863                  struct xfs_refcount_irec *i3),
2864         TP_ARGS(mp, agno, i1, i2, i3),
2865         TP_STRUCT__entry(
2866                 __field(dev_t, dev)
2867                 __field(xfs_agnumber_t, agno)
2868                 __field(xfs_agblock_t, i1_startblock)
2869                 __field(xfs_extlen_t, i1_blockcount)
2870                 __field(xfs_nlink_t, i1_refcount)
2871                 __field(xfs_agblock_t, i2_startblock)
2872                 __field(xfs_extlen_t, i2_blockcount)
2873                 __field(xfs_nlink_t, i2_refcount)
2874                 __field(xfs_agblock_t, i3_startblock)
2875                 __field(xfs_extlen_t, i3_blockcount)
2876                 __field(xfs_nlink_t, i3_refcount)
2877         ),
2878         TP_fast_assign(
2879                 __entry->dev = mp->m_super->s_dev;
2880                 __entry->agno = agno;
2881                 __entry->i1_startblock = i1->rc_startblock;
2882                 __entry->i1_blockcount = i1->rc_blockcount;
2883                 __entry->i1_refcount = i1->rc_refcount;
2884                 __entry->i2_startblock = i2->rc_startblock;
2885                 __entry->i2_blockcount = i2->rc_blockcount;
2886                 __entry->i2_refcount = i2->rc_refcount;
2887                 __entry->i3_startblock = i3->rc_startblock;
2888                 __entry->i3_blockcount = i3->rc_blockcount;
2889                 __entry->i3_refcount = i3->rc_refcount;
2890         ),
2891         TP_printk("dev %d:%d agno %u agbno %u len %u refcount %u -- "
2892                   "agbno %u len %u refcount %u -- "
2893                   "agbno %u len %u refcount %u\n",
2894                   MAJOR(__entry->dev), MINOR(__entry->dev),
2895                   __entry->agno,
2896                   __entry->i1_startblock,
2897                   __entry->i1_blockcount,
2898                   __entry->i1_refcount,
2899                   __entry->i2_startblock,
2900                   __entry->i2_blockcount,
2901                   __entry->i2_refcount,
2902                   __entry->i3_startblock,
2903                   __entry->i3_blockcount,
2904                   __entry->i3_refcount)
2905 );
2906
2907 #define DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(name) \
2908 DEFINE_EVENT(xfs_refcount_triple_extent_class, name, \
2909         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
2910                  struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2, \
2911                  struct xfs_refcount_irec *i3), \
2912         TP_ARGS(mp, agno, i1, i2, i3))
2913
2914 /* refcount btree tracepoints */
2915 DEFINE_BUSY_EVENT(xfs_refcountbt_alloc_block);
2916 DEFINE_BUSY_EVENT(xfs_refcountbt_free_block);
2917 DEFINE_AG_BTREE_LOOKUP_EVENT(xfs_refcount_lookup);
2918 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_get);
2919 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_update);
2920 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_insert);
2921 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_delete);
2922 DEFINE_AG_ERROR_EVENT(xfs_refcount_insert_error);
2923 DEFINE_AG_ERROR_EVENT(xfs_refcount_delete_error);
2924 DEFINE_AG_ERROR_EVENT(xfs_refcount_update_error);
2925
2926 /* refcount adjustment tracepoints */
2927 DEFINE_AG_EXTENT_EVENT(xfs_refcount_increase);
2928 DEFINE_AG_EXTENT_EVENT(xfs_refcount_decrease);
2929 DEFINE_AG_EXTENT_EVENT(xfs_refcount_cow_increase);
2930 DEFINE_AG_EXTENT_EVENT(xfs_refcount_cow_decrease);
2931 DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(xfs_refcount_merge_center_extents);
2932 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_modify_extent);
2933 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_recover_extent);
2934 DEFINE_REFCOUNT_EXTENT_AT_EVENT(xfs_refcount_split_extent);
2935 DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_left_extent);
2936 DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_right_extent);
2937 DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_left_extent);
2938 DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_right_extent);
2939 DEFINE_AG_ERROR_EVENT(xfs_refcount_adjust_error);
2940 DEFINE_AG_ERROR_EVENT(xfs_refcount_adjust_cow_error);
2941 DEFINE_AG_ERROR_EVENT(xfs_refcount_merge_center_extents_error);
2942 DEFINE_AG_ERROR_EVENT(xfs_refcount_modify_extent_error);
2943 DEFINE_AG_ERROR_EVENT(xfs_refcount_split_extent_error);
2944 DEFINE_AG_ERROR_EVENT(xfs_refcount_merge_left_extent_error);
2945 DEFINE_AG_ERROR_EVENT(xfs_refcount_merge_right_extent_error);
2946 DEFINE_AG_ERROR_EVENT(xfs_refcount_find_left_extent_error);
2947 DEFINE_AG_ERROR_EVENT(xfs_refcount_find_right_extent_error);
2948
2949 /* reflink helpers */
2950 DEFINE_AG_EXTENT_EVENT(xfs_refcount_find_shared);
2951 DEFINE_AG_EXTENT_EVENT(xfs_refcount_find_shared_result);
2952 DEFINE_AG_ERROR_EVENT(xfs_refcount_find_shared_error);
2953 #define DEFINE_REFCOUNT_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT
2954 DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_defer);
2955 DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_deferred);
2956
2957 TRACE_EVENT(xfs_refcount_finish_one_leftover,
2958         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
2959                  int type, xfs_agblock_t agbno, xfs_extlen_t len,
2960                  xfs_agblock_t new_agbno, xfs_extlen_t new_len),
2961         TP_ARGS(mp, agno, type, agbno, len, new_agbno, new_len),
2962         TP_STRUCT__entry(
2963                 __field(dev_t, dev)
2964                 __field(xfs_agnumber_t, agno)
2965                 __field(int, type)
2966                 __field(xfs_agblock_t, agbno)
2967                 __field(xfs_extlen_t, len)
2968                 __field(xfs_agblock_t, new_agbno)
2969                 __field(xfs_extlen_t, new_len)
2970         ),
2971         TP_fast_assign(
2972                 __entry->dev = mp->m_super->s_dev;
2973                 __entry->agno = agno;
2974                 __entry->type = type;
2975                 __entry->agbno = agbno;
2976                 __entry->len = len;
2977                 __entry->new_agbno = new_agbno;
2978                 __entry->new_len = new_len;
2979         ),
2980         TP_printk("dev %d:%d type %d agno %u agbno %u len %u new_agbno %u new_len %u",
2981                   MAJOR(__entry->dev), MINOR(__entry->dev),
2982                   __entry->type,
2983                   __entry->agno,
2984                   __entry->agbno,
2985                   __entry->len,
2986                   __entry->new_agbno,
2987                   __entry->new_len)
2988 );
2989
2990 /* simple inode-based error/%ip tracepoint class */
2991 DECLARE_EVENT_CLASS(xfs_inode_error_class,
2992         TP_PROTO(struct xfs_inode *ip, int error, unsigned long caller_ip),
2993         TP_ARGS(ip, error, caller_ip),
2994         TP_STRUCT__entry(
2995                 __field(dev_t, dev)
2996                 __field(xfs_ino_t, ino)
2997                 __field(int, error)
2998                 __field(unsigned long, caller_ip)
2999         ),
3000         TP_fast_assign(
3001                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
3002                 __entry->ino = ip->i_ino;
3003                 __entry->error = error;
3004                 __entry->caller_ip = caller_ip;
3005         ),
3006         TP_printk("dev %d:%d ino %llx error %d caller %ps",
3007                   MAJOR(__entry->dev), MINOR(__entry->dev),
3008                   __entry->ino,
3009                   __entry->error,
3010                   (char *)__entry->caller_ip)
3011 );
3012
3013 #define DEFINE_INODE_ERROR_EVENT(name) \
3014 DEFINE_EVENT(xfs_inode_error_class, name, \
3015         TP_PROTO(struct xfs_inode *ip, int error, \
3016                  unsigned long caller_ip), \
3017         TP_ARGS(ip, error, caller_ip))
3018
3019 /* reflink allocator */
3020 TRACE_EVENT(xfs_bmap_remap_alloc,
3021         TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t fsbno,
3022                  xfs_extlen_t len),
3023         TP_ARGS(ip, fsbno, len),
3024         TP_STRUCT__entry(
3025                 __field(dev_t, dev)
3026                 __field(xfs_ino_t, ino)
3027                 __field(xfs_fsblock_t, fsbno)
3028                 __field(xfs_extlen_t, len)
3029         ),
3030         TP_fast_assign(
3031                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
3032                 __entry->ino = ip->i_ino;
3033                 __entry->fsbno = fsbno;
3034                 __entry->len = len;
3035         ),
3036         TP_printk("dev %d:%d ino 0x%llx fsbno 0x%llx len %x",
3037                   MAJOR(__entry->dev), MINOR(__entry->dev),
3038                   __entry->ino,
3039                   __entry->fsbno,
3040                   __entry->len)
3041 );
3042 DEFINE_INODE_ERROR_EVENT(xfs_bmap_remap_alloc_error);
3043
3044 /* reflink tracepoint classes */
3045
3046 /* two-file io tracepoint class */
3047 DECLARE_EVENT_CLASS(xfs_double_io_class,
3048         TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len,
3049                  struct xfs_inode *dest, xfs_off_t doffset),
3050         TP_ARGS(src, soffset, len, dest, doffset),
3051         TP_STRUCT__entry(
3052                 __field(dev_t, dev)
3053                 __field(xfs_ino_t, src_ino)
3054                 __field(loff_t, src_isize)
3055                 __field(loff_t, src_disize)
3056                 __field(loff_t, src_offset)
3057                 __field(size_t, len)
3058                 __field(xfs_ino_t, dest_ino)
3059                 __field(loff_t, dest_isize)
3060                 __field(loff_t, dest_disize)
3061                 __field(loff_t, dest_offset)
3062         ),
3063         TP_fast_assign(
3064                 __entry->dev = VFS_I(src)->i_sb->s_dev;
3065                 __entry->src_ino = src->i_ino;
3066                 __entry->src_isize = VFS_I(src)->i_size;
3067                 __entry->src_disize = src->i_d.di_size;
3068                 __entry->src_offset = soffset;
3069                 __entry->len = len;
3070                 __entry->dest_ino = dest->i_ino;
3071                 __entry->dest_isize = VFS_I(dest)->i_size;
3072                 __entry->dest_disize = dest->i_d.di_size;
3073                 __entry->dest_offset = doffset;
3074         ),
3075         TP_printk("dev %d:%d count %zd "
3076                   "ino 0x%llx isize 0x%llx disize 0x%llx offset 0x%llx -> "
3077                   "ino 0x%llx isize 0x%llx disize 0x%llx offset 0x%llx",
3078                   MAJOR(__entry->dev), MINOR(__entry->dev),
3079                   __entry->len,
3080                   __entry->src_ino,
3081                   __entry->src_isize,
3082                   __entry->src_disize,
3083                   __entry->src_offset,
3084                   __entry->dest_ino,
3085                   __entry->dest_isize,
3086                   __entry->dest_disize,
3087                   __entry->dest_offset)
3088 )
3089
3090 #define DEFINE_DOUBLE_IO_EVENT(name)    \
3091 DEFINE_EVENT(xfs_double_io_class, name, \
3092         TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len, \
3093                  struct xfs_inode *dest, xfs_off_t doffset), \
3094         TP_ARGS(src, soffset, len, dest, doffset))
3095
3096 /* two-file vfs io tracepoint class */
3097 DECLARE_EVENT_CLASS(xfs_double_vfs_io_class,
3098         TP_PROTO(struct inode *src, u64 soffset, u64 len,
3099                  struct inode *dest, u64 doffset),
3100         TP_ARGS(src, soffset, len, dest, doffset),
3101         TP_STRUCT__entry(
3102                 __field(dev_t, dev)
3103                 __field(unsigned long, src_ino)
3104                 __field(loff_t, src_isize)
3105                 __field(loff_t, src_offset)
3106                 __field(size_t, len)
3107                 __field(unsigned long, dest_ino)
3108                 __field(loff_t, dest_isize)
3109                 __field(loff_t, dest_offset)
3110         ),
3111         TP_fast_assign(
3112                 __entry->dev = src->i_sb->s_dev;
3113                 __entry->src_ino = src->i_ino;
3114                 __entry->src_isize = i_size_read(src);
3115                 __entry->src_offset = soffset;
3116                 __entry->len = len;
3117                 __entry->dest_ino = dest->i_ino;
3118                 __entry->dest_isize = i_size_read(dest);
3119                 __entry->dest_offset = doffset;
3120         ),
3121         TP_printk("dev %d:%d count %zd "
3122                   "ino 0x%lx isize 0x%llx offset 0x%llx -> "
3123                   "ino 0x%lx isize 0x%llx offset 0x%llx",
3124                   MAJOR(__entry->dev), MINOR(__entry->dev),
3125                   __entry->len,
3126                   __entry->src_ino,
3127                   __entry->src_isize,
3128                   __entry->src_offset,
3129                   __entry->dest_ino,
3130                   __entry->dest_isize,
3131                   __entry->dest_offset)
3132 )
3133
3134 #define DEFINE_DOUBLE_VFS_IO_EVENT(name)        \
3135 DEFINE_EVENT(xfs_double_vfs_io_class, name,     \
3136         TP_PROTO(struct inode *src, u64 soffset, u64 len, \
3137                  struct inode *dest, u64 doffset), \
3138         TP_ARGS(src, soffset, len, dest, doffset))
3139
3140 /* CoW write tracepoint */
3141 DECLARE_EVENT_CLASS(xfs_copy_on_write_class,
3142         TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk, xfs_fsblock_t pblk,
3143                  xfs_extlen_t len, xfs_fsblock_t new_pblk),
3144         TP_ARGS(ip, lblk, pblk, len, new_pblk),
3145         TP_STRUCT__entry(
3146                 __field(dev_t, dev)
3147                 __field(xfs_ino_t, ino)
3148                 __field(xfs_fileoff_t, lblk)
3149                 __field(xfs_fsblock_t, pblk)
3150                 __field(xfs_extlen_t, len)
3151                 __field(xfs_fsblock_t, new_pblk)
3152         ),
3153         TP_fast_assign(
3154                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
3155                 __entry->ino = ip->i_ino;
3156                 __entry->lblk = lblk;
3157                 __entry->pblk = pblk;
3158                 __entry->len = len;
3159                 __entry->new_pblk = new_pblk;
3160         ),
3161         TP_printk("dev %d:%d ino 0x%llx lblk 0x%llx pblk 0x%llx "
3162                   "len 0x%x new_pblk %llu",
3163                   MAJOR(__entry->dev), MINOR(__entry->dev),
3164                   __entry->ino,
3165                   __entry->lblk,
3166                   __entry->pblk,
3167                   __entry->len,
3168                   __entry->new_pblk)
3169 )
3170
3171 #define DEFINE_COW_EVENT(name)  \
3172 DEFINE_EVENT(xfs_copy_on_write_class, name,     \
3173         TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk, xfs_fsblock_t pblk, \
3174                  xfs_extlen_t len, xfs_fsblock_t new_pblk), \
3175         TP_ARGS(ip, lblk, pblk, len, new_pblk))
3176
3177 /* inode/irec events */
3178 DECLARE_EVENT_CLASS(xfs_inode_irec_class,
3179         TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec),
3180         TP_ARGS(ip, irec),
3181         TP_STRUCT__entry(
3182                 __field(dev_t, dev)
3183                 __field(xfs_ino_t, ino)
3184                 __field(xfs_fileoff_t, lblk)
3185                 __field(xfs_extlen_t, len)
3186                 __field(xfs_fsblock_t, pblk)
3187         ),
3188         TP_fast_assign(
3189                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
3190                 __entry->ino = ip->i_ino;
3191                 __entry->lblk = irec->br_startoff;
3192                 __entry->len = irec->br_blockcount;
3193                 __entry->pblk = irec->br_startblock;
3194         ),
3195         TP_printk("dev %d:%d ino 0x%llx lblk 0x%llx len 0x%x pblk %llu",
3196                   MAJOR(__entry->dev), MINOR(__entry->dev),
3197                   __entry->ino,
3198                   __entry->lblk,
3199                   __entry->len,
3200                   __entry->pblk)
3201 );
3202 #define DEFINE_INODE_IREC_EVENT(name) \
3203 DEFINE_EVENT(xfs_inode_irec_class, name, \
3204         TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec), \
3205         TP_ARGS(ip, irec))
3206
3207 /* refcount/reflink tracepoint definitions */
3208
3209 /* reflink tracepoints */
3210 DEFINE_INODE_EVENT(xfs_reflink_set_inode_flag);
3211 DEFINE_INODE_EVENT(xfs_reflink_unset_inode_flag);
3212 DEFINE_ITRUNC_EVENT(xfs_reflink_update_inode_size);
3213 DEFINE_IOMAP_EVENT(xfs_reflink_remap_imap);
3214 TRACE_EVENT(xfs_reflink_remap_blocks_loop,
3215         TP_PROTO(struct xfs_inode *src, xfs_fileoff_t soffset,
3216                  xfs_filblks_t len, struct xfs_inode *dest,
3217                  xfs_fileoff_t doffset),
3218         TP_ARGS(src, soffset, len, dest, doffset),
3219         TP_STRUCT__entry(
3220                 __field(dev_t, dev)
3221                 __field(xfs_ino_t, src_ino)
3222                 __field(xfs_fileoff_t, src_lblk)
3223                 __field(xfs_filblks_t, len)
3224                 __field(xfs_ino_t, dest_ino)
3225                 __field(xfs_fileoff_t, dest_lblk)
3226         ),
3227         TP_fast_assign(
3228                 __entry->dev = VFS_I(src)->i_sb->s_dev;
3229                 __entry->src_ino = src->i_ino;
3230                 __entry->src_lblk = soffset;
3231                 __entry->len = len;
3232                 __entry->dest_ino = dest->i_ino;
3233                 __entry->dest_lblk = doffset;
3234         ),
3235         TP_printk("dev %d:%d len 0x%llx "
3236                   "ino 0x%llx offset 0x%llx blocks -> "
3237                   "ino 0x%llx offset 0x%llx blocks",
3238                   MAJOR(__entry->dev), MINOR(__entry->dev),
3239                   __entry->len,
3240                   __entry->src_ino,
3241                   __entry->src_lblk,
3242                   __entry->dest_ino,
3243                   __entry->dest_lblk)
3244 );
3245 TRACE_EVENT(xfs_reflink_punch_range,
3246         TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk,
3247                  xfs_extlen_t len),
3248         TP_ARGS(ip, lblk, len),
3249         TP_STRUCT__entry(
3250                 __field(dev_t, dev)
3251                 __field(xfs_ino_t, ino)
3252                 __field(xfs_fileoff_t, lblk)
3253                 __field(xfs_extlen_t, len)
3254         ),
3255         TP_fast_assign(
3256                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
3257                 __entry->ino = ip->i_ino;
3258                 __entry->lblk = lblk;
3259                 __entry->len = len;
3260         ),
3261         TP_printk("dev %d:%d ino 0x%llx lblk 0x%llx len 0x%x",
3262                   MAJOR(__entry->dev), MINOR(__entry->dev),
3263                   __entry->ino,
3264                   __entry->lblk,
3265                   __entry->len)
3266 );
3267 TRACE_EVENT(xfs_reflink_remap,
3268         TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t lblk,
3269                  xfs_extlen_t len, xfs_fsblock_t new_pblk),
3270         TP_ARGS(ip, lblk, len, new_pblk),
3271         TP_STRUCT__entry(
3272                 __field(dev_t, dev)
3273                 __field(xfs_ino_t, ino)
3274                 __field(xfs_fileoff_t, lblk)
3275                 __field(xfs_extlen_t, len)
3276                 __field(xfs_fsblock_t, new_pblk)
3277         ),
3278         TP_fast_assign(
3279                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
3280                 __entry->ino = ip->i_ino;
3281                 __entry->lblk = lblk;
3282                 __entry->len = len;
3283                 __entry->new_pblk = new_pblk;
3284         ),
3285         TP_printk("dev %d:%d ino 0x%llx lblk 0x%llx len 0x%x new_pblk %llu",
3286                   MAJOR(__entry->dev), MINOR(__entry->dev),
3287                   __entry->ino,
3288                   __entry->lblk,
3289                   __entry->len,
3290                   __entry->new_pblk)
3291 );
3292 DEFINE_DOUBLE_IO_EVENT(xfs_reflink_remap_range);
3293 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_range_error);
3294 DEFINE_INODE_ERROR_EVENT(xfs_reflink_set_inode_flag_error);
3295 DEFINE_INODE_ERROR_EVENT(xfs_reflink_update_inode_size_error);
3296 DEFINE_INODE_ERROR_EVENT(xfs_reflink_reflink_main_loop_error);
3297 DEFINE_INODE_ERROR_EVENT(xfs_reflink_read_iomap_error);
3298 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_blocks_error);
3299 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_extent_error);
3300
3301 /* dedupe tracepoints */
3302 DEFINE_DOUBLE_IO_EVENT(xfs_reflink_compare_extents);
3303 DEFINE_INODE_ERROR_EVENT(xfs_reflink_compare_extents_error);
3304
3305 /* ioctl tracepoints */
3306 DEFINE_DOUBLE_VFS_IO_EVENT(xfs_ioctl_reflink);
3307 DEFINE_DOUBLE_VFS_IO_EVENT(xfs_ioctl_clone_range);
3308 DEFINE_DOUBLE_VFS_IO_EVENT(xfs_ioctl_file_extent_same);
3309 TRACE_EVENT(xfs_ioctl_clone,
3310         TP_PROTO(struct inode *src, struct inode *dest),
3311         TP_ARGS(src, dest),
3312         TP_STRUCT__entry(
3313                 __field(dev_t, dev)
3314                 __field(unsigned long, src_ino)
3315                 __field(loff_t, src_isize)
3316                 __field(unsigned long, dest_ino)
3317                 __field(loff_t, dest_isize)
3318         ),
3319         TP_fast_assign(
3320                 __entry->dev = src->i_sb->s_dev;
3321                 __entry->src_ino = src->i_ino;
3322                 __entry->src_isize = i_size_read(src);
3323                 __entry->dest_ino = dest->i_ino;
3324                 __entry->dest_isize = i_size_read(dest);
3325         ),
3326         TP_printk("dev %d:%d "
3327                   "ino 0x%lx isize 0x%llx -> "
3328                   "ino 0x%lx isize 0x%llx\n",
3329                   MAJOR(__entry->dev), MINOR(__entry->dev),
3330                   __entry->src_ino,
3331                   __entry->src_isize,
3332                   __entry->dest_ino,
3333                   __entry->dest_isize)
3334 );
3335
3336 /* unshare tracepoints */
3337 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_unshare);
3338 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_cow_eof_block);
3339 DEFINE_PAGE_EVENT(xfs_reflink_unshare_page);
3340 DEFINE_INODE_ERROR_EVENT(xfs_reflink_unshare_error);
3341 DEFINE_INODE_ERROR_EVENT(xfs_reflink_cow_eof_block_error);
3342 DEFINE_INODE_ERROR_EVENT(xfs_reflink_dirty_page_error);
3343
3344 /* copy on write */
3345 DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_around_shared);
3346 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_alloc);
3347 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_found);
3348 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_enospc);
3349
3350 DEFINE_RW_EVENT(xfs_reflink_reserve_cow_range);
3351 DEFINE_RW_EVENT(xfs_reflink_allocate_cow_range);
3352
3353 DEFINE_INODE_IREC_EVENT(xfs_reflink_bounce_dio_write);
3354 DEFINE_IOMAP_EVENT(xfs_reflink_find_cow_mapping);
3355 DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_irec);
3356
3357 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_cancel_cow_range);
3358 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_end_cow);
3359 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap);
3360 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_piece);
3361
3362 DEFINE_INODE_ERROR_EVENT(xfs_reflink_reserve_cow_range_error);
3363 DEFINE_INODE_ERROR_EVENT(xfs_reflink_allocate_cow_range_error);
3364 DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_cow_range_error);
3365 DEFINE_INODE_ERROR_EVENT(xfs_reflink_end_cow_error);
3366
3367 DEFINE_COW_EVENT(xfs_reflink_fork_buf);
3368 DEFINE_COW_EVENT(xfs_reflink_finish_fork_buf);
3369 DEFINE_INODE_ERROR_EVENT(xfs_reflink_fork_buf_error);
3370 DEFINE_INODE_ERROR_EVENT(xfs_reflink_finish_fork_buf_error);
3371
3372 DEFINE_INODE_EVENT(xfs_reflink_cancel_pending_cow);
3373 DEFINE_INODE_IREC_EVENT(xfs_reflink_cancel_cow);
3374 DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_pending_cow_error);
3375
3376 /* rmap swapext tracepoints */
3377 DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap);
3378 DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap_piece);
3379 DEFINE_INODE_ERROR_EVENT(xfs_swap_extent_rmap_error);
3380
3381 #endif /* _TRACE_XFS_H */
3382
3383 #undef TRACE_INCLUDE_PATH
3384 #define TRACE_INCLUDE_PATH .
3385 #define TRACE_INCLUDE_FILE xfs_trace
3386 #include <trace/define_trace.h>