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