fs/xfs/scrub/trace.h

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2017-2023 Oracle.  All Rights Reserved.
   4  * Author: Darrick J. Wong <djwong@kernel.org>
   5  *
   6  * NOTE: none of these tracepoints shall be considered a stable kernel ABI
   7  * as they can change at any time.  See xfs_trace.h for documentation of
   8  * specific units found in tracepoint output.
   9  */
  10 #undef TRACE_SYSTEM
  11 #define TRACE_SYSTEM xfs_scrub
  12
  13 #if !defined(_TRACE_XFS_SCRUB_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
  14 #define _TRACE_XFS_SCRUB_TRACE_H
  15
  16 #include <linux/tracepoint.h>
  17 #include "xfs_bit.h"
  18 #include "xfs_quota_defs.h"
  19
  20 struct xfs_scrub;
  21 struct xfile;
  22 struct xfarray;
  23 struct xfarray_sortinfo;
  24 struct xchk_dqiter;
  25 struct xchk_iscan;
  26 struct xchk_nlink;
  27 struct xchk_fscounters;
  28 struct xfs_rmap_update_params;
  29
  30 /*
  31  * ftrace's __print_symbolic requires that all enum values be wrapped in the
  32  * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace
  33  * ring buffer.  Somehow this was only worth mentioning in the ftrace sample
  34  * code.
  35  */
  36 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED);
  37 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW);
  38
  39 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PROBE);
  40 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SB);
  41 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGF);
  42 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGFL);
  43 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGI);
  44 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BNOBT);
  45 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_CNTBT);
  46 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INOBT);
  47 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FINOBT);
  48 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RMAPBT);
  49 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_REFCNTBT);
  50 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INODE);
  51 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTD);
  52 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTA);
  53 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTC);
  54 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_DIR);
  55 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_XATTR);
  56 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SYMLINK);
  57 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PARENT);
  58 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTBITMAP);
  59 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTSUM);
  60 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_UQUOTA);
  61 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_GQUOTA);
  62 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PQUOTA);
  63 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FSCOUNTERS);
  64 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_QUOTACHECK);
  65 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_NLINKS);
  66 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_HEALTHY);
  67
  68 #define XFS_SCRUB_TYPE_STRINGS \
  69         { XFS_SCRUB_TYPE_PROBE,         "probe" }, \
  70         { XFS_SCRUB_TYPE_SB,            "sb" }, \
  71         { XFS_SCRUB_TYPE_AGF,           "agf" }, \
  72         { XFS_SCRUB_TYPE_AGFL,          "agfl" }, \
  73         { XFS_SCRUB_TYPE_AGI,           "agi" }, \
  74         { XFS_SCRUB_TYPE_BNOBT,         "bnobt" }, \
  75         { XFS_SCRUB_TYPE_CNTBT,         "cntbt" }, \
  76         { XFS_SCRUB_TYPE_INOBT,         "inobt" }, \
  77         { XFS_SCRUB_TYPE_FINOBT,        "finobt" }, \
  78         { XFS_SCRUB_TYPE_RMAPBT,        "rmapbt" }, \
  79         { XFS_SCRUB_TYPE_REFCNTBT,      "refcountbt" }, \
  80         { XFS_SCRUB_TYPE_INODE,         "inode" }, \
  81         { XFS_SCRUB_TYPE_BMBTD,         "bmapbtd" }, \
  82         { XFS_SCRUB_TYPE_BMBTA,         "bmapbta" }, \
  83         { XFS_SCRUB_TYPE_BMBTC,         "bmapbtc" }, \
  84         { XFS_SCRUB_TYPE_DIR,           "directory" }, \
  85         { XFS_SCRUB_TYPE_XATTR,         "xattr" }, \
  86         { XFS_SCRUB_TYPE_SYMLINK,       "symlink" }, \
  87         { XFS_SCRUB_TYPE_PARENT,        "parent" }, \
  88         { XFS_SCRUB_TYPE_RTBITMAP,      "rtbitmap" }, \
  89         { XFS_SCRUB_TYPE_RTSUM,         "rtsummary" }, \
  90         { XFS_SCRUB_TYPE_UQUOTA,        "usrquota" }, \
  91         { XFS_SCRUB_TYPE_GQUOTA,        "grpquota" }, \
  92         { XFS_SCRUB_TYPE_PQUOTA,        "prjquota" }, \
  93         { XFS_SCRUB_TYPE_FSCOUNTERS,    "fscounters" }, \
  94         { XFS_SCRUB_TYPE_QUOTACHECK,    "quotacheck" }, \
  95         { XFS_SCRUB_TYPE_NLINKS,        "nlinks" }, \
  96         { XFS_SCRUB_TYPE_HEALTHY,       "healthy" }
  97
  98 #define XFS_SCRUB_FLAG_STRINGS \
  99         { XFS_SCRUB_IFLAG_REPAIR,               "repair" }, \
 100         { XFS_SCRUB_OFLAG_CORRUPT,              "corrupt" }, \
 101         { XFS_SCRUB_OFLAG_PREEN,                "preen" }, \
 102         { XFS_SCRUB_OFLAG_XFAIL,                "xfail" }, \
 103         { XFS_SCRUB_OFLAG_XCORRUPT,             "xcorrupt" }, \
 104         { XFS_SCRUB_OFLAG_INCOMPLETE,           "incomplete" }, \
 105         { XFS_SCRUB_OFLAG_WARNING,              "warning" }, \
 106         { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED,     "norepair" }, \
 107         { XFS_SCRUB_IFLAG_FORCE_REBUILD,        "rebuild" }
 108
 109 #define XFS_SCRUB_STATE_STRINGS \
 110         { XCHK_TRY_HARDER,                      "try_harder" }, \
 111         { XCHK_HAVE_FREEZE_PROT,                "nofreeze" }, \
 112         { XCHK_FSGATES_DRAIN,                   "fsgates_drain" }, \
 113         { XCHK_NEED_DRAIN,                      "need_drain" }, \
 114         { XCHK_FSGATES_QUOTA,                   "fsgates_quota" }, \
 115         { XCHK_FSGATES_DIRENTS,                 "fsgates_dirents" }, \
 116         { XCHK_FSGATES_RMAP,                    "fsgates_rmap" }, \
 117         { XREP_FSGATES_EXCHANGE_RANGE,          "fsgates_exchrange" }, \
 118         { XREP_RESET_PERAG_RESV,                "reset_perag_resv" }, \
 119         { XREP_ALREADY_FIXED,                   "already_fixed" }
 120
 121 TRACE_DEFINE_ENUM(XFS_RMAP_MAP);
 122 TRACE_DEFINE_ENUM(XFS_RMAP_MAP_SHARED);
 123 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP);
 124 TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP_SHARED);
 125 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT);
 126 TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT_SHARED);
 127 TRACE_DEFINE_ENUM(XFS_RMAP_ALLOC);
 128 TRACE_DEFINE_ENUM(XFS_RMAP_FREE);
 129
 130 DECLARE_EVENT_CLASS(xchk_class,
 131         TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm,
 132                  int error),
 133         TP_ARGS(ip, sm, error),
 134         TP_STRUCT__entry(
 135                 __field(dev_t, dev)
 136                 __field(xfs_ino_t, ino)
 137                 __field(unsigned int, type)
 138                 __field(xfs_agnumber_t, agno)
 139                 __field(xfs_ino_t, inum)
 140                 __field(unsigned int, gen)
 141                 __field(unsigned int, flags)
 142                 __field(int, error)
 143         ),
 144         TP_fast_assign(
 145                 __entry->dev = ip->i_mount->m_super->s_dev;
 146                 __entry->ino = ip->i_ino;
 147                 __entry->type = sm->sm_type;
 148                 __entry->agno = sm->sm_agno;
 149                 __entry->inum = sm->sm_ino;
 150                 __entry->gen = sm->sm_gen;
 151                 __entry->flags = sm->sm_flags;
 152                 __entry->error = error;
 153         ),
 154         TP_printk("dev %d:%d ino 0x%llx type %s agno 0x%x inum 0x%llx gen 0x%x flags (%s) error %d",
 155                   MAJOR(__entry->dev), MINOR(__entry->dev),
 156                   __entry->ino,
 157                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 158                   __entry->agno,
 159                   __entry->inum,
 160                   __entry->gen,
 161                   __print_flags(__entry->flags, "|", XFS_SCRUB_FLAG_STRINGS),
 162                   __entry->error)
 163 )
 164 #define DEFINE_SCRUB_EVENT(name) \
 165 DEFINE_EVENT(xchk_class, name, \
 166         TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, \
 167                  int error), \
 168         TP_ARGS(ip, sm, error))
 169
 170 DEFINE_SCRUB_EVENT(xchk_start);
 171 DEFINE_SCRUB_EVENT(xchk_done);
 172 DEFINE_SCRUB_EVENT(xchk_deadlock_retry);
 173 DEFINE_SCRUB_EVENT(xrep_attempt);
 174 DEFINE_SCRUB_EVENT(xrep_done);
 175
 176 DECLARE_EVENT_CLASS(xchk_fsgate_class,
 177         TP_PROTO(struct xfs_scrub *sc, unsigned int fsgate_flags),
 178         TP_ARGS(sc, fsgate_flags),
 179         TP_STRUCT__entry(
 180                 __field(dev_t, dev)
 181                 __field(unsigned int, type)
 182                 __field(unsigned int, fsgate_flags)
 183         ),
 184         TP_fast_assign(
 185                 __entry->dev = sc->mp->m_super->s_dev;
 186                 __entry->type = sc->sm->sm_type;
 187                 __entry->fsgate_flags = fsgate_flags;
 188         ),
 189         TP_printk("dev %d:%d type %s fsgates '%s'",
 190                   MAJOR(__entry->dev), MINOR(__entry->dev),
 191                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 192                   __print_flags(__entry->fsgate_flags, "|", XFS_SCRUB_STATE_STRINGS))
 193 )
 194
 195 #define DEFINE_SCRUB_FSHOOK_EVENT(name) \
 196 DEFINE_EVENT(xchk_fsgate_class, name, \
 197         TP_PROTO(struct xfs_scrub *sc, unsigned int fsgates_flags), \
 198         TP_ARGS(sc, fsgates_flags))
 199
 200 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_enable);
 201 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_disable);
 202
 203 TRACE_EVENT(xchk_op_error,
 204         TP_PROTO(struct xfs_scrub *sc, xfs_agnumber_t agno,
 205                  xfs_agblock_t bno, int error, void *ret_ip),
 206         TP_ARGS(sc, agno, bno, error, ret_ip),
 207         TP_STRUCT__entry(
 208                 __field(dev_t, dev)
 209                 __field(unsigned int, type)
 210                 __field(xfs_agnumber_t, agno)
 211                 __field(xfs_agblock_t, bno)
 212                 __field(int, error)
 213                 __field(void *, ret_ip)
 214         ),
 215         TP_fast_assign(
 216                 __entry->dev = sc->mp->m_super->s_dev;
 217                 __entry->type = sc->sm->sm_type;
 218                 __entry->agno = agno;
 219                 __entry->bno = bno;
 220                 __entry->error = error;
 221                 __entry->ret_ip = ret_ip;
 222         ),
 223         TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x error %d ret_ip %pS",
 224                   MAJOR(__entry->dev), MINOR(__entry->dev),
 225                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 226                   __entry->agno,
 227                   __entry->bno,
 228                   __entry->error,
 229                   __entry->ret_ip)
 230 );
 231
 232 TRACE_EVENT(xchk_file_op_error,
 233         TP_PROTO(struct xfs_scrub *sc, int whichfork,
 234                  xfs_fileoff_t offset, int error, void *ret_ip),
 235         TP_ARGS(sc, whichfork, offset, error, ret_ip),
 236         TP_STRUCT__entry(
 237                 __field(dev_t, dev)
 238                 __field(xfs_ino_t, ino)
 239                 __field(int, whichfork)
 240                 __field(unsigned int, type)
 241                 __field(xfs_fileoff_t, offset)
 242                 __field(int, error)
 243                 __field(void *, ret_ip)
 244         ),
 245         TP_fast_assign(
 246                 __entry->dev = sc->ip->i_mount->m_super->s_dev;
 247                 __entry->ino = sc->ip->i_ino;
 248                 __entry->whichfork = whichfork;
 249                 __entry->type = sc->sm->sm_type;
 250                 __entry->offset = offset;
 251                 __entry->error = error;
 252                 __entry->ret_ip = ret_ip;
 253         ),
 254         TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx error %d ret_ip %pS",
 255                   MAJOR(__entry->dev), MINOR(__entry->dev),
 256                   __entry->ino,
 257                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 258                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 259                   __entry->offset,
 260                   __entry->error,
 261                   __entry->ret_ip)
 262 );
 263
 264 DECLARE_EVENT_CLASS(xchk_block_error_class,
 265         TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, void *ret_ip),
 266         TP_ARGS(sc, daddr, ret_ip),
 267         TP_STRUCT__entry(
 268                 __field(dev_t, dev)
 269                 __field(unsigned int, type)
 270                 __field(xfs_agnumber_t, agno)
 271                 __field(xfs_agblock_t, agbno)
 272                 __field(void *, ret_ip)
 273         ),
 274         TP_fast_assign(
 275                 __entry->dev = sc->mp->m_super->s_dev;
 276                 __entry->type = sc->sm->sm_type;
 277                 __entry->agno = xfs_daddr_to_agno(sc->mp, daddr);
 278                 __entry->agbno = xfs_daddr_to_agbno(sc->mp, daddr);
 279                 __entry->ret_ip = ret_ip;
 280         ),
 281         TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x ret_ip %pS",
 282                   MAJOR(__entry->dev), MINOR(__entry->dev),
 283                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 284                   __entry->agno,
 285                   __entry->agbno,
 286                   __entry->ret_ip)
 287 )
 288
 289 #define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \
 290 DEFINE_EVENT(xchk_block_error_class, name, \
 291         TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, \
 292                  void *ret_ip), \
 293         TP_ARGS(sc, daddr, ret_ip))
 294
 295 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_fs_error);
 296 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_error);
 297 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_preen);
 298
 299 DECLARE_EVENT_CLASS(xchk_ino_error_class,
 300         TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, void *ret_ip),
 301         TP_ARGS(sc, ino, ret_ip),
 302         TP_STRUCT__entry(
 303                 __field(dev_t, dev)
 304                 __field(xfs_ino_t, ino)
 305                 __field(unsigned int, type)
 306                 __field(void *, ret_ip)
 307         ),
 308         TP_fast_assign(
 309                 __entry->dev = sc->mp->m_super->s_dev;
 310                 __entry->ino = ino;
 311                 __entry->type = sc->sm->sm_type;
 312                 __entry->ret_ip = ret_ip;
 313         ),
 314         TP_printk("dev %d:%d ino 0x%llx type %s ret_ip %pS",
 315                   MAJOR(__entry->dev), MINOR(__entry->dev),
 316                   __entry->ino,
 317                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 318                   __entry->ret_ip)
 319 )
 320
 321 #define DEFINE_SCRUB_INO_ERROR_EVENT(name) \
 322 DEFINE_EVENT(xchk_ino_error_class, name, \
 323         TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, \
 324                  void *ret_ip), \
 325         TP_ARGS(sc, ino, ret_ip))
 326
 327 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_error);
 328 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_preen);
 329 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_warning);
 330
 331 DECLARE_EVENT_CLASS(xchk_fblock_error_class,
 332         TP_PROTO(struct xfs_scrub *sc, int whichfork,
 333                  xfs_fileoff_t offset, void *ret_ip),
 334         TP_ARGS(sc, whichfork, offset, ret_ip),
 335         TP_STRUCT__entry(
 336                 __field(dev_t, dev)
 337                 __field(xfs_ino_t, ino)
 338                 __field(int, whichfork)
 339                 __field(unsigned int, type)
 340                 __field(xfs_fileoff_t, offset)
 341                 __field(void *, ret_ip)
 342         ),
 343         TP_fast_assign(
 344                 __entry->dev = sc->ip->i_mount->m_super->s_dev;
 345                 __entry->ino = sc->ip->i_ino;
 346                 __entry->whichfork = whichfork;
 347                 __entry->type = sc->sm->sm_type;
 348                 __entry->offset = offset;
 349                 __entry->ret_ip = ret_ip;
 350         ),
 351         TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx ret_ip %pS",
 352                   MAJOR(__entry->dev), MINOR(__entry->dev),
 353                   __entry->ino,
 354                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 355                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 356                   __entry->offset,
 357                   __entry->ret_ip)
 358 );
 359
 360 #define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \
 361 DEFINE_EVENT(xchk_fblock_error_class, name, \
 362         TP_PROTO(struct xfs_scrub *sc, int whichfork, \
 363                  xfs_fileoff_t offset, void *ret_ip), \
 364         TP_ARGS(sc, whichfork, offset, ret_ip))
 365
 366 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_error);
 367 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_warning);
 368 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_preen);
 369
 370 #ifdef CONFIG_XFS_QUOTA
 371 DECLARE_EVENT_CLASS(xchk_dqiter_class,
 372         TP_PROTO(struct xchk_dqiter *cursor, uint64_t id),
 373         TP_ARGS(cursor, id),
 374         TP_STRUCT__entry(
 375                 __field(dev_t, dev)
 376                 __field(xfs_dqtype_t, dqtype)
 377                 __field(xfs_ino_t, ino)
 378                 __field(unsigned long long, cur_id)
 379                 __field(unsigned long long, id)
 380                 __field(xfs_fileoff_t, startoff)
 381                 __field(xfs_fsblock_t, startblock)
 382                 __field(xfs_filblks_t, blockcount)
 383                 __field(xfs_exntst_t, state)
 384         ),
 385         TP_fast_assign(
 386                 __entry->dev = cursor->sc->ip->i_mount->m_super->s_dev;
 387                 __entry->dqtype = cursor->dqtype;
 388                 __entry->ino = cursor->quota_ip->i_ino;
 389                 __entry->cur_id = cursor->id;
 390                 __entry->startoff = cursor->bmap.br_startoff;
 391                 __entry->startblock = cursor->bmap.br_startblock;
 392                 __entry->blockcount = cursor->bmap.br_blockcount;
 393                 __entry->state = cursor->bmap.br_state;
 394                 __entry->id = id;
 395         ),
 396         TP_printk("dev %d:%d dquot type %s ino 0x%llx cursor_id 0x%llx startoff 0x%llx startblock 0x%llx blockcount 0x%llx state %u id 0x%llx",
 397                   MAJOR(__entry->dev), MINOR(__entry->dev),
 398                   __print_symbolic(__entry->dqtype, XFS_DQTYPE_STRINGS),
 399                   __entry->ino,
 400                   __entry->cur_id,
 401                   __entry->startoff,
 402                   __entry->startblock,
 403                   __entry->blockcount,
 404                   __entry->state,
 405                   __entry->id)
 406 );
 407
 408 #define DEFINE_SCRUB_DQITER_EVENT(name) \
 409 DEFINE_EVENT(xchk_dqiter_class, name, \
 410         TP_PROTO(struct xchk_dqiter *cursor, uint64_t id), \
 411         TP_ARGS(cursor, id))
 412 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_revalidate_bmap);
 413 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_advance_bmap);
 414 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter_advance_incore);
 415 DEFINE_SCRUB_DQITER_EVENT(xchk_dquot_iter);
 416
 417 TRACE_EVENT(xchk_qcheck_error,
 418         TP_PROTO(struct xfs_scrub *sc, xfs_dqtype_t dqtype, xfs_dqid_t id,
 419                  void *ret_ip),
 420         TP_ARGS(sc, dqtype, id, ret_ip),
 421         TP_STRUCT__entry(
 422                 __field(dev_t, dev)
 423                 __field(xfs_dqtype_t, dqtype)
 424                 __field(xfs_dqid_t, id)
 425                 __field(void *, ret_ip)
 426         ),
 427         TP_fast_assign(
 428                 __entry->dev = sc->mp->m_super->s_dev;
 429                 __entry->dqtype = dqtype;
 430                 __entry->id = id;
 431                 __entry->ret_ip = ret_ip;
 432         ),
 433         TP_printk("dev %d:%d dquot type %s id 0x%x ret_ip %pS",
 434                   MAJOR(__entry->dev), MINOR(__entry->dev),
 435                   __print_symbolic(__entry->dqtype, XFS_DQTYPE_STRINGS),
 436                   __entry->id,
 437                   __entry->ret_ip)
 438 );
 439 #endif /* CONFIG_XFS_QUOTA */
 440
 441 TRACE_EVENT(xchk_incomplete,
 442         TP_PROTO(struct xfs_scrub *sc, void *ret_ip),
 443         TP_ARGS(sc, ret_ip),
 444         TP_STRUCT__entry(
 445                 __field(dev_t, dev)
 446                 __field(unsigned int, type)
 447                 __field(void *, ret_ip)
 448         ),
 449         TP_fast_assign(
 450                 __entry->dev = sc->mp->m_super->s_dev;
 451                 __entry->type = sc->sm->sm_type;
 452                 __entry->ret_ip = ret_ip;
 453         ),
 454         TP_printk("dev %d:%d type %s ret_ip %pS",
 455                   MAJOR(__entry->dev), MINOR(__entry->dev),
 456                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 457                   __entry->ret_ip)
 458 );
 459
 460 TRACE_EVENT(xchk_btree_op_error,
 461         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 462                  int level, int error, void *ret_ip),
 463         TP_ARGS(sc, cur, level, error, ret_ip),
 464         TP_STRUCT__entry(
 465                 __field(dev_t, dev)
 466                 __field(unsigned int, type)
 467                 __string(name, cur->bc_ops->name)
 468                 __field(int, level)
 469                 __field(xfs_agnumber_t, agno)
 470                 __field(xfs_agblock_t, bno)
 471                 __field(int, ptr)
 472                 __field(int, error)
 473                 __field(void *, ret_ip)
 474         ),
 475         TP_fast_assign(
 476                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 477
 478                 __entry->dev = sc->mp->m_super->s_dev;
 479                 __entry->type = sc->sm->sm_type;
 480                 __assign_str(name, cur->bc_ops->name);
 481                 __entry->level = level;
 482                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 483                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 484                 __entry->ptr = cur->bc_levels[level].ptr;
 485                 __entry->error = error;
 486                 __entry->ret_ip = ret_ip;
 487         ),
 488         TP_printk("dev %d:%d type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS",
 489                   MAJOR(__entry->dev), MINOR(__entry->dev),
 490                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 491                   __get_str(name),
 492                   __entry->level,
 493                   __entry->ptr,
 494                   __entry->agno,
 495                   __entry->bno,
 496                   __entry->error,
 497                   __entry->ret_ip)
 498 );
 499
 500 TRACE_EVENT(xchk_ifork_btree_op_error,
 501         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 502                  int level, int error, void *ret_ip),
 503         TP_ARGS(sc, cur, level, error, ret_ip),
 504         TP_STRUCT__entry(
 505                 __field(dev_t, dev)
 506                 __field(xfs_ino_t, ino)
 507                 __field(int, whichfork)
 508                 __field(unsigned int, type)
 509                 __string(name, cur->bc_ops->name)
 510                 __field(int, level)
 511                 __field(int, ptr)
 512                 __field(xfs_agnumber_t, agno)
 513                 __field(xfs_agblock_t, bno)
 514                 __field(int, error)
 515                 __field(void *, ret_ip)
 516         ),
 517         TP_fast_assign(
 518                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 519                 __entry->dev = sc->mp->m_super->s_dev;
 520                 __entry->ino = sc->ip->i_ino;
 521                 __entry->whichfork = cur->bc_ino.whichfork;
 522                 __entry->type = sc->sm->sm_type;
 523                 __assign_str(name, cur->bc_ops->name);
 524                 __entry->level = level;
 525                 __entry->ptr = cur->bc_levels[level].ptr;
 526                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 527                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 528                 __entry->error = error;
 529                 __entry->ret_ip = ret_ip;
 530         ),
 531         TP_printk("dev %d:%d ino 0x%llx fork %s type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS",
 532                   MAJOR(__entry->dev), MINOR(__entry->dev),
 533                   __entry->ino,
 534                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 535                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 536                   __get_str(name),
 537                   __entry->level,
 538                   __entry->ptr,
 539                   __entry->agno,
 540                   __entry->bno,
 541                   __entry->error,
 542                   __entry->ret_ip)
 543 );
 544
 545 TRACE_EVENT(xchk_btree_error,
 546         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 547                  int level, void *ret_ip),
 548         TP_ARGS(sc, cur, level, ret_ip),
 549         TP_STRUCT__entry(
 550                 __field(dev_t, dev)
 551                 __field(unsigned int, type)
 552                 __string(name, cur->bc_ops->name)
 553                 __field(int, level)
 554                 __field(xfs_agnumber_t, agno)
 555                 __field(xfs_agblock_t, bno)
 556                 __field(int, ptr)
 557                 __field(void *, ret_ip)
 558         ),
 559         TP_fast_assign(
 560                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 561                 __entry->dev = sc->mp->m_super->s_dev;
 562                 __entry->type = sc->sm->sm_type;
 563                 __assign_str(name, cur->bc_ops->name);
 564                 __entry->level = level;
 565                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 566                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 567                 __entry->ptr = cur->bc_levels[level].ptr;
 568                 __entry->ret_ip = ret_ip;
 569         ),
 570         TP_printk("dev %d:%d type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS",
 571                   MAJOR(__entry->dev), MINOR(__entry->dev),
 572                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 573                   __get_str(name),
 574                   __entry->level,
 575                   __entry->ptr,
 576                   __entry->agno,
 577                   __entry->bno,
 578                   __entry->ret_ip)
 579 );
 580
 581 TRACE_EVENT(xchk_ifork_btree_error,
 582         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 583                  int level, void *ret_ip),
 584         TP_ARGS(sc, cur, level, ret_ip),
 585         TP_STRUCT__entry(
 586                 __field(dev_t, dev)
 587                 __field(xfs_ino_t, ino)
 588                 __field(int, whichfork)
 589                 __field(unsigned int, type)
 590                 __string(name, cur->bc_ops->name)
 591                 __field(int, level)
 592                 __field(xfs_agnumber_t, agno)
 593                 __field(xfs_agblock_t, bno)
 594                 __field(int, ptr)
 595                 __field(void *, ret_ip)
 596         ),
 597         TP_fast_assign(
 598                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 599                 __entry->dev = sc->mp->m_super->s_dev;
 600                 __entry->ino = sc->ip->i_ino;
 601                 __entry->whichfork = cur->bc_ino.whichfork;
 602                 __entry->type = sc->sm->sm_type;
 603                 __assign_str(name, cur->bc_ops->name);
 604                 __entry->level = level;
 605                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 606                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 607                 __entry->ptr = cur->bc_levels[level].ptr;
 608                 __entry->ret_ip = ret_ip;
 609         ),
 610         TP_printk("dev %d:%d ino 0x%llx fork %s type %s %sbt level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS",
 611                   MAJOR(__entry->dev), MINOR(__entry->dev),
 612                   __entry->ino,
 613                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 614                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 615                   __get_str(name),
 616                   __entry->level,
 617                   __entry->ptr,
 618                   __entry->agno,
 619                   __entry->bno,
 620                   __entry->ret_ip)
 621 );
 622
 623 DECLARE_EVENT_CLASS(xchk_sbtree_class,
 624         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 625                  int level),
 626         TP_ARGS(sc, cur, level),
 627         TP_STRUCT__entry(
 628                 __field(dev_t, dev)
 629                 __field(int, type)
 630                 __string(name, cur->bc_ops->name)
 631                 __field(xfs_agnumber_t, agno)
 632                 __field(xfs_agblock_t, bno)
 633                 __field(int, level)
 634                 __field(int, nlevels)
 635                 __field(int, ptr)
 636         ),
 637         TP_fast_assign(
 638                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 639
 640                 __entry->dev = sc->mp->m_super->s_dev;
 641                 __entry->type = sc->sm->sm_type;
 642                 __assign_str(name, cur->bc_ops->name);
 643                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 644                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 645                 __entry->level = level;
 646                 __entry->nlevels = cur->bc_nlevels;
 647                 __entry->ptr = cur->bc_levels[level].ptr;
 648         ),
 649         TP_printk("dev %d:%d type %s %sbt agno 0x%x agbno 0x%x level %d nlevels %d ptr %d",
 650                   MAJOR(__entry->dev), MINOR(__entry->dev),
 651                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 652                   __get_str(name),
 653                   __entry->agno,
 654                   __entry->bno,
 655                   __entry->level,
 656                   __entry->nlevels,
 657                   __entry->ptr)
 658 )
 659 #define DEFINE_SCRUB_SBTREE_EVENT(name) \
 660 DEFINE_EVENT(xchk_sbtree_class, name, \
 661         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, \
 662                  int level), \
 663         TP_ARGS(sc, cur, level))
 664
 665 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_rec);
 666 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_key);
 667
 668 TRACE_EVENT(xchk_xref_error,
 669         TP_PROTO(struct xfs_scrub *sc, int error, void *ret_ip),
 670         TP_ARGS(sc, error, ret_ip),
 671         TP_STRUCT__entry(
 672                 __field(dev_t, dev)
 673                 __field(int, type)
 674                 __field(int, error)
 675                 __field(void *, ret_ip)
 676         ),
 677         TP_fast_assign(
 678                 __entry->dev = sc->mp->m_super->s_dev;
 679                 __entry->type = sc->sm->sm_type;
 680                 __entry->error = error;
 681                 __entry->ret_ip = ret_ip;
 682         ),
 683         TP_printk("dev %d:%d type %s xref error %d ret_ip %pS",
 684                   MAJOR(__entry->dev), MINOR(__entry->dev),
 685                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 686                   __entry->error,
 687                   __entry->ret_ip)
 688 );
 689
 690 TRACE_EVENT(xchk_iallocbt_check_cluster,
 691         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
 692                  xfs_agino_t startino, xfs_daddr_t map_daddr,
 693                  unsigned short map_len, unsigned int chunk_ino,
 694                  unsigned int nr_inodes, uint16_t cluster_mask,
 695                  uint16_t holemask, unsigned int cluster_ino),
 696         TP_ARGS(mp, agno, startino, map_daddr, map_len, chunk_ino, nr_inodes,
 697                 cluster_mask, holemask, cluster_ino),
 698         TP_STRUCT__entry(
 699                 __field(dev_t, dev)
 700                 __field(xfs_agnumber_t, agno)
 701                 __field(xfs_agino_t, startino)
 702                 __field(xfs_daddr_t, map_daddr)
 703                 __field(unsigned short, map_len)
 704                 __field(unsigned int, chunk_ino)
 705                 __field(unsigned int, nr_inodes)
 706                 __field(unsigned int, cluster_ino)
 707                 __field(uint16_t, cluster_mask)
 708                 __field(uint16_t, holemask)
 709         ),
 710         TP_fast_assign(
 711                 __entry->dev = mp->m_super->s_dev;
 712                 __entry->agno = agno;
 713                 __entry->startino = startino;
 714                 __entry->map_daddr = map_daddr;
 715                 __entry->map_len = map_len;
 716                 __entry->chunk_ino = chunk_ino;
 717                 __entry->nr_inodes = nr_inodes;
 718                 __entry->cluster_mask = cluster_mask;
 719                 __entry->holemask = holemask;
 720                 __entry->cluster_ino = cluster_ino;
 721         ),
 722         TP_printk("dev %d:%d agno 0x%x startino 0x%x daddr 0x%llx bbcount 0x%x chunkino 0x%x nr_inodes %u cluster_mask 0x%x holemask 0x%x cluster_ino 0x%x",
 723                   MAJOR(__entry->dev), MINOR(__entry->dev),
 724                   __entry->agno,
 725                   __entry->startino,
 726                   __entry->map_daddr,
 727                   __entry->map_len,
 728                   __entry->chunk_ino,
 729                   __entry->nr_inodes,
 730                   __entry->cluster_mask,
 731                   __entry->holemask,
 732                   __entry->cluster_ino)
 733 )
 734
 735 TRACE_EVENT(xchk_inode_is_allocated,
 736         TP_PROTO(struct xfs_inode *ip),
 737         TP_ARGS(ip),
 738         TP_STRUCT__entry(
 739                 __field(dev_t, dev)
 740                 __field(xfs_ino_t, ino)
 741                 __field(unsigned long, iflags)
 742                 __field(umode_t, mode)
 743         ),
 744         TP_fast_assign(
 745                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
 746                 __entry->ino = ip->i_ino;
 747                 __entry->iflags = ip->i_flags;
 748                 __entry->mode = VFS_I(ip)->i_mode;
 749         ),
 750         TP_printk("dev %d:%d ino 0x%llx iflags 0x%lx mode 0x%x",
 751                   MAJOR(__entry->dev), MINOR(__entry->dev),
 752                   __entry->ino,
 753                   __entry->iflags,
 754                   __entry->mode)
 755 );
 756
 757 TRACE_EVENT(xchk_fscounters_calc,
 758         TP_PROTO(struct xfs_mount *mp, uint64_t icount, uint64_t ifree,
 759                  uint64_t fdblocks, uint64_t delalloc),
 760         TP_ARGS(mp, icount, ifree, fdblocks, delalloc),
 761         TP_STRUCT__entry(
 762                 __field(dev_t, dev)
 763                 __field(int64_t, icount_sb)
 764                 __field(uint64_t, icount_calculated)
 765                 __field(int64_t, ifree_sb)
 766                 __field(uint64_t, ifree_calculated)
 767                 __field(int64_t, fdblocks_sb)
 768                 __field(uint64_t, fdblocks_calculated)
 769                 __field(uint64_t, delalloc)
 770         ),
 771         TP_fast_assign(
 772                 __entry->dev = mp->m_super->s_dev;
 773                 __entry->icount_sb = mp->m_sb.sb_icount;
 774                 __entry->icount_calculated = icount;
 775                 __entry->ifree_sb = mp->m_sb.sb_ifree;
 776                 __entry->ifree_calculated = ifree;
 777                 __entry->fdblocks_sb = mp->m_sb.sb_fdblocks;
 778                 __entry->fdblocks_calculated = fdblocks;
 779                 __entry->delalloc = delalloc;
 780         ),
 781         TP_printk("dev %d:%d icount %lld:%llu ifree %lld::%llu fdblocks %lld::%llu delalloc %llu",
 782                   MAJOR(__entry->dev), MINOR(__entry->dev),
 783                   __entry->icount_sb,
 784                   __entry->icount_calculated,
 785                   __entry->ifree_sb,
 786                   __entry->ifree_calculated,
 787                   __entry->fdblocks_sb,
 788                   __entry->fdblocks_calculated,
 789                   __entry->delalloc)
 790 )
 791
 792 TRACE_EVENT(xchk_fscounters_within_range,
 793         TP_PROTO(struct xfs_mount *mp, uint64_t expected, int64_t curr_value,
 794                  int64_t old_value),
 795         TP_ARGS(mp, expected, curr_value, old_value),
 796         TP_STRUCT__entry(
 797                 __field(dev_t, dev)
 798                 __field(uint64_t, expected)
 799                 __field(int64_t, curr_value)
 800                 __field(int64_t, old_value)
 801         ),
 802         TP_fast_assign(
 803                 __entry->dev = mp->m_super->s_dev;
 804                 __entry->expected = expected;
 805                 __entry->curr_value = curr_value;
 806                 __entry->old_value = old_value;
 807         ),
 808         TP_printk("dev %d:%d expected %llu curr_value %lld old_value %lld",
 809                   MAJOR(__entry->dev), MINOR(__entry->dev),
 810                   __entry->expected,
 811                   __entry->curr_value,
 812                   __entry->old_value)
 813 )
 814
 815 DECLARE_EVENT_CLASS(xchk_fsfreeze_class,
 816         TP_PROTO(struct xfs_scrub *sc, int error),
 817         TP_ARGS(sc, error),
 818         TP_STRUCT__entry(
 819                 __field(dev_t, dev)
 820                 __field(unsigned int, type)
 821                 __field(int, error)
 822         ),
 823         TP_fast_assign(
 824                 __entry->dev = sc->mp->m_super->s_dev;
 825                 __entry->type = sc->sm->sm_type;
 826                 __entry->error = error;
 827         ),
 828         TP_printk("dev %d:%d type %s error %d",
 829                   MAJOR(__entry->dev), MINOR(__entry->dev),
 830                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 831                   __entry->error)
 832 );
 833 #define DEFINE_XCHK_FSFREEZE_EVENT(name) \
 834 DEFINE_EVENT(xchk_fsfreeze_class, name, \
 835         TP_PROTO(struct xfs_scrub *sc, int error), \
 836         TP_ARGS(sc, error))
 837 DEFINE_XCHK_FSFREEZE_EVENT(xchk_fsfreeze);
 838 DEFINE_XCHK_FSFREEZE_EVENT(xchk_fsthaw);
 839
 840 TRACE_EVENT(xchk_refcount_incorrect,
 841         TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *irec,
 842                  xfs_nlink_t seen),
 843         TP_ARGS(pag, irec, seen),
 844         TP_STRUCT__entry(
 845                 __field(dev_t, dev)
 846                 __field(xfs_agnumber_t, agno)
 847                 __field(enum xfs_refc_domain, domain)
 848                 __field(xfs_agblock_t, startblock)
 849                 __field(xfs_extlen_t, blockcount)
 850                 __field(xfs_nlink_t, refcount)
 851                 __field(xfs_nlink_t, seen)
 852         ),
 853         TP_fast_assign(
 854                 __entry->dev = pag->pag_mount->m_super->s_dev;
 855                 __entry->agno = pag->pag_agno;
 856                 __entry->domain = irec->rc_domain;
 857                 __entry->startblock = irec->rc_startblock;
 858                 __entry->blockcount = irec->rc_blockcount;
 859                 __entry->refcount = irec->rc_refcount;
 860                 __entry->seen = seen;
 861         ),
 862         TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u seen %u",
 863                   MAJOR(__entry->dev), MINOR(__entry->dev),
 864                   __entry->agno,
 865                   __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS),
 866                   __entry->startblock,
 867                   __entry->blockcount,
 868                   __entry->refcount,
 869                   __entry->seen)
 870 )
 871
 872 TRACE_EVENT(xfile_create,
 873         TP_PROTO(struct xfile *xf),
 874         TP_ARGS(xf),
 875         TP_STRUCT__entry(
 876                 __field(dev_t, dev)
 877                 __field(unsigned long, ino)
 878                 __array(char, pathname, 256)
 879         ),
 880         TP_fast_assign(
 881                 char            pathname[257];
 882                 char            *path;
 883
 884                 __entry->ino = file_inode(xf->file)->i_ino;
 885                 memset(pathname, 0, sizeof(pathname));
 886                 path = file_path(xf->file, pathname, sizeof(pathname) - 1);
 887                 if (IS_ERR(path))
 888                         path = "(unknown)";
 889                 strncpy(__entry->pathname, path, sizeof(__entry->pathname));
 890         ),
 891         TP_printk("xfino 0x%lx path '%s'",
 892                   __entry->ino,
 893                   __entry->pathname)
 894 );
 895
 896 TRACE_EVENT(xfile_destroy,
 897         TP_PROTO(struct xfile *xf),
 898         TP_ARGS(xf),
 899         TP_STRUCT__entry(
 900                 __field(unsigned long, ino)
 901                 __field(unsigned long long, bytes)
 902                 __field(loff_t, size)
 903         ),
 904         TP_fast_assign(
 905                 struct inode            *inode = file_inode(xf->file);
 906
 907                 __entry->ino = inode->i_ino;
 908                 __entry->bytes = inode->i_blocks << SECTOR_SHIFT;
 909                 __entry->size = i_size_read(inode);
 910         ),
 911         TP_printk("xfino 0x%lx mem_bytes 0x%llx isize 0x%llx",
 912                   __entry->ino,
 913                   __entry->bytes,
 914                   __entry->size)
 915 );
 916
 917 DECLARE_EVENT_CLASS(xfile_class,
 918         TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount),
 919         TP_ARGS(xf, pos, bytecount),
 920         TP_STRUCT__entry(
 921                 __field(unsigned long, ino)
 922                 __field(unsigned long long, bytes_used)
 923                 __field(loff_t, pos)
 924                 __field(loff_t, size)
 925                 __field(unsigned long long, bytecount)
 926         ),
 927         TP_fast_assign(
 928                 struct inode            *inode = file_inode(xf->file);
 929
 930                 __entry->ino = inode->i_ino;
 931                 __entry->bytes_used = inode->i_blocks << SECTOR_SHIFT;
 932                 __entry->pos = pos;
 933                 __entry->size = i_size_read(inode);
 934                 __entry->bytecount = bytecount;
 935         ),
 936         TP_printk("xfino 0x%lx mem_bytes 0x%llx pos 0x%llx bytecount 0x%llx isize 0x%llx",
 937                   __entry->ino,
 938                   __entry->bytes_used,
 939                   __entry->pos,
 940                   __entry->bytecount,
 941                   __entry->size)
 942 );
 943 #define DEFINE_XFILE_EVENT(name) \
 944 DEFINE_EVENT(xfile_class, name, \
 945         TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount), \
 946         TP_ARGS(xf, pos, bytecount))
 947 DEFINE_XFILE_EVENT(xfile_load);
 948 DEFINE_XFILE_EVENT(xfile_store);
 949 DEFINE_XFILE_EVENT(xfile_seek_data);
 950 DEFINE_XFILE_EVENT(xfile_get_folio);
 951 DEFINE_XFILE_EVENT(xfile_put_folio);
 952 DEFINE_XFILE_EVENT(xfile_discard);
 953
 954 TRACE_EVENT(xfarray_create,
 955         TP_PROTO(struct xfarray *xfa, unsigned long long required_capacity),
 956         TP_ARGS(xfa, required_capacity),
 957         TP_STRUCT__entry(
 958                 __field(unsigned long, ino)
 959                 __field(uint64_t, max_nr)
 960                 __field(size_t, obj_size)
 961                 __field(int, obj_size_log)
 962                 __field(unsigned long long, required_capacity)
 963         ),
 964         TP_fast_assign(
 965                 __entry->max_nr = xfa->max_nr;
 966                 __entry->obj_size = xfa->obj_size;
 967                 __entry->obj_size_log = xfa->obj_size_log;
 968                 __entry->ino = file_inode(xfa->xfile->file)->i_ino;
 969                 __entry->required_capacity = required_capacity;
 970         ),
 971         TP_printk("xfino 0x%lx max_nr %llu reqd_nr %llu objsz %zu objszlog %d",
 972                   __entry->ino,
 973                   __entry->max_nr,
 974                   __entry->required_capacity,
 975                   __entry->obj_size,
 976                   __entry->obj_size_log)
 977 );
 978
 979 TRACE_EVENT(xfarray_isort,
 980         TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
 981         TP_ARGS(si, lo, hi),
 982         TP_STRUCT__entry(
 983                 __field(unsigned long, ino)
 984                 __field(unsigned long long, lo)
 985                 __field(unsigned long long, hi)
 986         ),
 987         TP_fast_assign(
 988                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
 989                 __entry->lo = lo;
 990                 __entry->hi = hi;
 991         ),
 992         TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu",
 993                   __entry->ino,
 994                   __entry->lo,
 995                   __entry->hi,
 996                   __entry->hi - __entry->lo)
 997 );
 998
 999 TRACE_EVENT(xfarray_foliosort,
1000         TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
1001         TP_ARGS(si, lo, hi),
1002         TP_STRUCT__entry(
1003                 __field(unsigned long, ino)
1004                 __field(unsigned long long, lo)
1005                 __field(unsigned long long, hi)
1006         ),
1007         TP_fast_assign(
1008                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1009                 __entry->lo = lo;
1010                 __entry->hi = hi;
1011         ),
1012         TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu",
1013                   __entry->ino,
1014                   __entry->lo,
1015                   __entry->hi,
1016                   __entry->hi - __entry->lo)
1017 );
1018
1019 TRACE_EVENT(xfarray_qsort,
1020         TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
1021         TP_ARGS(si, lo, hi),
1022         TP_STRUCT__entry(
1023                 __field(unsigned long, ino)
1024                 __field(unsigned long long, lo)
1025                 __field(unsigned long long, hi)
1026                 __field(int, stack_depth)
1027                 __field(int, max_stack_depth)
1028         ),
1029         TP_fast_assign(
1030                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1031                 __entry->lo = lo;
1032                 __entry->hi = hi;
1033                 __entry->stack_depth = si->stack_depth;
1034                 __entry->max_stack_depth = si->max_stack_depth;
1035         ),
1036         TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu stack %d/%d",
1037                   __entry->ino,
1038                   __entry->lo,
1039                   __entry->hi,
1040                   __entry->hi - __entry->lo,
1041                   __entry->stack_depth,
1042                   __entry->max_stack_depth)
1043 );
1044
1045 TRACE_EVENT(xfarray_sort,
1046         TP_PROTO(struct xfarray_sortinfo *si, size_t bytes),
1047         TP_ARGS(si, bytes),
1048         TP_STRUCT__entry(
1049                 __field(unsigned long, ino)
1050                 __field(unsigned long long, nr)
1051                 __field(size_t, obj_size)
1052                 __field(size_t, bytes)
1053                 __field(unsigned int, max_stack_depth)
1054         ),
1055         TP_fast_assign(
1056                 __entry->nr = si->array->nr;
1057                 __entry->obj_size = si->array->obj_size;
1058                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1059                 __entry->bytes = bytes;
1060                 __entry->max_stack_depth = si->max_stack_depth;
1061         ),
1062         TP_printk("xfino 0x%lx nr %llu objsz %zu stack %u bytes %zu",
1063                   __entry->ino,
1064                   __entry->nr,
1065                   __entry->obj_size,
1066                   __entry->max_stack_depth,
1067                   __entry->bytes)
1068 );
1069
1070 TRACE_EVENT(xfarray_sort_scan,
1071         TP_PROTO(struct xfarray_sortinfo *si, unsigned long long idx),
1072         TP_ARGS(si, idx),
1073         TP_STRUCT__entry(
1074                 __field(unsigned long, ino)
1075                 __field(unsigned long long, nr)
1076                 __field(size_t, obj_size)
1077                 __field(unsigned long long, idx)
1078                 __field(unsigned long long, folio_pos)
1079                 __field(unsigned long, folio_bytes)
1080                 __field(unsigned long long, first_idx)
1081                 __field(unsigned long long, last_idx)
1082         ),
1083         TP_fast_assign(
1084                 __entry->nr = si->array->nr;
1085                 __entry->obj_size = si->array->obj_size;
1086                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1087                 __entry->idx = idx;
1088                 if (si->folio) {
1089                         __entry->folio_pos = folio_pos(si->folio);
1090                         __entry->folio_bytes = folio_size(si->folio);
1091                         __entry->first_idx = si->first_folio_idx;
1092                         __entry->last_idx = si->last_folio_idx;
1093                 } else {
1094                         __entry->folio_pos = 0;
1095                         __entry->folio_bytes = 0;
1096                         __entry->first_idx = 0;
1097                         __entry->last_idx = 0;
1098                 }
1099         ),
1100         TP_printk("xfino 0x%lx nr %llu objsz %zu idx %llu folio_pos 0x%llx folio_bytes 0x%lx first_idx %llu last_idx %llu",
1101                   __entry->ino,
1102                   __entry->nr,
1103                   __entry->obj_size,
1104                   __entry->idx,
1105                   __entry->folio_pos,
1106                   __entry->folio_bytes,
1107                   __entry->first_idx,
1108                   __entry->last_idx)
1109 );
1110
1111 TRACE_EVENT(xfarray_sort_stats,
1112         TP_PROTO(struct xfarray_sortinfo *si, int error),
1113         TP_ARGS(si, error),
1114         TP_STRUCT__entry(
1115                 __field(unsigned long, ino)
1116 #ifdef DEBUG
1117                 __field(unsigned long long, loads)
1118                 __field(unsigned long long, stores)
1119                 __field(unsigned long long, compares)
1120                 __field(unsigned long long, heapsorts)
1121 #endif
1122                 __field(unsigned int, max_stack_depth)
1123                 __field(unsigned int, max_stack_used)
1124                 __field(int, error)
1125         ),
1126         TP_fast_assign(
1127                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
1128 #ifdef DEBUG
1129                 __entry->loads = si->loads;
1130                 __entry->stores = si->stores;
1131                 __entry->compares = si->compares;
1132                 __entry->heapsorts = si->heapsorts;
1133 #endif
1134                 __entry->max_stack_depth = si->max_stack_depth;
1135                 __entry->max_stack_used = si->max_stack_used;
1136                 __entry->error = error;
1137         ),
1138         TP_printk(
1139 #ifdef DEBUG
1140                   "xfino 0x%lx loads %llu stores %llu compares %llu heapsorts %llu stack_depth %u/%u error %d",
1141 #else
1142                   "xfino 0x%lx stack_depth %u/%u error %d",
1143 #endif
1144                   __entry->ino,
1145 #ifdef DEBUG
1146                   __entry->loads,
1147                   __entry->stores,
1148                   __entry->compares,
1149                   __entry->heapsorts,
1150 #endif
1151                   __entry->max_stack_used,
1152                   __entry->max_stack_depth,
1153                   __entry->error)
1154 );
1155
1156 #ifdef CONFIG_XFS_RT
1157 TRACE_EVENT(xchk_rtsum_record_free,
1158         TP_PROTO(struct xfs_mount *mp, xfs_rtxnum_t start,
1159                  xfs_rtbxlen_t len, unsigned int log, loff_t pos,
1160                  xfs_suminfo_t value),
1161         TP_ARGS(mp, start, len, log, pos, value),
1162         TP_STRUCT__entry(
1163                 __field(dev_t, dev)
1164                 __field(dev_t, rtdev)
1165                 __field(xfs_rtxnum_t, start)
1166                 __field(unsigned long long, len)
1167                 __field(unsigned int, log)
1168                 __field(loff_t, pos)
1169                 __field(xfs_suminfo_t, value)
1170         ),
1171         TP_fast_assign(
1172                 __entry->dev = mp->m_super->s_dev;
1173                 __entry->rtdev = mp->m_rtdev_targp->bt_dev;
1174                 __entry->start = start;
1175                 __entry->len = len;
1176                 __entry->log = log;
1177                 __entry->pos = pos;
1178                 __entry->value = value;
1179         ),
1180         TP_printk("dev %d:%d rtdev %d:%d rtx 0x%llx rtxcount 0x%llx log %u rsumpos 0x%llx sumcount %u",
1181                   MAJOR(__entry->dev), MINOR(__entry->dev),
1182                   MAJOR(__entry->rtdev), MINOR(__entry->rtdev),
1183                   __entry->start,
1184                   __entry->len,
1185                   __entry->log,
1186                   __entry->pos,
1187                   __entry->value)
1188 );
1189 #endif /* CONFIG_XFS_RT */
1190
1191 DECLARE_EVENT_CLASS(xchk_iscan_class,
1192         TP_PROTO(struct xchk_iscan *iscan),
1193         TP_ARGS(iscan),
1194         TP_STRUCT__entry(
1195                 __field(dev_t, dev)
1196                 __field(xfs_ino_t, cursor)
1197                 __field(xfs_ino_t, visited)
1198         ),
1199         TP_fast_assign(
1200                 __entry->dev = iscan->sc->mp->m_super->s_dev;
1201                 __entry->cursor = iscan->cursor_ino;
1202                 __entry->visited = iscan->__visited_ino;
1203         ),
1204         TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx",
1205                   MAJOR(__entry->dev), MINOR(__entry->dev),
1206                   __entry->cursor,
1207                   __entry->visited)
1208 )
1209 #define DEFINE_ISCAN_EVENT(name) \
1210 DEFINE_EVENT(xchk_iscan_class, name, \
1211         TP_PROTO(struct xchk_iscan *iscan), \
1212         TP_ARGS(iscan))
1213 DEFINE_ISCAN_EVENT(xchk_iscan_move_cursor);
1214 DEFINE_ISCAN_EVENT(xchk_iscan_visit);
1215 DEFINE_ISCAN_EVENT(xchk_iscan_skip);
1216 DEFINE_ISCAN_EVENT(xchk_iscan_advance_ag);
1217
1218 DECLARE_EVENT_CLASS(xchk_iscan_ino_class,
1219         TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino),
1220         TP_ARGS(iscan, ino),
1221         TP_STRUCT__entry(
1222                 __field(dev_t, dev)
1223                 __field(xfs_ino_t, startino)
1224                 __field(xfs_ino_t, cursor)
1225                 __field(xfs_ino_t, visited)
1226                 __field(xfs_ino_t, ino)
1227         ),
1228         TP_fast_assign(
1229                 __entry->dev = iscan->sc->mp->m_super->s_dev;
1230                 __entry->startino = iscan->scan_start_ino;
1231                 __entry->cursor = iscan->cursor_ino;
1232                 __entry->visited = iscan->__visited_ino;
1233                 __entry->ino = ino;
1234         ),
1235         TP_printk("dev %d:%d iscan start 0x%llx cursor 0x%llx visited 0x%llx ino 0x%llx",
1236                   MAJOR(__entry->dev), MINOR(__entry->dev),
1237                   __entry->startino,
1238                   __entry->cursor,
1239                   __entry->visited,
1240                   __entry->ino)
1241 )
1242 #define DEFINE_ISCAN_INO_EVENT(name) \
1243 DEFINE_EVENT(xchk_iscan_ino_class, name, \
1244         TP_PROTO(struct xchk_iscan *iscan, xfs_ino_t ino), \
1245         TP_ARGS(iscan, ino))
1246 DEFINE_ISCAN_INO_EVENT(xchk_iscan_want_live_update);
1247 DEFINE_ISCAN_INO_EVENT(xchk_iscan_start);
1248
1249 TRACE_EVENT(xchk_iscan_iget,
1250         TP_PROTO(struct xchk_iscan *iscan, int error),
1251         TP_ARGS(iscan, error),
1252         TP_STRUCT__entry(
1253                 __field(dev_t, dev)
1254                 __field(xfs_ino_t, cursor)
1255                 __field(xfs_ino_t, visited)
1256                 __field(int, error)
1257         ),
1258         TP_fast_assign(
1259                 __entry->dev = iscan->sc->mp->m_super->s_dev;
1260                 __entry->cursor = iscan->cursor_ino;
1261                 __entry->visited = iscan->__visited_ino;
1262                 __entry->error = error;
1263         ),
1264         TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx error %d",
1265                   MAJOR(__entry->dev), MINOR(__entry->dev),
1266                   __entry->cursor,
1267                   __entry->visited,
1268                   __entry->error)
1269 );
1270
1271 TRACE_EVENT(xchk_iscan_iget_batch,
1272         TP_PROTO(struct xfs_mount *mp, struct xchk_iscan *iscan,
1273                  unsigned int nr, unsigned int avail),
1274         TP_ARGS(mp, iscan, nr, avail),
1275         TP_STRUCT__entry(
1276                 __field(dev_t, dev)
1277                 __field(xfs_ino_t, cursor)
1278                 __field(xfs_ino_t, visited)
1279                 __field(unsigned int, nr)
1280                 __field(unsigned int, avail)
1281                 __field(unsigned int, unavail)
1282                 __field(xfs_ino_t, batch_ino)
1283                 __field(unsigned long long, skipmask)
1284         ),
1285         TP_fast_assign(
1286                 __entry->dev = mp->m_super->s_dev;
1287                 __entry->cursor = iscan->cursor_ino;
1288                 __entry->visited = iscan->__visited_ino;
1289                 __entry->nr = nr;
1290                 __entry->avail = avail;
1291                 __entry->unavail = hweight64(iscan->__skipped_inomask);
1292                 __entry->batch_ino = iscan->__batch_ino;
1293                 __entry->skipmask = iscan->__skipped_inomask;
1294         ),
1295         TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx batchino 0x%llx skipmask 0x%llx nr %u avail %u unavail %u",
1296                   MAJOR(__entry->dev), MINOR(__entry->dev),
1297                   __entry->cursor,
1298                   __entry->visited,
1299                   __entry->batch_ino,
1300                   __entry->skipmask,
1301                   __entry->nr,
1302                   __entry->avail,
1303                   __entry->unavail)
1304 );
1305
1306 DECLARE_EVENT_CLASS(xchk_iscan_retry_wait_class,
1307         TP_PROTO(struct xchk_iscan *iscan),
1308         TP_ARGS(iscan),
1309         TP_STRUCT__entry(
1310                 __field(dev_t, dev)
1311                 __field(xfs_ino_t, cursor)
1312                 __field(xfs_ino_t, visited)
1313                 __field(unsigned int, retry_delay)
1314                 __field(unsigned long, remaining)
1315                 __field(unsigned int, iget_timeout)
1316         ),
1317         TP_fast_assign(
1318                 __entry->dev = iscan->sc->mp->m_super->s_dev;
1319                 __entry->cursor = iscan->cursor_ino;
1320                 __entry->visited = iscan->__visited_ino;
1321                 __entry->retry_delay = iscan->iget_retry_delay;
1322                 __entry->remaining = jiffies_to_msecs(iscan->__iget_deadline - jiffies);
1323                 __entry->iget_timeout = iscan->iget_timeout;
1324         ),
1325         TP_printk("dev %d:%d iscan cursor 0x%llx visited 0x%llx remaining %lu timeout %u delay %u",
1326                   MAJOR(__entry->dev), MINOR(__entry->dev),
1327                   __entry->cursor,
1328                   __entry->visited,
1329                   __entry->remaining,
1330                   __entry->iget_timeout,
1331                   __entry->retry_delay)
1332 )
1333 #define DEFINE_ISCAN_RETRY_WAIT_EVENT(name) \
1334 DEFINE_EVENT(xchk_iscan_retry_wait_class, name, \
1335         TP_PROTO(struct xchk_iscan *iscan), \
1336         TP_ARGS(iscan))
1337 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_iget_retry_wait);
1338 DEFINE_ISCAN_RETRY_WAIT_EVENT(xchk_iscan_agi_retry_wait);
1339
1340 TRACE_EVENT(xchk_nlinks_collect_dirent,
1341         TP_PROTO(struct xfs_mount *mp, struct xfs_inode *dp,
1342                  xfs_ino_t ino, const struct xfs_name *name),
1343         TP_ARGS(mp, dp, ino, name),
1344         TP_STRUCT__entry(
1345                 __field(dev_t, dev)
1346                 __field(xfs_ino_t, dir)
1347                 __field(xfs_ino_t, ino)
1348                 __field(unsigned int, namelen)
1349                 __dynamic_array(char, name, name->len)
1350         ),
1351         TP_fast_assign(
1352                 __entry->dev = mp->m_super->s_dev;
1353                 __entry->dir = dp->i_ino;
1354                 __entry->ino = ino;
1355                 __entry->namelen = name->len;
1356                 memcpy(__get_str(name), name->name, name->len);
1357         ),
1358         TP_printk("dev %d:%d dir 0x%llx -> ino 0x%llx name '%.*s'",
1359                   MAJOR(__entry->dev), MINOR(__entry->dev),
1360                   __entry->dir,
1361                   __entry->ino,
1362                   __entry->namelen,
1363                   __get_str(name))
1364 );
1365
1366 TRACE_EVENT(xchk_nlinks_collect_metafile,
1367         TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino),
1368         TP_ARGS(mp, ino),
1369         TP_STRUCT__entry(
1370                 __field(dev_t, dev)
1371                 __field(xfs_ino_t, ino)
1372         ),
1373         TP_fast_assign(
1374                 __entry->dev = mp->m_super->s_dev;
1375                 __entry->ino = ino;
1376         ),
1377         TP_printk("dev %d:%d ino 0x%llx",
1378                   MAJOR(__entry->dev), MINOR(__entry->dev),
1379                   __entry->ino)
1380 );
1381
1382 TRACE_EVENT(xchk_nlinks_live_update,
1383         TP_PROTO(struct xfs_mount *mp, const struct xfs_inode *dp,
1384                  int action, xfs_ino_t ino, int delta,
1385                  const char *name, unsigned int namelen),
1386         TP_ARGS(mp, dp, action, ino, delta, name, namelen),
1387         TP_STRUCT__entry(
1388                 __field(dev_t, dev)
1389                 __field(xfs_ino_t, dir)
1390                 __field(int, action)
1391                 __field(xfs_ino_t, ino)
1392                 __field(int, delta)
1393                 __field(unsigned int, namelen)
1394                 __dynamic_array(char, name, namelen)
1395         ),
1396         TP_fast_assign(
1397                 __entry->dev = mp->m_super->s_dev;
1398                 __entry->dir = dp ? dp->i_ino : NULLFSINO;
1399                 __entry->action = action;
1400                 __entry->ino = ino;
1401                 __entry->delta = delta;
1402                 __entry->namelen = namelen;
1403                 memcpy(__get_str(name), name, namelen);
1404         ),
1405         TP_printk("dev %d:%d dir 0x%llx ino 0x%llx nlink_delta %d name '%.*s'",
1406                   MAJOR(__entry->dev), MINOR(__entry->dev),
1407                   __entry->dir,
1408                   __entry->ino,
1409                   __entry->delta,
1410                   __entry->namelen,
1411                   __get_str(name))
1412 );
1413
1414 TRACE_EVENT(xchk_nlinks_check_zero,
1415         TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino,
1416                  const struct xchk_nlink *live),
1417         TP_ARGS(mp, ino, live),
1418         TP_STRUCT__entry(
1419                 __field(dev_t, dev)
1420                 __field(xfs_ino_t, ino)
1421                 __field(xfs_nlink_t, parents)
1422                 __field(xfs_nlink_t, backrefs)
1423                 __field(xfs_nlink_t, children)
1424         ),
1425         TP_fast_assign(
1426                 __entry->dev = mp->m_super->s_dev;
1427                 __entry->ino = ino;
1428                 __entry->parents = live->parents;
1429                 __entry->backrefs = live->backrefs;
1430                 __entry->children = live->children;
1431         ),
1432         TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u",
1433                   MAJOR(__entry->dev), MINOR(__entry->dev),
1434                   __entry->ino,
1435                   __entry->parents,
1436                   __entry->backrefs,
1437                   __entry->children)
1438 );
1439
1440 TRACE_EVENT(xchk_nlinks_update_incore,
1441         TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino,
1442                  const struct xchk_nlink *live, int parents_delta,
1443                  int backrefs_delta, int children_delta),
1444         TP_ARGS(mp, ino, live, parents_delta, backrefs_delta, children_delta),
1445         TP_STRUCT__entry(
1446                 __field(dev_t, dev)
1447                 __field(xfs_ino_t, ino)
1448                 __field(xfs_nlink_t, parents)
1449                 __field(xfs_nlink_t, backrefs)
1450                 __field(xfs_nlink_t, children)
1451                 __field(int, parents_delta)
1452                 __field(int, backrefs_delta)
1453                 __field(int, children_delta)
1454         ),
1455         TP_fast_assign(
1456                 __entry->dev = mp->m_super->s_dev;
1457                 __entry->ino = ino;
1458                 __entry->parents = live->parents;
1459                 __entry->backrefs = live->backrefs;
1460                 __entry->children = live->children;
1461                 __entry->parents_delta = parents_delta;
1462                 __entry->backrefs_delta = backrefs_delta;
1463                 __entry->children_delta = children_delta;
1464         ),
1465         TP_printk("dev %d:%d ino 0x%llx parents %d:%u backrefs %d:%u children %d:%u",
1466                   MAJOR(__entry->dev), MINOR(__entry->dev),
1467                   __entry->ino,
1468                   __entry->parents_delta,
1469                   __entry->parents,
1470                   __entry->backrefs_delta,
1471                   __entry->backrefs,
1472                   __entry->children_delta,
1473                   __entry->children)
1474 );
1475
1476 DECLARE_EVENT_CLASS(xchk_nlinks_diff_class,
1477         TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip,
1478                  const struct xchk_nlink *live),
1479         TP_ARGS(mp, ip, live),
1480         TP_STRUCT__entry(
1481                 __field(dev_t, dev)
1482                 __field(xfs_ino_t, ino)
1483                 __field(uint8_t, ftype)
1484                 __field(xfs_nlink_t, nlink)
1485                 __field(xfs_nlink_t, parents)
1486                 __field(xfs_nlink_t, backrefs)
1487                 __field(xfs_nlink_t, children)
1488         ),
1489         TP_fast_assign(
1490                 __entry->dev = mp->m_super->s_dev;
1491                 __entry->ino = ip->i_ino;
1492                 __entry->ftype = xfs_mode_to_ftype(VFS_I(ip)->i_mode);
1493                 __entry->nlink = VFS_I(ip)->i_nlink;
1494                 __entry->parents = live->parents;
1495                 __entry->backrefs = live->backrefs;
1496                 __entry->children = live->children;
1497         ),
1498         TP_printk("dev %d:%d ino 0x%llx ftype %s nlink %u parents %u backrefs %u children %u",
1499                   MAJOR(__entry->dev), MINOR(__entry->dev),
1500                   __entry->ino,
1501                   __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR),
1502                   __entry->nlink,
1503                   __entry->parents,
1504                   __entry->backrefs,
1505                   __entry->children)
1506 );
1507 #define DEFINE_SCRUB_NLINKS_DIFF_EVENT(name) \
1508 DEFINE_EVENT(xchk_nlinks_diff_class, name, \
1509         TP_PROTO(struct xfs_mount *mp, struct xfs_inode *ip, \
1510                  const struct xchk_nlink *live), \
1511         TP_ARGS(mp, ip, live))
1512 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xchk_nlinks_compare_inode);
1513
1514 /* repair tracepoints */
1515 #if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR)
1516
1517 DECLARE_EVENT_CLASS(xrep_extent_class,
1518         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len),
1519         TP_ARGS(pag, agbno, len),
1520         TP_STRUCT__entry(
1521                 __field(dev_t, dev)
1522                 __field(xfs_agnumber_t, agno)
1523                 __field(xfs_agblock_t, agbno)
1524                 __field(xfs_extlen_t, len)
1525         ),
1526         TP_fast_assign(
1527                 __entry->dev = pag->pag_mount->m_super->s_dev;
1528                 __entry->agno = pag->pag_agno;
1529                 __entry->agbno = agbno;
1530                 __entry->len = len;
1531         ),
1532         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
1533                   MAJOR(__entry->dev), MINOR(__entry->dev),
1534                   __entry->agno,
1535                   __entry->agbno,
1536                   __entry->len)
1537 );
1538 #define DEFINE_REPAIR_EXTENT_EVENT(name) \
1539 DEFINE_EVENT(xrep_extent_class, name, \
1540         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), \
1541         TP_ARGS(pag, agbno, len))
1542 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_unmap_extent);
1543 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_free_extent);
1544 DEFINE_REPAIR_EXTENT_EVENT(xreap_agextent_binval);
1545 DEFINE_REPAIR_EXTENT_EVENT(xreap_bmapi_binval);
1546 DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert);
1547
1548 DECLARE_EVENT_CLASS(xrep_reap_find_class,
1549         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len,
1550                 bool crosslinked),
1551         TP_ARGS(pag, agbno, len, crosslinked),
1552         TP_STRUCT__entry(
1553                 __field(dev_t, dev)
1554                 __field(xfs_agnumber_t, agno)
1555                 __field(xfs_agblock_t, agbno)
1556                 __field(xfs_extlen_t, len)
1557                 __field(bool, crosslinked)
1558         ),
1559         TP_fast_assign(
1560                 __entry->dev = pag->pag_mount->m_super->s_dev;
1561                 __entry->agno = pag->pag_agno;
1562                 __entry->agbno = agbno;
1563                 __entry->len = len;
1564                 __entry->crosslinked = crosslinked;
1565         ),
1566         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x crosslinked %d",
1567                   MAJOR(__entry->dev), MINOR(__entry->dev),
1568                   __entry->agno,
1569                   __entry->agbno,
1570                   __entry->len,
1571                   __entry->crosslinked ? 1 : 0)
1572 );
1573 #define DEFINE_REPAIR_REAP_FIND_EVENT(name) \
1574 DEFINE_EVENT(xrep_reap_find_class, name, \
1575         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len, \
1576                  bool crosslinked), \
1577         TP_ARGS(pag, agbno, len, crosslinked))
1578 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_agextent_select);
1579 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_bmapi_select);
1580
1581 DECLARE_EVENT_CLASS(xrep_rmap_class,
1582         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1583                  xfs_agblock_t agbno, xfs_extlen_t len,
1584                  uint64_t owner, uint64_t offset, unsigned int flags),
1585         TP_ARGS(mp, agno, agbno, len, owner, offset, flags),
1586         TP_STRUCT__entry(
1587                 __field(dev_t, dev)
1588                 __field(xfs_agnumber_t, agno)
1589                 __field(xfs_agblock_t, agbno)
1590                 __field(xfs_extlen_t, len)
1591                 __field(uint64_t, owner)
1592                 __field(uint64_t, offset)
1593                 __field(unsigned int, flags)
1594         ),
1595         TP_fast_assign(
1596                 __entry->dev = mp->m_super->s_dev;
1597                 __entry->agno = agno;
1598                 __entry->agbno = agbno;
1599                 __entry->len = len;
1600                 __entry->owner = owner;
1601                 __entry->offset = offset;
1602                 __entry->flags = flags;
1603         ),
1604         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
1605                   MAJOR(__entry->dev), MINOR(__entry->dev),
1606                   __entry->agno,
1607                   __entry->agbno,
1608                   __entry->len,
1609                   __entry->owner,
1610                   __entry->offset,
1611                   __entry->flags)
1612 );
1613 #define DEFINE_REPAIR_RMAP_EVENT(name) \
1614 DEFINE_EVENT(xrep_rmap_class, name, \
1615         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
1616                  xfs_agblock_t agbno, xfs_extlen_t len, \
1617                  uint64_t owner, uint64_t offset, unsigned int flags), \
1618         TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
1619 DEFINE_REPAIR_RMAP_EVENT(xrep_ibt_walk_rmap);
1620 DEFINE_REPAIR_RMAP_EVENT(xrep_bmap_walk_rmap);
1621
1622 TRACE_EVENT(xrep_abt_found,
1623         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1624                  const struct xfs_alloc_rec_incore *rec),
1625         TP_ARGS(mp, agno, rec),
1626         TP_STRUCT__entry(
1627                 __field(dev_t, dev)
1628                 __field(xfs_agnumber_t, agno)
1629                 __field(xfs_agblock_t, startblock)
1630                 __field(xfs_extlen_t, blockcount)
1631         ),
1632         TP_fast_assign(
1633                 __entry->dev = mp->m_super->s_dev;
1634                 __entry->agno = agno;
1635                 __entry->startblock = rec->ar_startblock;
1636                 __entry->blockcount = rec->ar_blockcount;
1637         ),
1638         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
1639                   MAJOR(__entry->dev), MINOR(__entry->dev),
1640                   __entry->agno,
1641                   __entry->startblock,
1642                   __entry->blockcount)
1643 )
1644
1645 TRACE_EVENT(xrep_ibt_found,
1646         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1647                  const struct xfs_inobt_rec_incore *rec),
1648         TP_ARGS(mp, agno, rec),
1649         TP_STRUCT__entry(
1650                 __field(dev_t, dev)
1651                 __field(xfs_agnumber_t, agno)
1652                 __field(xfs_agino_t, startino)
1653                 __field(uint16_t, holemask)
1654                 __field(uint8_t, count)
1655                 __field(uint8_t, freecount)
1656                 __field(uint64_t, freemask)
1657         ),
1658         TP_fast_assign(
1659                 __entry->dev = mp->m_super->s_dev;
1660                 __entry->agno = agno;
1661                 __entry->startino = rec->ir_startino;
1662                 __entry->holemask = rec->ir_holemask;
1663                 __entry->count = rec->ir_count;
1664                 __entry->freecount = rec->ir_freecount;
1665                 __entry->freemask = rec->ir_free;
1666         ),
1667         TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x count 0x%x freecount 0x%x freemask 0x%llx",
1668                   MAJOR(__entry->dev), MINOR(__entry->dev),
1669                   __entry->agno,
1670                   __entry->startino,
1671                   __entry->holemask,
1672                   __entry->count,
1673                   __entry->freecount,
1674                   __entry->freemask)
1675 )
1676
1677 TRACE_EVENT(xrep_refc_found,
1678         TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *rec),
1679         TP_ARGS(pag, rec),
1680         TP_STRUCT__entry(
1681                 __field(dev_t, dev)
1682                 __field(xfs_agnumber_t, agno)
1683                 __field(enum xfs_refc_domain, domain)
1684                 __field(xfs_agblock_t, startblock)
1685                 __field(xfs_extlen_t, blockcount)
1686                 __field(xfs_nlink_t, refcount)
1687         ),
1688         TP_fast_assign(
1689                 __entry->dev = pag->pag_mount->m_super->s_dev;
1690                 __entry->agno = pag->pag_agno;
1691                 __entry->domain = rec->rc_domain;
1692                 __entry->startblock = rec->rc_startblock;
1693                 __entry->blockcount = rec->rc_blockcount;
1694                 __entry->refcount = rec->rc_refcount;
1695         ),
1696         TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u",
1697                   MAJOR(__entry->dev), MINOR(__entry->dev),
1698                   __entry->agno,
1699                   __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS),
1700                   __entry->startblock,
1701                   __entry->blockcount,
1702                   __entry->refcount)
1703 )
1704
1705 TRACE_EVENT(xrep_bmap_found,
1706         TP_PROTO(struct xfs_inode *ip, int whichfork,
1707                  struct xfs_bmbt_irec *irec),
1708         TP_ARGS(ip, whichfork, irec),
1709         TP_STRUCT__entry(
1710                 __field(dev_t, dev)
1711                 __field(xfs_ino_t, ino)
1712                 __field(int, whichfork)
1713                 __field(xfs_fileoff_t, lblk)
1714                 __field(xfs_filblks_t, len)
1715                 __field(xfs_fsblock_t, pblk)
1716                 __field(int, state)
1717         ),
1718         TP_fast_assign(
1719                 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1720                 __entry->ino = ip->i_ino;
1721                 __entry->whichfork = whichfork;
1722                 __entry->lblk = irec->br_startoff;
1723                 __entry->len = irec->br_blockcount;
1724                 __entry->pblk = irec->br_startblock;
1725                 __entry->state = irec->br_state;
1726         ),
1727         TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d",
1728                   MAJOR(__entry->dev), MINOR(__entry->dev),
1729                   __entry->ino,
1730                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
1731                   __entry->lblk,
1732                   __entry->len,
1733                   __entry->pblk,
1734                   __entry->state)
1735 );
1736
1737 TRACE_EVENT(xrep_rmap_found,
1738         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1739                  const struct xfs_rmap_irec *rec),
1740         TP_ARGS(mp, agno, rec),
1741         TP_STRUCT__entry(
1742                 __field(dev_t, dev)
1743                 __field(xfs_agnumber_t, agno)
1744                 __field(xfs_agblock_t, agbno)
1745                 __field(xfs_extlen_t, len)
1746                 __field(uint64_t, owner)
1747                 __field(uint64_t, offset)
1748                 __field(unsigned int, flags)
1749         ),
1750         TP_fast_assign(
1751                 __entry->dev = mp->m_super->s_dev;
1752                 __entry->agno = agno;
1753                 __entry->agbno = rec->rm_startblock;
1754                 __entry->len = rec->rm_blockcount;
1755                 __entry->owner = rec->rm_owner;
1756                 __entry->offset = rec->rm_offset;
1757                 __entry->flags = rec->rm_flags;
1758         ),
1759         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
1760                   MAJOR(__entry->dev), MINOR(__entry->dev),
1761                   __entry->agno,
1762                   __entry->agbno,
1763                   __entry->len,
1764                   __entry->owner,
1765                   __entry->offset,
1766                   __entry->flags)
1767 );
1768
1769 TRACE_EVENT(xrep_findroot_block,
1770         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
1771                  uint32_t magic, uint16_t level),
1772         TP_ARGS(mp, agno, agbno, magic, level),
1773         TP_STRUCT__entry(
1774                 __field(dev_t, dev)
1775                 __field(xfs_agnumber_t, agno)
1776                 __field(xfs_agblock_t, agbno)
1777                 __field(uint32_t, magic)
1778                 __field(uint16_t, level)
1779         ),
1780         TP_fast_assign(
1781                 __entry->dev = mp->m_super->s_dev;
1782                 __entry->agno = agno;
1783                 __entry->agbno = agbno;
1784                 __entry->magic = magic;
1785                 __entry->level = level;
1786         ),
1787         TP_printk("dev %d:%d agno 0x%x agbno 0x%x magic 0x%x level %u",
1788                   MAJOR(__entry->dev), MINOR(__entry->dev),
1789                   __entry->agno,
1790                   __entry->agbno,
1791                   __entry->magic,
1792                   __entry->level)
1793 )
1794 TRACE_EVENT(xrep_calc_ag_resblks,
1795         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1796                  xfs_agino_t icount, xfs_agblock_t aglen, xfs_agblock_t freelen,
1797                  xfs_agblock_t usedlen),
1798         TP_ARGS(mp, agno, icount, aglen, freelen, usedlen),
1799         TP_STRUCT__entry(
1800                 __field(dev_t, dev)
1801                 __field(xfs_agnumber_t, agno)
1802                 __field(xfs_agino_t, icount)
1803                 __field(xfs_agblock_t, aglen)
1804                 __field(xfs_agblock_t, freelen)
1805                 __field(xfs_agblock_t, usedlen)
1806         ),
1807         TP_fast_assign(
1808                 __entry->dev = mp->m_super->s_dev;
1809                 __entry->agno = agno;
1810                 __entry->icount = icount;
1811                 __entry->aglen = aglen;
1812                 __entry->freelen = freelen;
1813                 __entry->usedlen = usedlen;
1814         ),
1815         TP_printk("dev %d:%d agno 0x%x icount %u aglen %u freelen %u usedlen %u",
1816                   MAJOR(__entry->dev), MINOR(__entry->dev),
1817                   __entry->agno,
1818                   __entry->icount,
1819                   __entry->aglen,
1820                   __entry->freelen,
1821                   __entry->usedlen)
1822 )
1823 TRACE_EVENT(xrep_calc_ag_resblks_btsize,
1824         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1825                  xfs_agblock_t bnobt_sz, xfs_agblock_t inobt_sz,
1826                  xfs_agblock_t rmapbt_sz, xfs_agblock_t refcbt_sz),
1827         TP_ARGS(mp, agno, bnobt_sz, inobt_sz, rmapbt_sz, refcbt_sz),
1828         TP_STRUCT__entry(
1829                 __field(dev_t, dev)
1830                 __field(xfs_agnumber_t, agno)
1831                 __field(xfs_agblock_t, bnobt_sz)
1832                 __field(xfs_agblock_t, inobt_sz)
1833                 __field(xfs_agblock_t, rmapbt_sz)
1834                 __field(xfs_agblock_t, refcbt_sz)
1835         ),
1836         TP_fast_assign(
1837                 __entry->dev = mp->m_super->s_dev;
1838                 __entry->agno = agno;
1839                 __entry->bnobt_sz = bnobt_sz;
1840                 __entry->inobt_sz = inobt_sz;
1841                 __entry->rmapbt_sz = rmapbt_sz;
1842                 __entry->refcbt_sz = refcbt_sz;
1843         ),
1844         TP_printk("dev %d:%d agno 0x%x bnobt %u inobt %u rmapbt %u refcountbt %u",
1845                   MAJOR(__entry->dev), MINOR(__entry->dev),
1846                   __entry->agno,
1847                   __entry->bnobt_sz,
1848                   __entry->inobt_sz,
1849                   __entry->rmapbt_sz,
1850                   __entry->refcbt_sz)
1851 )
1852 TRACE_EVENT(xrep_reset_counters,
1853         TP_PROTO(struct xfs_mount *mp, struct xchk_fscounters *fsc),
1854         TP_ARGS(mp, fsc),
1855         TP_STRUCT__entry(
1856                 __field(dev_t, dev)
1857                 __field(uint64_t, icount)
1858                 __field(uint64_t, ifree)
1859                 __field(uint64_t, fdblocks)
1860                 __field(uint64_t, frextents)
1861         ),
1862         TP_fast_assign(
1863                 __entry->dev = mp->m_super->s_dev;
1864                 __entry->icount = fsc->icount;
1865                 __entry->ifree = fsc->ifree;
1866                 __entry->fdblocks = fsc->fdblocks;
1867                 __entry->frextents = fsc->frextents;
1868         ),
1869         TP_printk("dev %d:%d icount %llu ifree %llu fdblocks %llu frextents %llu",
1870                   MAJOR(__entry->dev), MINOR(__entry->dev),
1871                   __entry->icount,
1872                   __entry->ifree,
1873                   __entry->fdblocks,
1874                   __entry->frextents)
1875 )
1876
1877 DECLARE_EVENT_CLASS(xrep_newbt_extent_class,
1878         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1879                  xfs_agblock_t agbno, xfs_extlen_t len,
1880                  int64_t owner),
1881         TP_ARGS(mp, agno, agbno, len, owner),
1882         TP_STRUCT__entry(
1883                 __field(dev_t, dev)
1884                 __field(xfs_agnumber_t, agno)
1885                 __field(xfs_agblock_t, agbno)
1886                 __field(xfs_extlen_t, len)
1887                 __field(int64_t, owner)
1888         ),
1889         TP_fast_assign(
1890                 __entry->dev = mp->m_super->s_dev;
1891                 __entry->agno = agno;
1892                 __entry->agbno = agbno;
1893                 __entry->len = len;
1894                 __entry->owner = owner;
1895         ),
1896         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx",
1897                   MAJOR(__entry->dev), MINOR(__entry->dev),
1898                   __entry->agno,
1899                   __entry->agbno,
1900                   __entry->len,
1901                   __entry->owner)
1902 );
1903 #define DEFINE_NEWBT_EXTENT_EVENT(name) \
1904 DEFINE_EVENT(xrep_newbt_extent_class, name, \
1905         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
1906                  xfs_agblock_t agbno, xfs_extlen_t len, \
1907                  int64_t owner), \
1908         TP_ARGS(mp, agno, agbno, len, owner))
1909 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_ag_blocks);
1910 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_alloc_file_blocks);
1911 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_free_blocks);
1912 DEFINE_NEWBT_EXTENT_EVENT(xrep_newbt_claim_block);
1913
1914 DECLARE_EVENT_CLASS(xrep_dinode_class,
1915         TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip),
1916         TP_ARGS(sc, dip),
1917         TP_STRUCT__entry(
1918                 __field(dev_t, dev)
1919                 __field(xfs_ino_t, ino)
1920                 __field(uint16_t, mode)
1921                 __field(uint8_t, version)
1922                 __field(uint8_t, format)
1923                 __field(uint32_t, uid)
1924                 __field(uint32_t, gid)
1925                 __field(uint64_t, size)
1926                 __field(uint64_t, nblocks)
1927                 __field(uint32_t, extsize)
1928                 __field(uint32_t, nextents)
1929                 __field(uint16_t, anextents)
1930                 __field(uint8_t, forkoff)
1931                 __field(uint8_t, aformat)
1932                 __field(uint16_t, flags)
1933                 __field(uint32_t, gen)
1934                 __field(uint64_t, flags2)
1935                 __field(uint32_t, cowextsize)
1936         ),
1937         TP_fast_assign(
1938                 __entry->dev = sc->mp->m_super->s_dev;
1939                 __entry->ino = sc->sm->sm_ino;
1940                 __entry->mode = be16_to_cpu(dip->di_mode);
1941                 __entry->version = dip->di_version;
1942                 __entry->format = dip->di_format;
1943                 __entry->uid = be32_to_cpu(dip->di_uid);
1944                 __entry->gid = be32_to_cpu(dip->di_gid);
1945                 __entry->size = be64_to_cpu(dip->di_size);
1946                 __entry->nblocks = be64_to_cpu(dip->di_nblocks);
1947                 __entry->extsize = be32_to_cpu(dip->di_extsize);
1948                 __entry->nextents = be32_to_cpu(dip->di_nextents);
1949                 __entry->anextents = be16_to_cpu(dip->di_anextents);
1950                 __entry->forkoff = dip->di_forkoff;
1951                 __entry->aformat = dip->di_aformat;
1952                 __entry->flags = be16_to_cpu(dip->di_flags);
1953                 __entry->gen = be32_to_cpu(dip->di_gen);
1954                 __entry->flags2 = be64_to_cpu(dip->di_flags2);
1955                 __entry->cowextsize = be32_to_cpu(dip->di_cowextsize);
1956         ),
1957         TP_printk("dev %d:%d ino 0x%llx mode 0x%x version %u format %u uid %u gid %u disize 0x%llx nblocks 0x%llx extsize %u nextents %u anextents %u forkoff 0x%x aformat %u flags 0x%x gen 0x%x flags2 0x%llx cowextsize %u",
1958                   MAJOR(__entry->dev), MINOR(__entry->dev),
1959                   __entry->ino,
1960                   __entry->mode,
1961                   __entry->version,
1962                   __entry->format,
1963                   __entry->uid,
1964                   __entry->gid,
1965                   __entry->size,
1966                   __entry->nblocks,
1967                   __entry->extsize,
1968                   __entry->nextents,
1969                   __entry->anextents,
1970                   __entry->forkoff,
1971                   __entry->aformat,
1972                   __entry->flags,
1973                   __entry->gen,
1974                   __entry->flags2,
1975                   __entry->cowextsize)
1976 )
1977
1978 #define DEFINE_REPAIR_DINODE_EVENT(name) \
1979 DEFINE_EVENT(xrep_dinode_class, name, \
1980         TP_PROTO(struct xfs_scrub *sc, struct xfs_dinode *dip), \
1981         TP_ARGS(sc, dip))
1982 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_header);
1983 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_mode);
1984 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_flags);
1985 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_size);
1986 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_extsize_hints);
1987 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_symlink);
1988 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dir);
1989 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_fixed);
1990 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_forks);
1991 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_dfork);
1992 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_zap_afork);
1993 DEFINE_REPAIR_DINODE_EVENT(xrep_dinode_ensure_forkoff);
1994
1995 DECLARE_EVENT_CLASS(xrep_inode_class,
1996         TP_PROTO(struct xfs_scrub *sc),
1997         TP_ARGS(sc),
1998         TP_STRUCT__entry(
1999                 __field(dev_t, dev)
2000                 __field(xfs_ino_t, ino)
2001                 __field(xfs_fsize_t, size)
2002                 __field(xfs_rfsblock_t, nblocks)
2003                 __field(uint16_t, flags)
2004                 __field(uint64_t, flags2)
2005                 __field(uint32_t, nextents)
2006                 __field(uint8_t, format)
2007                 __field(uint32_t, anextents)
2008                 __field(uint8_t, aformat)
2009         ),
2010         TP_fast_assign(
2011                 __entry->dev = sc->mp->m_super->s_dev;
2012                 __entry->ino = sc->sm->sm_ino;
2013                 __entry->size = sc->ip->i_disk_size;
2014                 __entry->nblocks = sc->ip->i_nblocks;
2015                 __entry->flags = sc->ip->i_diflags;
2016                 __entry->flags2 = sc->ip->i_diflags2;
2017                 __entry->nextents = sc->ip->i_df.if_nextents;
2018                 __entry->format = sc->ip->i_df.if_format;
2019                 __entry->anextents = sc->ip->i_af.if_nextents;
2020                 __entry->aformat = sc->ip->i_af.if_format;
2021         ),
2022         TP_printk("dev %d:%d ino 0x%llx disize 0x%llx nblocks 0x%llx flags 0x%x flags2 0x%llx nextents %u format %u anextents %u aformat %u",
2023                   MAJOR(__entry->dev), MINOR(__entry->dev),
2024                   __entry->ino,
2025                   __entry->size,
2026                   __entry->nblocks,
2027                   __entry->flags,
2028                   __entry->flags2,
2029                   __entry->nextents,
2030                   __entry->format,
2031                   __entry->anextents,
2032                   __entry->aformat)
2033 )
2034
2035 #define DEFINE_REPAIR_INODE_EVENT(name) \
2036 DEFINE_EVENT(xrep_inode_class, name, \
2037         TP_PROTO(struct xfs_scrub *sc), \
2038         TP_ARGS(sc))
2039 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockcounts);
2040 DEFINE_REPAIR_INODE_EVENT(xrep_inode_ids);
2041 DEFINE_REPAIR_INODE_EVENT(xrep_inode_flags);
2042 DEFINE_REPAIR_INODE_EVENT(xrep_inode_blockdir_size);
2043 DEFINE_REPAIR_INODE_EVENT(xrep_inode_sfdir_size);
2044 DEFINE_REPAIR_INODE_EVENT(xrep_inode_dir_size);
2045 DEFINE_REPAIR_INODE_EVENT(xrep_inode_fixed);
2046
2047 TRACE_EVENT(xrep_dinode_count_rmaps,
2048         TP_PROTO(struct xfs_scrub *sc, xfs_rfsblock_t data_blocks,
2049                 xfs_rfsblock_t rt_blocks, xfs_rfsblock_t attr_blocks,
2050                 xfs_extnum_t data_extents, xfs_extnum_t rt_extents,
2051                 xfs_aextnum_t attr_extents),
2052         TP_ARGS(sc, data_blocks, rt_blocks, attr_blocks, data_extents,
2053                 rt_extents, attr_extents),
2054         TP_STRUCT__entry(
2055                 __field(dev_t, dev)
2056                 __field(xfs_ino_t, ino)
2057                 __field(xfs_rfsblock_t, data_blocks)
2058                 __field(xfs_rfsblock_t, rt_blocks)
2059                 __field(xfs_rfsblock_t, attr_blocks)
2060                 __field(xfs_extnum_t, data_extents)
2061                 __field(xfs_extnum_t, rt_extents)
2062                 __field(xfs_aextnum_t, attr_extents)
2063         ),
2064         TP_fast_assign(
2065                 __entry->dev = sc->mp->m_super->s_dev;
2066                 __entry->ino = sc->sm->sm_ino;
2067                 __entry->data_blocks = data_blocks;
2068                 __entry->rt_blocks = rt_blocks;
2069                 __entry->attr_blocks = attr_blocks;
2070                 __entry->data_extents = data_extents;
2071                 __entry->rt_extents = rt_extents;
2072                 __entry->attr_extents = attr_extents;
2073         ),
2074         TP_printk("dev %d:%d ino 0x%llx dblocks 0x%llx rtblocks 0x%llx ablocks 0x%llx dextents %llu rtextents %llu aextents %u",
2075                   MAJOR(__entry->dev), MINOR(__entry->dev),
2076                   __entry->ino,
2077                   __entry->data_blocks,
2078                   __entry->rt_blocks,
2079                   __entry->attr_blocks,
2080                   __entry->data_extents,
2081                   __entry->rt_extents,
2082                   __entry->attr_extents)
2083 );
2084
2085 TRACE_EVENT(xrep_dinode_findmode_dirent,
2086         TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp,
2087                  unsigned int ftype),
2088         TP_ARGS(sc, dp, ftype),
2089         TP_STRUCT__entry(
2090                 __field(dev_t, dev)
2091                 __field(xfs_ino_t, ino)
2092                 __field(xfs_ino_t, parent_ino)
2093                 __field(unsigned int, ftype)
2094         ),
2095         TP_fast_assign(
2096                 __entry->dev = sc->mp->m_super->s_dev;
2097                 __entry->ino = sc->sm->sm_ino;
2098                 __entry->parent_ino = dp->i_ino;
2099                 __entry->ftype = ftype;
2100         ),
2101         TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s'",
2102                   MAJOR(__entry->dev), MINOR(__entry->dev),
2103                   __entry->ino,
2104                   __entry->parent_ino,
2105                   __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR))
2106 );
2107
2108 TRACE_EVENT(xrep_dinode_findmode_dirent_inval,
2109         TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *dp,
2110                  unsigned int ftype, unsigned int found_ftype),
2111         TP_ARGS(sc, dp, ftype, found_ftype),
2112         TP_STRUCT__entry(
2113                 __field(dev_t, dev)
2114                 __field(xfs_ino_t, ino)
2115                 __field(xfs_ino_t, parent_ino)
2116                 __field(unsigned int, ftype)
2117                 __field(unsigned int, found_ftype)
2118         ),
2119         TP_fast_assign(
2120                 __entry->dev = sc->mp->m_super->s_dev;
2121                 __entry->ino = sc->sm->sm_ino;
2122                 __entry->parent_ino = dp->i_ino;
2123                 __entry->ftype = ftype;
2124                 __entry->found_ftype = found_ftype;
2125         ),
2126         TP_printk("dev %d:%d ino 0x%llx parent_ino 0x%llx ftype '%s' found_ftype '%s'",
2127                   MAJOR(__entry->dev), MINOR(__entry->dev),
2128                   __entry->ino,
2129                   __entry->parent_ino,
2130                   __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR),
2131                   __print_symbolic(__entry->found_ftype, XFS_DIR3_FTYPE_STR))
2132 );
2133
2134 TRACE_EVENT(xrep_cow_mark_file_range,
2135         TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t startblock,
2136                  xfs_fileoff_t startoff, xfs_filblks_t blockcount),
2137         TP_ARGS(ip, startblock, startoff, blockcount),
2138         TP_STRUCT__entry(
2139                 __field(dev_t, dev)
2140                 __field(xfs_ino_t, ino)
2141                 __field(xfs_fsblock_t, startblock)
2142                 __field(xfs_fileoff_t, startoff)
2143                 __field(xfs_filblks_t, blockcount)
2144         ),
2145         TP_fast_assign(
2146                 __entry->dev = ip->i_mount->m_super->s_dev;
2147                 __entry->ino = ip->i_ino;
2148                 __entry->startoff = startoff;
2149                 __entry->startblock = startblock;
2150                 __entry->blockcount = blockcount;
2151         ),
2152         TP_printk("dev %d:%d ino 0x%llx fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx",
2153                   MAJOR(__entry->dev), MINOR(__entry->dev),
2154                   __entry->ino,
2155                   __entry->startoff,
2156                   __entry->startblock,
2157                   __entry->blockcount)
2158 );
2159
2160 TRACE_EVENT(xrep_cow_replace_mapping,
2161         TP_PROTO(struct xfs_inode *ip, const struct xfs_bmbt_irec *irec,
2162                  xfs_fsblock_t new_startblock, xfs_extlen_t new_blockcount),
2163         TP_ARGS(ip, irec, new_startblock, new_blockcount),
2164         TP_STRUCT__entry(
2165                 __field(dev_t, dev)
2166                 __field(xfs_ino_t, ino)
2167                 __field(xfs_fsblock_t, startblock)
2168                 __field(xfs_fileoff_t, startoff)
2169                 __field(xfs_filblks_t, blockcount)
2170                 __field(xfs_exntst_t, state)
2171                 __field(xfs_fsblock_t, new_startblock)
2172                 __field(xfs_extlen_t, new_blockcount)
2173         ),
2174         TP_fast_assign(
2175                 __entry->dev = ip->i_mount->m_super->s_dev;
2176                 __entry->ino = ip->i_ino;
2177                 __entry->startoff = irec->br_startoff;
2178                 __entry->startblock = irec->br_startblock;
2179                 __entry->blockcount = irec->br_blockcount;
2180                 __entry->state = irec->br_state;
2181                 __entry->new_startblock = new_startblock;
2182                 __entry->new_blockcount = new_blockcount;
2183         ),
2184         TP_printk("dev %d:%d ino 0x%llx startoff 0x%llx startblock 0x%llx fsbcount 0x%llx state 0x%x new_startblock 0x%llx new_fsbcount 0x%x",
2185                   MAJOR(__entry->dev), MINOR(__entry->dev),
2186                   __entry->ino,
2187                   __entry->startoff,
2188                   __entry->startblock,
2189                   __entry->blockcount,
2190                   __entry->state,
2191                   __entry->new_startblock,
2192                   __entry->new_blockcount)
2193 );
2194
2195 TRACE_EVENT(xrep_cow_free_staging,
2196         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno,
2197                  xfs_extlen_t blockcount),
2198         TP_ARGS(pag, agbno, blockcount),
2199         TP_STRUCT__entry(
2200                 __field(dev_t, dev)
2201                 __field(xfs_agnumber_t, agno)
2202                 __field(xfs_agblock_t, agbno)
2203                 __field(xfs_extlen_t, blockcount)
2204         ),
2205         TP_fast_assign(
2206                 __entry->dev = pag->pag_mount->m_super->s_dev;
2207                 __entry->agno = pag->pag_agno;
2208                 __entry->agbno = agbno;
2209                 __entry->blockcount = blockcount;
2210         ),
2211         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
2212                   MAJOR(__entry->dev), MINOR(__entry->dev),
2213                   __entry->agno,
2214                   __entry->agbno,
2215                   __entry->blockcount)
2216 );
2217
2218 #ifdef CONFIG_XFS_QUOTA
2219 DECLARE_EVENT_CLASS(xrep_dquot_class,
2220         TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id),
2221         TP_ARGS(mp, type, id),
2222         TP_STRUCT__entry(
2223                 __field(dev_t, dev)
2224                 __field(uint8_t, type)
2225                 __field(uint32_t, id)
2226         ),
2227         TP_fast_assign(
2228                 __entry->dev = mp->m_super->s_dev;
2229                 __entry->id = id;
2230                 __entry->type = type;
2231         ),
2232         TP_printk("dev %d:%d type %s id 0x%x",
2233                   MAJOR(__entry->dev), MINOR(__entry->dev),
2234                   __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS),
2235                   __entry->id)
2236 );
2237
2238 #define DEFINE_XREP_DQUOT_EVENT(name) \
2239 DEFINE_EVENT(xrep_dquot_class, name, \
2240         TP_PROTO(struct xfs_mount *mp, uint8_t type, uint32_t id), \
2241         TP_ARGS(mp, type, id))
2242 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item);
2243 DEFINE_XREP_DQUOT_EVENT(xrep_disk_dquot);
2244 DEFINE_XREP_DQUOT_EVENT(xrep_dquot_item_fill_bmap_hole);
2245 DEFINE_XREP_DQUOT_EVENT(xrep_quotacheck_dquot);
2246 #endif /* CONFIG_XFS_QUOTA */
2247
2248 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_update_inode);
2249 DEFINE_SCRUB_NLINKS_DIFF_EVENT(xrep_nlinks_unfixable_inode);
2250
2251 TRACE_EVENT(xrep_rmap_live_update,
2252         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, unsigned int op,
2253                  const struct xfs_rmap_update_params *p),
2254         TP_ARGS(mp, agno, op, p),
2255         TP_STRUCT__entry(
2256                 __field(dev_t, dev)
2257                 __field(xfs_agnumber_t, agno)
2258                 __field(unsigned int, op)
2259                 __field(xfs_agblock_t, agbno)
2260                 __field(xfs_extlen_t, len)
2261                 __field(uint64_t, owner)
2262                 __field(uint64_t, offset)
2263                 __field(unsigned int, flags)
2264         ),
2265         TP_fast_assign(
2266                 __entry->dev = mp->m_super->s_dev;
2267                 __entry->agno = agno;
2268                 __entry->op = op;
2269                 __entry->agbno = p->startblock;
2270                 __entry->len = p->blockcount;
2271                 xfs_owner_info_unpack(&p->oinfo, &__entry->owner,
2272                                 &__entry->offset, &__entry->flags);
2273                 if (p->unwritten)
2274                         __entry->flags |= XFS_RMAP_UNWRITTEN;
2275         ),
2276         TP_printk("dev %d:%d agno 0x%x op %d agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
2277                   MAJOR(__entry->dev), MINOR(__entry->dev),
2278                   __entry->agno,
2279                   __entry->op,
2280                   __entry->agbno,
2281                   __entry->len,
2282                   __entry->owner,
2283                   __entry->offset,
2284                   __entry->flags)
2285 );
2286
2287 TRACE_EVENT(xrep_tempfile_create,
2288         TP_PROTO(struct xfs_scrub *sc),
2289         TP_ARGS(sc),
2290         TP_STRUCT__entry(
2291                 __field(dev_t, dev)
2292                 __field(xfs_ino_t, ino)
2293                 __field(unsigned int, type)
2294                 __field(xfs_agnumber_t, agno)
2295                 __field(xfs_ino_t, inum)
2296                 __field(unsigned int, gen)
2297                 __field(unsigned int, flags)
2298                 __field(xfs_ino_t, temp_inum)
2299         ),
2300         TP_fast_assign(
2301                 __entry->dev = sc->mp->m_super->s_dev;
2302                 __entry->ino = sc->file ? XFS_I(file_inode(sc->file))->i_ino : 0;
2303                 __entry->type = sc->sm->sm_type;
2304                 __entry->agno = sc->sm->sm_agno;
2305                 __entry->inum = sc->sm->sm_ino;
2306                 __entry->gen = sc->sm->sm_gen;
2307                 __entry->flags = sc->sm->sm_flags;
2308                 __entry->temp_inum = sc->tempip->i_ino;
2309         ),
2310         TP_printk("dev %d:%d ino 0x%llx type %s inum 0x%llx gen 0x%x flags 0x%x temp_inum 0x%llx",
2311                   MAJOR(__entry->dev), MINOR(__entry->dev),
2312                   __entry->ino,
2313                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
2314                   __entry->inum,
2315                   __entry->gen,
2316                   __entry->flags,
2317                   __entry->temp_inum)
2318 );
2319
2320 DECLARE_EVENT_CLASS(xrep_tempfile_class,
2321         TP_PROTO(struct xfs_scrub *sc, int whichfork,
2322                  struct xfs_bmbt_irec *irec),
2323         TP_ARGS(sc, whichfork, irec),
2324         TP_STRUCT__entry(
2325                 __field(dev_t, dev)
2326                 __field(xfs_ino_t, ino)
2327                 __field(int, whichfork)
2328                 __field(xfs_fileoff_t, lblk)
2329                 __field(xfs_filblks_t, len)
2330                 __field(xfs_fsblock_t, pblk)
2331                 __field(int, state)
2332         ),
2333         TP_fast_assign(
2334                 __entry->dev = sc->mp->m_super->s_dev;
2335                 __entry->ino = sc->tempip->i_ino;
2336                 __entry->whichfork = whichfork;
2337                 __entry->lblk = irec->br_startoff;
2338                 __entry->len = irec->br_blockcount;
2339                 __entry->pblk = irec->br_startblock;
2340                 __entry->state = irec->br_state;
2341         ),
2342         TP_printk("dev %d:%d ino 0x%llx whichfork %s fileoff 0x%llx fsbcount 0x%llx startblock 0x%llx state %d",
2343                   MAJOR(__entry->dev), MINOR(__entry->dev),
2344                   __entry->ino,
2345                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
2346                   __entry->lblk,
2347                   __entry->len,
2348                   __entry->pblk,
2349                   __entry->state)
2350 );
2351 #define DEFINE_XREP_TEMPFILE_EVENT(name) \
2352 DEFINE_EVENT(xrep_tempfile_class, name, \
2353         TP_PROTO(struct xfs_scrub *sc, int whichfork, \
2354                  struct xfs_bmbt_irec *irec), \
2355         TP_ARGS(sc, whichfork, irec))
2356 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_prealloc);
2357 DEFINE_XREP_TEMPFILE_EVENT(xrep_tempfile_copyin);
2358
2359 TRACE_EVENT(xreap_ifork_extent,
2360         TP_PROTO(struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork,
2361                  const struct xfs_bmbt_irec *irec),
2362         TP_ARGS(sc, ip, whichfork, irec),
2363         TP_STRUCT__entry(
2364                 __field(dev_t, dev)
2365                 __field(xfs_ino_t, ino)
2366                 __field(int, whichfork)
2367                 __field(xfs_fileoff_t, fileoff)
2368                 __field(xfs_filblks_t, len)
2369                 __field(xfs_agnumber_t, agno)
2370                 __field(xfs_agblock_t, agbno)
2371                 __field(int, state)
2372         ),
2373         TP_fast_assign(
2374                 __entry->dev = sc->mp->m_super->s_dev;
2375                 __entry->ino = ip->i_ino;
2376                 __entry->whichfork = whichfork;
2377                 __entry->fileoff = irec->br_startoff;
2378                 __entry->len = irec->br_blockcount;
2379                 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock);
2380                 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock);
2381                 __entry->state = irec->br_state;
2382         ),
2383         TP_printk("dev %d:%d ip 0x%llx whichfork %s agno 0x%x agbno 0x%x fileoff 0x%llx fsbcount 0x%llx state 0x%x",
2384                   MAJOR(__entry->dev), MINOR(__entry->dev),
2385                   __entry->ino,
2386                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
2387                   __entry->agno,
2388                   __entry->agbno,
2389                   __entry->fileoff,
2390                   __entry->len,
2391                   __entry->state)
2392 );
2393
2394 TRACE_EVENT(xreap_bmapi_binval_scan,
2395         TP_PROTO(struct xfs_scrub *sc, const struct xfs_bmbt_irec *irec,
2396                  xfs_extlen_t scan_blocks),
2397         TP_ARGS(sc, irec, scan_blocks),
2398         TP_STRUCT__entry(
2399                 __field(dev_t, dev)
2400                 __field(xfs_filblks_t, len)
2401                 __field(xfs_agnumber_t, agno)
2402                 __field(xfs_agblock_t, agbno)
2403                 __field(xfs_extlen_t, scan_blocks)
2404         ),
2405         TP_fast_assign(
2406                 __entry->dev = sc->mp->m_super->s_dev;
2407                 __entry->len = irec->br_blockcount;
2408                 __entry->agno = XFS_FSB_TO_AGNO(sc->mp, irec->br_startblock);
2409                 __entry->agbno = XFS_FSB_TO_AGBNO(sc->mp, irec->br_startblock);
2410                 __entry->scan_blocks = scan_blocks;
2411         ),
2412         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%llx scan_blocks 0x%x",
2413                   MAJOR(__entry->dev), MINOR(__entry->dev),
2414                   __entry->agno,
2415                   __entry->agbno,
2416                   __entry->len,
2417                   __entry->scan_blocks)
2418 );
2419
2420 TRACE_EVENT(xrep_xattr_recover_leafblock,
2421         TP_PROTO(struct xfs_inode *ip, xfs_dablk_t dabno, uint16_t magic),
2422         TP_ARGS(ip, dabno, magic),
2423         TP_STRUCT__entry(
2424                 __field(dev_t, dev)
2425                 __field(xfs_ino_t, ino)
2426                 __field(xfs_dablk_t, dabno)
2427                 __field(uint16_t, magic)
2428         ),
2429         TP_fast_assign(
2430                 __entry->dev = ip->i_mount->m_super->s_dev;
2431                 __entry->ino = ip->i_ino;
2432                 __entry->dabno = dabno;
2433                 __entry->magic = magic;
2434         ),
2435         TP_printk("dev %d:%d ino 0x%llx dablk 0x%x magic 0x%x",
2436                   MAJOR(__entry->dev), MINOR(__entry->dev),
2437                   __entry->ino,
2438                   __entry->dabno,
2439                   __entry->magic)
2440 );
2441
2442 DECLARE_EVENT_CLASS(xrep_xattr_salvage_class,
2443         TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name,
2444                  unsigned int namelen, unsigned int valuelen),
2445         TP_ARGS(ip, flags, name, namelen, valuelen),
2446         TP_STRUCT__entry(
2447                 __field(dev_t, dev)
2448                 __field(xfs_ino_t, ino)
2449                 __field(unsigned int, flags)
2450                 __field(unsigned int, namelen)
2451                 __dynamic_array(char, name, namelen)
2452                 __field(unsigned int, valuelen)
2453         ),
2454         TP_fast_assign(
2455                 __entry->dev = ip->i_mount->m_super->s_dev;
2456                 __entry->ino = ip->i_ino;
2457                 __entry->flags = flags;
2458                 __entry->namelen = namelen;
2459                 memcpy(__get_str(name), name, namelen);
2460                 __entry->valuelen = valuelen;
2461         ),
2462         TP_printk("dev %d:%d ino 0x%llx flags %s name '%.*s' valuelen 0x%x",
2463                   MAJOR(__entry->dev), MINOR(__entry->dev),
2464                   __entry->ino,
2465                    __print_flags(__entry->flags, "|", XFS_ATTR_NAMESPACE_STR),
2466                   __entry->namelen,
2467                   __get_str(name),
2468                   __entry->valuelen)
2469 );
2470 #define DEFINE_XREP_XATTR_SALVAGE_EVENT(name) \
2471 DEFINE_EVENT(xrep_xattr_salvage_class, name, \
2472         TP_PROTO(struct xfs_inode *ip, unsigned int flags, char *name, \
2473                  unsigned int namelen, unsigned int valuelen), \
2474         TP_ARGS(ip, flags, name, namelen, valuelen))
2475 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_salvage_rec);
2476 DEFINE_XREP_XATTR_SALVAGE_EVENT(xrep_xattr_insert_rec);
2477
2478 TRACE_EVENT(xrep_xattr_class,
2479         TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip),
2480         TP_ARGS(ip, arg_ip),
2481         TP_STRUCT__entry(
2482                 __field(dev_t, dev)
2483                 __field(xfs_ino_t, ino)
2484                 __field(xfs_ino_t, src_ino)
2485         ),
2486         TP_fast_assign(
2487                 __entry->dev = ip->i_mount->m_super->s_dev;
2488                 __entry->ino = ip->i_ino;
2489                 __entry->src_ino = arg_ip->i_ino;
2490         ),
2491         TP_printk("dev %d:%d ino 0x%llx src 0x%llx",
2492                   MAJOR(__entry->dev), MINOR(__entry->dev),
2493                   __entry->ino,
2494                   __entry->src_ino)
2495 )
2496 #define DEFINE_XREP_XATTR_EVENT(name) \
2497 DEFINE_EVENT(xrep_xattr_class, name, \
2498         TP_PROTO(struct xfs_inode *ip, struct xfs_inode *arg_ip), \
2499         TP_ARGS(ip, arg_ip))
2500 DEFINE_XREP_XATTR_EVENT(xrep_xattr_rebuild_tree);
2501 DEFINE_XREP_XATTR_EVENT(xrep_xattr_reset_fork);
2502
2503 TRACE_EVENT(xrep_dir_recover_dirblock,
2504         TP_PROTO(struct xfs_inode *dp, xfs_dablk_t dabno, uint32_t magic,
2505                  uint32_t magic_guess),
2506         TP_ARGS(dp, dabno, magic, magic_guess),
2507         TP_STRUCT__entry(
2508                 __field(dev_t, dev)
2509                 __field(xfs_ino_t, dir_ino)
2510                 __field(xfs_dablk_t, dabno)
2511                 __field(uint32_t, magic)
2512                 __field(uint32_t, magic_guess)
2513         ),
2514         TP_fast_assign(
2515                 __entry->dev = dp->i_mount->m_super->s_dev;
2516                 __entry->dir_ino = dp->i_ino;
2517                 __entry->dabno = dabno;
2518                 __entry->magic = magic;
2519                 __entry->magic_guess = magic_guess;
2520         ),
2521         TP_printk("dev %d:%d dir 0x%llx dablk 0x%x magic 0x%x magic_guess 0x%x",
2522                   MAJOR(__entry->dev), MINOR(__entry->dev),
2523                   __entry->dir_ino,
2524                   __entry->dabno,
2525                   __entry->magic,
2526                   __entry->magic_guess)
2527 );
2528
2529 DECLARE_EVENT_CLASS(xrep_dir_class,
2530         TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino),
2531         TP_ARGS(dp, parent_ino),
2532         TP_STRUCT__entry(
2533                 __field(dev_t, dev)
2534                 __field(xfs_ino_t, dir_ino)
2535                 __field(xfs_ino_t, parent_ino)
2536         ),
2537         TP_fast_assign(
2538                 __entry->dev = dp->i_mount->m_super->s_dev;
2539                 __entry->dir_ino = dp->i_ino;
2540                 __entry->parent_ino = parent_ino;
2541         ),
2542         TP_printk("dev %d:%d dir 0x%llx parent 0x%llx",
2543                   MAJOR(__entry->dev), MINOR(__entry->dev),
2544                   __entry->dir_ino,
2545                   __entry->parent_ino)
2546 )
2547 #define DEFINE_XREP_DIR_EVENT(name) \
2548 DEFINE_EVENT(xrep_dir_class, name, \
2549         TP_PROTO(struct xfs_inode *dp, xfs_ino_t parent_ino), \
2550         TP_ARGS(dp, parent_ino))
2551 DEFINE_XREP_DIR_EVENT(xrep_dir_rebuild_tree);
2552 DEFINE_XREP_DIR_EVENT(xrep_dir_reset_fork);
2553 DEFINE_XREP_DIR_EVENT(xrep_parent_reset_dotdot);
2554
2555 DECLARE_EVENT_CLASS(xrep_dirent_class,
2556         TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name,
2557                  xfs_ino_t ino),
2558         TP_ARGS(dp, name, ino),
2559         TP_STRUCT__entry(
2560                 __field(dev_t, dev)
2561                 __field(xfs_ino_t, dir_ino)
2562                 __field(unsigned int, namelen)
2563                 __dynamic_array(char, name, name->len)
2564                 __field(xfs_ino_t, ino)
2565                 __field(uint8_t, ftype)
2566         ),
2567         TP_fast_assign(
2568                 __entry->dev = dp->i_mount->m_super->s_dev;
2569                 __entry->dir_ino = dp->i_ino;
2570                 __entry->namelen = name->len;
2571                 memcpy(__get_str(name), name->name, name->len);
2572                 __entry->ino = ino;
2573                 __entry->ftype = name->type;
2574         ),
2575         TP_printk("dev %d:%d dir 0x%llx ftype %s name '%.*s' ino 0x%llx",
2576                   MAJOR(__entry->dev), MINOR(__entry->dev),
2577                   __entry->dir_ino,
2578                   __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR),
2579                   __entry->namelen,
2580                   __get_str(name),
2581                   __entry->ino)
2582 )
2583 #define DEFINE_XREP_DIRENT_EVENT(name) \
2584 DEFINE_EVENT(xrep_dirent_class, name, \
2585         TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name, \
2586                  xfs_ino_t ino), \
2587         TP_ARGS(dp, name, ino))
2588 DEFINE_XREP_DIRENT_EVENT(xrep_dir_salvage_entry);
2589 DEFINE_XREP_DIRENT_EVENT(xrep_dir_stash_createname);
2590 DEFINE_XREP_DIRENT_EVENT(xrep_dir_replay_createname);
2591 DEFINE_XREP_DIRENT_EVENT(xrep_adoption_reparent);
2592
2593 DECLARE_EVENT_CLASS(xrep_adoption_class,
2594         TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved),
2595         TP_ARGS(dp, ip, moved),
2596         TP_STRUCT__entry(
2597                 __field(dev_t, dev)
2598                 __field(xfs_ino_t, dir_ino)
2599                 __field(xfs_ino_t, child_ino)
2600                 __field(bool, moved)
2601         ),
2602         TP_fast_assign(
2603                 __entry->dev = dp->i_mount->m_super->s_dev;
2604                 __entry->dir_ino = dp->i_ino;
2605                 __entry->child_ino = ip->i_ino;
2606                 __entry->moved = moved;
2607         ),
2608         TP_printk("dev %d:%d dir 0x%llx child 0x%llx moved? %d",
2609                   MAJOR(__entry->dev), MINOR(__entry->dev),
2610                   __entry->dir_ino,
2611                   __entry->child_ino,
2612                   __entry->moved)
2613 );
2614 #define DEFINE_XREP_ADOPTION_EVENT(name) \
2615 DEFINE_EVENT(xrep_adoption_class, name, \
2616         TP_PROTO(struct xfs_inode *dp, struct xfs_inode *ip, bool moved), \
2617         TP_ARGS(dp, ip, moved))
2618 DEFINE_XREP_ADOPTION_EVENT(xrep_adoption_trans_roll);
2619
2620 DECLARE_EVENT_CLASS(xrep_parent_salvage_class,
2621         TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino),
2622         TP_ARGS(dp, ino),
2623         TP_STRUCT__entry(
2624                 __field(dev_t, dev)
2625                 __field(xfs_ino_t, dir_ino)
2626                 __field(xfs_ino_t, ino)
2627         ),
2628         TP_fast_assign(
2629                 __entry->dev = dp->i_mount->m_super->s_dev;
2630                 __entry->dir_ino = dp->i_ino;
2631                 __entry->ino = ino;
2632         ),
2633         TP_printk("dev %d:%d dir 0x%llx parent 0x%llx",
2634                   MAJOR(__entry->dev), MINOR(__entry->dev),
2635                   __entry->dir_ino,
2636                   __entry->ino)
2637 )
2638 #define DEFINE_XREP_PARENT_SALVAGE_EVENT(name) \
2639 DEFINE_EVENT(xrep_parent_salvage_class, name, \
2640         TP_PROTO(struct xfs_inode *dp, xfs_ino_t ino), \
2641         TP_ARGS(dp, ino))
2642 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_dir_salvaged_parent);
2643 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_dirent);
2644 DEFINE_XREP_PARENT_SALVAGE_EVENT(xrep_findparent_from_dcache);
2645
2646 TRACE_EVENT(xrep_nlinks_set_record,
2647         TP_PROTO(struct xfs_mount *mp, xfs_ino_t ino,
2648                  const struct xchk_nlink *obs),
2649         TP_ARGS(mp, ino, obs),
2650         TP_STRUCT__entry(
2651                 __field(dev_t, dev)
2652                 __field(xfs_ino_t, ino)
2653                 __field(xfs_nlink_t, parents)
2654                 __field(xfs_nlink_t, backrefs)
2655                 __field(xfs_nlink_t, children)
2656         ),
2657         TP_fast_assign(
2658                 __entry->dev = mp->m_super->s_dev;
2659                 __entry->ino = ino;
2660                 __entry->parents = obs->parents;
2661                 __entry->backrefs = obs->backrefs;
2662                 __entry->children = obs->children;
2663         ),
2664         TP_printk("dev %d:%d ino 0x%llx parents %u backrefs %u children %u",
2665                   MAJOR(__entry->dev), MINOR(__entry->dev),
2666                   __entry->ino,
2667                   __entry->parents,
2668                   __entry->backrefs,
2669                   __entry->children)
2670 );
2671
2672 DECLARE_EVENT_CLASS(xrep_dentry_class,
2673         TP_PROTO(struct xfs_mount *mp, const struct dentry *dentry),
2674         TP_ARGS(mp, dentry),
2675         TP_STRUCT__entry(
2676                 __field(dev_t, dev)
2677                 __field(unsigned int, flags)
2678                 __field(unsigned long, ino)
2679                 __field(bool, positive)
2680                 __field(unsigned long, parent_ino)
2681                 __field(unsigned int, namelen)
2682                 __dynamic_array(char, name, dentry->d_name.len)
2683         ),
2684         TP_fast_assign(
2685                 __entry->dev = mp->m_super->s_dev;
2686                 __entry->flags = dentry->d_flags;
2687                 __entry->positive = d_is_positive(dentry);
2688                 if (dentry->d_parent && d_inode(dentry->d_parent))
2689                         __entry->parent_ino = d_inode(dentry->d_parent)->i_ino;
2690                 else
2691                         __entry->parent_ino = -1UL;
2692                 __entry->ino = d_inode(dentry) ? d_inode(dentry)->i_ino : 0;
2693                 __entry->namelen = dentry->d_name.len;
2694                 memcpy(__get_str(name), dentry->d_name.name, dentry->d_name.len);
2695         ),
2696         TP_printk("dev %d:%d flags 0x%x positive? %d parent_ino 0x%lx ino 0x%lx name '%.*s'",
2697                   MAJOR(__entry->dev), MINOR(__entry->dev),
2698                   __entry->flags,
2699                   __entry->positive,
2700                   __entry->parent_ino,
2701                   __entry->ino,
2702                   __entry->namelen,
2703                   __get_str(name))
2704 );
2705 #define DEFINE_REPAIR_DENTRY_EVENT(name) \
2706 DEFINE_EVENT(xrep_dentry_class, name, \
2707         TP_PROTO(struct xfs_mount *mp, const struct dentry *dentry), \
2708         TP_ARGS(mp, dentry))
2709 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_check_child);
2710 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_check_alias);
2711 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_check_dentry);
2712 DEFINE_REPAIR_DENTRY_EVENT(xrep_adoption_invalidate_child);
2713
2714 TRACE_EVENT(xrep_symlink_salvage_target,
2715         TP_PROTO(struct xfs_inode *ip, char *target, unsigned int targetlen),
2716         TP_ARGS(ip, target, targetlen),
2717         TP_STRUCT__entry(
2718                 __field(dev_t, dev)
2719                 __field(xfs_ino_t, ino)
2720                 __field(unsigned int, targetlen)
2721                 __dynamic_array(char, target, targetlen + 1)
2722         ),
2723         TP_fast_assign(
2724                 __entry->dev = ip->i_mount->m_super->s_dev;
2725                 __entry->ino = ip->i_ino;
2726                 __entry->targetlen = targetlen;
2727                 memcpy(__get_str(target), target, targetlen);
2728                 __get_str(target)[targetlen] = 0;
2729         ),
2730         TP_printk("dev %d:%d ip 0x%llx target '%.*s'",
2731                   MAJOR(__entry->dev), MINOR(__entry->dev),
2732                   __entry->ino,
2733                   __entry->targetlen,
2734                   __get_str(target))
2735 );
2736
2737 DECLARE_EVENT_CLASS(xrep_symlink_class,
2738         TP_PROTO(struct xfs_inode *ip),
2739         TP_ARGS(ip),
2740         TP_STRUCT__entry(
2741                 __field(dev_t, dev)
2742                 __field(xfs_ino_t, ino)
2743         ),
2744         TP_fast_assign(
2745                 __entry->dev = ip->i_mount->m_super->s_dev;
2746                 __entry->ino = ip->i_ino;
2747         ),
2748         TP_printk("dev %d:%d ip 0x%llx",
2749                   MAJOR(__entry->dev), MINOR(__entry->dev),
2750                   __entry->ino)
2751 );
2752
2753 #define DEFINE_XREP_SYMLINK_EVENT(name) \
2754 DEFINE_EVENT(xrep_symlink_class, name, \
2755         TP_PROTO(struct xfs_inode *ip), \
2756         TP_ARGS(ip))
2757 DEFINE_XREP_SYMLINK_EVENT(xrep_symlink_rebuild);
2758 DEFINE_XREP_SYMLINK_EVENT(xrep_symlink_reset_fork);
2759
2760 TRACE_EVENT(xrep_iunlink_visit,
2761         TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
2762                  xfs_agino_t bucket_agino, struct xfs_inode *ip),
2763         TP_ARGS(pag, bucket, bucket_agino, ip),
2764         TP_STRUCT__entry(
2765                 __field(dev_t, dev)
2766                 __field(xfs_agnumber_t, agno)
2767                 __field(xfs_agino_t, agino)
2768                 __field(unsigned int, bucket)
2769                 __field(xfs_agino_t, bucket_agino)
2770                 __field(xfs_agino_t, prev_agino)
2771                 __field(xfs_agino_t, next_agino)
2772         ),
2773         TP_fast_assign(
2774                 __entry->dev = pag->pag_mount->m_super->s_dev;
2775                 __entry->agno = pag->pag_agno;
2776                 __entry->agino = XFS_INO_TO_AGINO(pag->pag_mount, ip->i_ino);
2777                 __entry->bucket = bucket;
2778                 __entry->bucket_agino = bucket_agino;
2779                 __entry->prev_agino = ip->i_prev_unlinked;
2780                 __entry->next_agino = ip->i_next_unlinked;
2781         ),
2782         TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x bucket_agino 0x%x prev_agino 0x%x next_agino 0x%x",
2783                   MAJOR(__entry->dev), MINOR(__entry->dev),
2784                   __entry->agno,
2785                   __entry->bucket,
2786                   __entry->agino,
2787                   __entry->bucket_agino,
2788                   __entry->prev_agino,
2789                   __entry->next_agino)
2790 );
2791
2792 TRACE_EVENT(xrep_iunlink_reload_next,
2793         TP_PROTO(struct xfs_inode *ip, xfs_agino_t prev_agino),
2794         TP_ARGS(ip, prev_agino),
2795         TP_STRUCT__entry(
2796                 __field(dev_t, dev)
2797                 __field(xfs_agnumber_t, agno)
2798                 __field(xfs_agino_t, agino)
2799                 __field(xfs_agino_t, old_prev_agino)
2800                 __field(xfs_agino_t, prev_agino)
2801                 __field(xfs_agino_t, next_agino)
2802                 __field(unsigned int, nlink)
2803         ),
2804         TP_fast_assign(
2805                 __entry->dev = ip->i_mount->m_super->s_dev;
2806                 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
2807                 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
2808                 __entry->old_prev_agino = ip->i_prev_unlinked;
2809                 __entry->prev_agino = prev_agino;
2810                 __entry->next_agino = ip->i_next_unlinked;
2811                 __entry->nlink = VFS_I(ip)->i_nlink;
2812         ),
2813         TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x nlink %u old_prev_agino %u prev_agino 0x%x next_agino 0x%x",
2814                   MAJOR(__entry->dev), MINOR(__entry->dev),
2815                   __entry->agno,
2816                   __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
2817                   __entry->agino,
2818                   __entry->nlink,
2819                   __entry->old_prev_agino,
2820                   __entry->prev_agino,
2821                   __entry->next_agino)
2822 );
2823
2824 TRACE_EVENT(xrep_iunlink_reload_ondisk,
2825         TP_PROTO(struct xfs_inode *ip),
2826         TP_ARGS(ip),
2827         TP_STRUCT__entry(
2828                 __field(dev_t, dev)
2829                 __field(xfs_agnumber_t, agno)
2830                 __field(xfs_agino_t, agino)
2831                 __field(unsigned int, nlink)
2832                 __field(xfs_agino_t, next_agino)
2833         ),
2834         TP_fast_assign(
2835                 __entry->dev = ip->i_mount->m_super->s_dev;
2836                 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
2837                 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
2838                 __entry->nlink = VFS_I(ip)->i_nlink;
2839                 __entry->next_agino = ip->i_next_unlinked;
2840         ),
2841         TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x nlink %u next_agino 0x%x",
2842                   MAJOR(__entry->dev), MINOR(__entry->dev),
2843                   __entry->agno,
2844                   __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
2845                   __entry->agino,
2846                   __entry->nlink,
2847                   __entry->next_agino)
2848 );
2849
2850 TRACE_EVENT(xrep_iunlink_walk_ondisk_bucket,
2851         TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
2852                  xfs_agino_t prev_agino, xfs_agino_t next_agino),
2853         TP_ARGS(pag, bucket, prev_agino, next_agino),
2854         TP_STRUCT__entry(
2855                 __field(dev_t, dev)
2856                 __field(xfs_agnumber_t, agno)
2857                 __field(unsigned int, bucket)
2858                 __field(xfs_agino_t, prev_agino)
2859                 __field(xfs_agino_t, next_agino)
2860         ),
2861         TP_fast_assign(
2862                 __entry->dev = pag->pag_mount->m_super->s_dev;
2863                 __entry->agno = pag->pag_agno;
2864                 __entry->bucket = bucket;
2865                 __entry->prev_agino = prev_agino;
2866                 __entry->next_agino = next_agino;
2867         ),
2868         TP_printk("dev %d:%d agno 0x%x bucket %u prev_agino 0x%x next_agino 0x%x",
2869                   MAJOR(__entry->dev), MINOR(__entry->dev),
2870                   __entry->agno,
2871                   __entry->bucket,
2872                   __entry->prev_agino,
2873                   __entry->next_agino)
2874 );
2875
2876 DECLARE_EVENT_CLASS(xrep_iunlink_resolve_class,
2877         TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
2878                  xfs_agino_t prev_agino, xfs_agino_t next_agino),
2879         TP_ARGS(pag, bucket, prev_agino, next_agino),
2880         TP_STRUCT__entry(
2881                 __field(dev_t, dev)
2882                 __field(xfs_agnumber_t, agno)
2883                 __field(unsigned int, bucket)
2884                 __field(xfs_agino_t, prev_agino)
2885                 __field(xfs_agino_t, next_agino)
2886         ),
2887         TP_fast_assign(
2888                 __entry->dev = pag->pag_mount->m_super->s_dev;
2889                 __entry->agno = pag->pag_agno;
2890                 __entry->bucket = bucket;
2891                 __entry->prev_agino = prev_agino;
2892                 __entry->next_agino = next_agino;
2893         ),
2894         TP_printk("dev %d:%d agno 0x%x bucket %u prev_agino 0x%x next_agino 0x%x",
2895                   MAJOR(__entry->dev), MINOR(__entry->dev),
2896                   __entry->agno,
2897                   __entry->bucket,
2898                   __entry->prev_agino,
2899                   __entry->next_agino)
2900 );
2901 #define DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(name) \
2902 DEFINE_EVENT(xrep_iunlink_resolve_class, name, \
2903         TP_PROTO(struct xfs_perag *pag, unsigned int bucket, \
2904                  xfs_agino_t prev_agino, xfs_agino_t next_agino), \
2905         TP_ARGS(pag, bucket, prev_agino, next_agino))
2906 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_uncached);
2907 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_wronglist);
2908 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_nolist);
2909 DEFINE_REPAIR_IUNLINK_RESOLVE_EVENT(xrep_iunlink_resolve_ok);
2910
2911 TRACE_EVENT(xrep_iunlink_relink_next,
2912         TP_PROTO(struct xfs_inode *ip, xfs_agino_t next_agino),
2913         TP_ARGS(ip, next_agino),
2914         TP_STRUCT__entry(
2915                 __field(dev_t, dev)
2916                 __field(xfs_agnumber_t, agno)
2917                 __field(xfs_agino_t, agino)
2918                 __field(xfs_agino_t, next_agino)
2919                 __field(xfs_agino_t, new_next_agino)
2920         ),
2921         TP_fast_assign(
2922                 __entry->dev = ip->i_mount->m_super->s_dev;
2923                 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
2924                 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
2925                 __entry->next_agino = ip->i_next_unlinked;
2926                 __entry->new_next_agino = next_agino;
2927         ),
2928         TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x next_agino 0x%x -> 0x%x",
2929                   MAJOR(__entry->dev), MINOR(__entry->dev),
2930                   __entry->agno,
2931                   __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
2932                   __entry->agino,
2933                   __entry->next_agino,
2934                   __entry->new_next_agino)
2935 );
2936
2937 TRACE_EVENT(xrep_iunlink_relink_prev,
2938         TP_PROTO(struct xfs_inode *ip, xfs_agino_t prev_agino),
2939         TP_ARGS(ip, prev_agino),
2940         TP_STRUCT__entry(
2941                 __field(dev_t, dev)
2942                 __field(xfs_agnumber_t, agno)
2943                 __field(xfs_agino_t, agino)
2944                 __field(xfs_agino_t, prev_agino)
2945                 __field(xfs_agino_t, new_prev_agino)
2946         ),
2947         TP_fast_assign(
2948                 __entry->dev = ip->i_mount->m_super->s_dev;
2949                 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino);
2950                 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino);
2951                 __entry->prev_agino = ip->i_prev_unlinked;
2952                 __entry->new_prev_agino = prev_agino;
2953         ),
2954         TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x prev_agino 0x%x -> 0x%x",
2955                   MAJOR(__entry->dev), MINOR(__entry->dev),
2956                   __entry->agno,
2957                   __entry->agino % XFS_AGI_UNLINKED_BUCKETS,
2958                   __entry->agino,
2959                   __entry->prev_agino,
2960                   __entry->new_prev_agino)
2961 );
2962
2963 TRACE_EVENT(xrep_iunlink_add_to_bucket,
2964         TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
2965                  xfs_agino_t agino, xfs_agino_t curr_head),
2966         TP_ARGS(pag, bucket, agino, curr_head),
2967         TP_STRUCT__entry(
2968                 __field(dev_t, dev)
2969                 __field(xfs_agnumber_t, agno)
2970                 __field(unsigned int, bucket)
2971                 __field(xfs_agino_t, agino)
2972                 __field(xfs_agino_t, next_agino)
2973         ),
2974         TP_fast_assign(
2975                 __entry->dev = pag->pag_mount->m_super->s_dev;
2976                 __entry->agno = pag->pag_agno;
2977                 __entry->bucket = bucket;
2978                 __entry->agino = agino;
2979                 __entry->next_agino = curr_head;
2980         ),
2981         TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x next_agino 0x%x",
2982                   MAJOR(__entry->dev), MINOR(__entry->dev),
2983                   __entry->agno,
2984                   __entry->bucket,
2985                   __entry->agino,
2986                   __entry->next_agino)
2987 );
2988
2989 TRACE_EVENT(xrep_iunlink_commit_bucket,
2990         TP_PROTO(struct xfs_perag *pag, unsigned int bucket,
2991                  xfs_agino_t old_agino, xfs_agino_t agino),
2992         TP_ARGS(pag, bucket, old_agino, agino),
2993         TP_STRUCT__entry(
2994                 __field(dev_t, dev)
2995                 __field(xfs_agnumber_t, agno)
2996                 __field(unsigned int, bucket)
2997                 __field(xfs_agino_t, old_agino)
2998                 __field(xfs_agino_t, agino)
2999         ),
3000         TP_fast_assign(
3001                 __entry->dev = pag->pag_mount->m_super->s_dev;
3002                 __entry->agno = pag->pag_agno;
3003                 __entry->bucket = bucket;
3004                 __entry->old_agino = old_agino;
3005                 __entry->agino = agino;
3006         ),
3007         TP_printk("dev %d:%d agno 0x%x bucket %u agino 0x%x -> 0x%x",
3008                   MAJOR(__entry->dev), MINOR(__entry->dev),
3009                   __entry->agno,
3010                   __entry->bucket,
3011                   __entry->old_agino,
3012                   __entry->agino)
3013 );
3014
3015 #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
3016
3017 #endif /* _TRACE_XFS_SCRUB_TRACE_H */
3018
3019 #undef TRACE_INCLUDE_PATH
3020 #define TRACE_INCLUDE_PATH .
3021 #define TRACE_INCLUDE_FILE scrub/trace
3022 #include <trace/define_trace.h>