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
  19 struct xfile;
  20 struct xfarray;
  21 struct xfarray_sortinfo;
  22
  23 /*
  24  * ftrace's __print_symbolic requires that all enum values be wrapped in the
  25  * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace
  26  * ring buffer.  Somehow this was only worth mentioning in the ftrace sample
  27  * code.
  28  */
  29 TRACE_DEFINE_ENUM(XFS_BTNUM_BNOi);
  30 TRACE_DEFINE_ENUM(XFS_BTNUM_CNTi);
  31 TRACE_DEFINE_ENUM(XFS_BTNUM_BMAPi);
  32 TRACE_DEFINE_ENUM(XFS_BTNUM_INOi);
  33 TRACE_DEFINE_ENUM(XFS_BTNUM_FINOi);
  34 TRACE_DEFINE_ENUM(XFS_BTNUM_RMAPi);
  35 TRACE_DEFINE_ENUM(XFS_BTNUM_REFCi);
  36
  37 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED);
  38 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW);
  39
  40 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PROBE);
  41 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SB);
  42 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGF);
  43 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGFL);
  44 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGI);
  45 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BNOBT);
  46 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_CNTBT);
  47 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INOBT);
  48 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FINOBT);
  49 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RMAPBT);
  50 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_REFCNTBT);
  51 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INODE);
  52 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTD);
  53 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTA);
  54 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTC);
  55 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_DIR);
  56 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_XATTR);
  57 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SYMLINK);
  58 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PARENT);
  59 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTBITMAP);
  60 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTSUM);
  61 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_UQUOTA);
  62 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_GQUOTA);
  63 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PQUOTA);
  64 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FSCOUNTERS);
  65
  66 #define XFS_SCRUB_TYPE_STRINGS \
  67         { XFS_SCRUB_TYPE_PROBE,         "probe" }, \
  68         { XFS_SCRUB_TYPE_SB,            "sb" }, \
  69         { XFS_SCRUB_TYPE_AGF,           "agf" }, \
  70         { XFS_SCRUB_TYPE_AGFL,          "agfl" }, \
  71         { XFS_SCRUB_TYPE_AGI,           "agi" }, \
  72         { XFS_SCRUB_TYPE_BNOBT,         "bnobt" }, \
  73         { XFS_SCRUB_TYPE_CNTBT,         "cntbt" }, \
  74         { XFS_SCRUB_TYPE_INOBT,         "inobt" }, \
  75         { XFS_SCRUB_TYPE_FINOBT,        "finobt" }, \
  76         { XFS_SCRUB_TYPE_RMAPBT,        "rmapbt" }, \
  77         { XFS_SCRUB_TYPE_REFCNTBT,      "refcountbt" }, \
  78         { XFS_SCRUB_TYPE_INODE,         "inode" }, \
  79         { XFS_SCRUB_TYPE_BMBTD,         "bmapbtd" }, \
  80         { XFS_SCRUB_TYPE_BMBTA,         "bmapbta" }, \
  81         { XFS_SCRUB_TYPE_BMBTC,         "bmapbtc" }, \
  82         { XFS_SCRUB_TYPE_DIR,           "directory" }, \
  83         { XFS_SCRUB_TYPE_XATTR,         "xattr" }, \
  84         { XFS_SCRUB_TYPE_SYMLINK,       "symlink" }, \
  85         { XFS_SCRUB_TYPE_PARENT,        "parent" }, \
  86         { XFS_SCRUB_TYPE_RTBITMAP,      "rtbitmap" }, \
  87         { XFS_SCRUB_TYPE_RTSUM,         "rtsummary" }, \
  88         { XFS_SCRUB_TYPE_UQUOTA,        "usrquota" }, \
  89         { XFS_SCRUB_TYPE_GQUOTA,        "grpquota" }, \
  90         { XFS_SCRUB_TYPE_PQUOTA,        "prjquota" }, \
  91         { XFS_SCRUB_TYPE_FSCOUNTERS,    "fscounters" }
  92
  93 #define XFS_SCRUB_FLAG_STRINGS \
  94         { XFS_SCRUB_IFLAG_REPAIR,               "repair" }, \
  95         { XFS_SCRUB_OFLAG_CORRUPT,              "corrupt" }, \
  96         { XFS_SCRUB_OFLAG_PREEN,                "preen" }, \
  97         { XFS_SCRUB_OFLAG_XFAIL,                "xfail" }, \
  98         { XFS_SCRUB_OFLAG_XCORRUPT,             "xcorrupt" }, \
  99         { XFS_SCRUB_OFLAG_INCOMPLETE,           "incomplete" }, \
 100         { XFS_SCRUB_OFLAG_WARNING,              "warning" }, \
 101         { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED,     "norepair" }
 102
 103 #define XFS_SCRUB_STATE_STRINGS \
 104         { XCHK_TRY_HARDER,                      "try_harder" }, \
 105         { XCHK_FSGATES_DRAIN,                   "fsgates_drain" }, \
 106         { XCHK_NEED_DRAIN,                      "need_drain" }, \
 107         { XREP_ALREADY_FIXED,                   "already_fixed" }
 108
 109 DECLARE_EVENT_CLASS(xchk_class,
 110         TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm,
 111                  int error),
 112         TP_ARGS(ip, sm, error),
 113         TP_STRUCT__entry(
 114                 __field(dev_t, dev)
 115                 __field(xfs_ino_t, ino)
 116                 __field(unsigned int, type)
 117                 __field(xfs_agnumber_t, agno)
 118                 __field(xfs_ino_t, inum)
 119                 __field(unsigned int, gen)
 120                 __field(unsigned int, flags)
 121                 __field(int, error)
 122         ),
 123         TP_fast_assign(
 124                 __entry->dev = ip->i_mount->m_super->s_dev;
 125                 __entry->ino = ip->i_ino;
 126                 __entry->type = sm->sm_type;
 127                 __entry->agno = sm->sm_agno;
 128                 __entry->inum = sm->sm_ino;
 129                 __entry->gen = sm->sm_gen;
 130                 __entry->flags = sm->sm_flags;
 131                 __entry->error = error;
 132         ),
 133         TP_printk("dev %d:%d ino 0x%llx type %s agno 0x%x inum 0x%llx gen 0x%x flags (%s) error %d",
 134                   MAJOR(__entry->dev), MINOR(__entry->dev),
 135                   __entry->ino,
 136                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 137                   __entry->agno,
 138                   __entry->inum,
 139                   __entry->gen,
 140                   __print_flags(__entry->flags, "|", XFS_SCRUB_FLAG_STRINGS),
 141                   __entry->error)
 142 )
 143 #define DEFINE_SCRUB_EVENT(name) \
 144 DEFINE_EVENT(xchk_class, name, \
 145         TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, \
 146                  int error), \
 147         TP_ARGS(ip, sm, error))
 148
 149 DEFINE_SCRUB_EVENT(xchk_start);
 150 DEFINE_SCRUB_EVENT(xchk_done);
 151 DEFINE_SCRUB_EVENT(xchk_deadlock_retry);
 152 DEFINE_SCRUB_EVENT(xrep_attempt);
 153 DEFINE_SCRUB_EVENT(xrep_done);
 154
 155 DECLARE_EVENT_CLASS(xchk_fsgate_class,
 156         TP_PROTO(struct xfs_scrub *sc, unsigned int fsgate_flags),
 157         TP_ARGS(sc, fsgate_flags),
 158         TP_STRUCT__entry(
 159                 __field(dev_t, dev)
 160                 __field(unsigned int, type)
 161                 __field(unsigned int, fsgate_flags)
 162         ),
 163         TP_fast_assign(
 164                 __entry->dev = sc->mp->m_super->s_dev;
 165                 __entry->type = sc->sm->sm_type;
 166                 __entry->fsgate_flags = fsgate_flags;
 167         ),
 168         TP_printk("dev %d:%d type %s fsgates '%s'",
 169                   MAJOR(__entry->dev), MINOR(__entry->dev),
 170                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 171                   __print_flags(__entry->fsgate_flags, "|", XFS_SCRUB_STATE_STRINGS))
 172 )
 173
 174 #define DEFINE_SCRUB_FSHOOK_EVENT(name) \
 175 DEFINE_EVENT(xchk_fsgate_class, name, \
 176         TP_PROTO(struct xfs_scrub *sc, unsigned int fsgates_flags), \
 177         TP_ARGS(sc, fsgates_flags))
 178
 179 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_enable);
 180 DEFINE_SCRUB_FSHOOK_EVENT(xchk_fsgates_disable);
 181
 182 TRACE_EVENT(xchk_op_error,
 183         TP_PROTO(struct xfs_scrub *sc, xfs_agnumber_t agno,
 184                  xfs_agblock_t bno, int error, void *ret_ip),
 185         TP_ARGS(sc, agno, bno, error, ret_ip),
 186         TP_STRUCT__entry(
 187                 __field(dev_t, dev)
 188                 __field(unsigned int, type)
 189                 __field(xfs_agnumber_t, agno)
 190                 __field(xfs_agblock_t, bno)
 191                 __field(int, error)
 192                 __field(void *, ret_ip)
 193         ),
 194         TP_fast_assign(
 195                 __entry->dev = sc->mp->m_super->s_dev;
 196                 __entry->type = sc->sm->sm_type;
 197                 __entry->agno = agno;
 198                 __entry->bno = bno;
 199                 __entry->error = error;
 200                 __entry->ret_ip = ret_ip;
 201         ),
 202         TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x error %d ret_ip %pS",
 203                   MAJOR(__entry->dev), MINOR(__entry->dev),
 204                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 205                   __entry->agno,
 206                   __entry->bno,
 207                   __entry->error,
 208                   __entry->ret_ip)
 209 );
 210
 211 TRACE_EVENT(xchk_file_op_error,
 212         TP_PROTO(struct xfs_scrub *sc, int whichfork,
 213                  xfs_fileoff_t offset, int error, void *ret_ip),
 214         TP_ARGS(sc, whichfork, offset, error, ret_ip),
 215         TP_STRUCT__entry(
 216                 __field(dev_t, dev)
 217                 __field(xfs_ino_t, ino)
 218                 __field(int, whichfork)
 219                 __field(unsigned int, type)
 220                 __field(xfs_fileoff_t, offset)
 221                 __field(int, error)
 222                 __field(void *, ret_ip)
 223         ),
 224         TP_fast_assign(
 225                 __entry->dev = sc->ip->i_mount->m_super->s_dev;
 226                 __entry->ino = sc->ip->i_ino;
 227                 __entry->whichfork = whichfork;
 228                 __entry->type = sc->sm->sm_type;
 229                 __entry->offset = offset;
 230                 __entry->error = error;
 231                 __entry->ret_ip = ret_ip;
 232         ),
 233         TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx error %d ret_ip %pS",
 234                   MAJOR(__entry->dev), MINOR(__entry->dev),
 235                   __entry->ino,
 236                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 237                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 238                   __entry->offset,
 239                   __entry->error,
 240                   __entry->ret_ip)
 241 );
 242
 243 DECLARE_EVENT_CLASS(xchk_block_error_class,
 244         TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, void *ret_ip),
 245         TP_ARGS(sc, daddr, ret_ip),
 246         TP_STRUCT__entry(
 247                 __field(dev_t, dev)
 248                 __field(unsigned int, type)
 249                 __field(xfs_agnumber_t, agno)
 250                 __field(xfs_agblock_t, agbno)
 251                 __field(void *, ret_ip)
 252         ),
 253         TP_fast_assign(
 254                 __entry->dev = sc->mp->m_super->s_dev;
 255                 __entry->type = sc->sm->sm_type;
 256                 __entry->agno = xfs_daddr_to_agno(sc->mp, daddr);
 257                 __entry->agbno = xfs_daddr_to_agbno(sc->mp, daddr);
 258                 __entry->ret_ip = ret_ip;
 259         ),
 260         TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x ret_ip %pS",
 261                   MAJOR(__entry->dev), MINOR(__entry->dev),
 262                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 263                   __entry->agno,
 264                   __entry->agbno,
 265                   __entry->ret_ip)
 266 )
 267
 268 #define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \
 269 DEFINE_EVENT(xchk_block_error_class, name, \
 270         TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, \
 271                  void *ret_ip), \
 272         TP_ARGS(sc, daddr, ret_ip))
 273
 274 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_fs_error);
 275 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_error);
 276 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_preen);
 277
 278 DECLARE_EVENT_CLASS(xchk_ino_error_class,
 279         TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, void *ret_ip),
 280         TP_ARGS(sc, ino, ret_ip),
 281         TP_STRUCT__entry(
 282                 __field(dev_t, dev)
 283                 __field(xfs_ino_t, ino)
 284                 __field(unsigned int, type)
 285                 __field(void *, ret_ip)
 286         ),
 287         TP_fast_assign(
 288                 __entry->dev = sc->mp->m_super->s_dev;
 289                 __entry->ino = ino;
 290                 __entry->type = sc->sm->sm_type;
 291                 __entry->ret_ip = ret_ip;
 292         ),
 293         TP_printk("dev %d:%d ino 0x%llx type %s ret_ip %pS",
 294                   MAJOR(__entry->dev), MINOR(__entry->dev),
 295                   __entry->ino,
 296                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 297                   __entry->ret_ip)
 298 )
 299
 300 #define DEFINE_SCRUB_INO_ERROR_EVENT(name) \
 301 DEFINE_EVENT(xchk_ino_error_class, name, \
 302         TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, \
 303                  void *ret_ip), \
 304         TP_ARGS(sc, ino, ret_ip))
 305
 306 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_error);
 307 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_preen);
 308 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_warning);
 309
 310 DECLARE_EVENT_CLASS(xchk_fblock_error_class,
 311         TP_PROTO(struct xfs_scrub *sc, int whichfork,
 312                  xfs_fileoff_t offset, void *ret_ip),
 313         TP_ARGS(sc, whichfork, offset, ret_ip),
 314         TP_STRUCT__entry(
 315                 __field(dev_t, dev)
 316                 __field(xfs_ino_t, ino)
 317                 __field(int, whichfork)
 318                 __field(unsigned int, type)
 319                 __field(xfs_fileoff_t, offset)
 320                 __field(void *, ret_ip)
 321         ),
 322         TP_fast_assign(
 323                 __entry->dev = sc->ip->i_mount->m_super->s_dev;
 324                 __entry->ino = sc->ip->i_ino;
 325                 __entry->whichfork = whichfork;
 326                 __entry->type = sc->sm->sm_type;
 327                 __entry->offset = offset;
 328                 __entry->ret_ip = ret_ip;
 329         ),
 330         TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx ret_ip %pS",
 331                   MAJOR(__entry->dev), MINOR(__entry->dev),
 332                   __entry->ino,
 333                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 334                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 335                   __entry->offset,
 336                   __entry->ret_ip)
 337 );
 338
 339 #define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \
 340 DEFINE_EVENT(xchk_fblock_error_class, name, \
 341         TP_PROTO(struct xfs_scrub *sc, int whichfork, \
 342                  xfs_fileoff_t offset, void *ret_ip), \
 343         TP_ARGS(sc, whichfork, offset, ret_ip))
 344
 345 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_error);
 346 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_warning);
 347
 348 TRACE_EVENT(xchk_incomplete,
 349         TP_PROTO(struct xfs_scrub *sc, void *ret_ip),
 350         TP_ARGS(sc, ret_ip),
 351         TP_STRUCT__entry(
 352                 __field(dev_t, dev)
 353                 __field(unsigned int, type)
 354                 __field(void *, ret_ip)
 355         ),
 356         TP_fast_assign(
 357                 __entry->dev = sc->mp->m_super->s_dev;
 358                 __entry->type = sc->sm->sm_type;
 359                 __entry->ret_ip = ret_ip;
 360         ),
 361         TP_printk("dev %d:%d type %s ret_ip %pS",
 362                   MAJOR(__entry->dev), MINOR(__entry->dev),
 363                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 364                   __entry->ret_ip)
 365 );
 366
 367 TRACE_EVENT(xchk_btree_op_error,
 368         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 369                  int level, int error, void *ret_ip),
 370         TP_ARGS(sc, cur, level, error, ret_ip),
 371         TP_STRUCT__entry(
 372                 __field(dev_t, dev)
 373                 __field(unsigned int, type)
 374                 __field(xfs_btnum_t, btnum)
 375                 __field(int, level)
 376                 __field(xfs_agnumber_t, agno)
 377                 __field(xfs_agblock_t, bno)
 378                 __field(int, ptr)
 379                 __field(int, error)
 380                 __field(void *, ret_ip)
 381         ),
 382         TP_fast_assign(
 383                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 384
 385                 __entry->dev = sc->mp->m_super->s_dev;
 386                 __entry->type = sc->sm->sm_type;
 387                 __entry->btnum = cur->bc_btnum;
 388                 __entry->level = level;
 389                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 390                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 391                 __entry->ptr = cur->bc_levels[level].ptr;
 392                 __entry->error = error;
 393                 __entry->ret_ip = ret_ip;
 394         ),
 395         TP_printk("dev %d:%d type %s btree %s level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS",
 396                   MAJOR(__entry->dev), MINOR(__entry->dev),
 397                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 398                   __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
 399                   __entry->level,
 400                   __entry->ptr,
 401                   __entry->agno,
 402                   __entry->bno,
 403                   __entry->error,
 404                   __entry->ret_ip)
 405 );
 406
 407 TRACE_EVENT(xchk_ifork_btree_op_error,
 408         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 409                  int level, int error, void *ret_ip),
 410         TP_ARGS(sc, cur, level, error, ret_ip),
 411         TP_STRUCT__entry(
 412                 __field(dev_t, dev)
 413                 __field(xfs_ino_t, ino)
 414                 __field(int, whichfork)
 415                 __field(unsigned int, type)
 416                 __field(xfs_btnum_t, btnum)
 417                 __field(int, level)
 418                 __field(int, ptr)
 419                 __field(xfs_agnumber_t, agno)
 420                 __field(xfs_agblock_t, bno)
 421                 __field(int, error)
 422                 __field(void *, ret_ip)
 423         ),
 424         TP_fast_assign(
 425                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 426                 __entry->dev = sc->mp->m_super->s_dev;
 427                 __entry->ino = sc->ip->i_ino;
 428                 __entry->whichfork = cur->bc_ino.whichfork;
 429                 __entry->type = sc->sm->sm_type;
 430                 __entry->btnum = cur->bc_btnum;
 431                 __entry->level = level;
 432                 __entry->ptr = cur->bc_levels[level].ptr;
 433                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 434                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 435                 __entry->error = error;
 436                 __entry->ret_ip = ret_ip;
 437         ),
 438         TP_printk("dev %d:%d ino 0x%llx fork %s type %s btree %s level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS",
 439                   MAJOR(__entry->dev), MINOR(__entry->dev),
 440                   __entry->ino,
 441                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 442                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 443                   __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
 444                   __entry->level,
 445                   __entry->ptr,
 446                   __entry->agno,
 447                   __entry->bno,
 448                   __entry->error,
 449                   __entry->ret_ip)
 450 );
 451
 452 TRACE_EVENT(xchk_btree_error,
 453         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 454                  int level, void *ret_ip),
 455         TP_ARGS(sc, cur, level, ret_ip),
 456         TP_STRUCT__entry(
 457                 __field(dev_t, dev)
 458                 __field(unsigned int, type)
 459                 __field(xfs_btnum_t, btnum)
 460                 __field(int, level)
 461                 __field(xfs_agnumber_t, agno)
 462                 __field(xfs_agblock_t, bno)
 463                 __field(int, ptr)
 464                 __field(void *, ret_ip)
 465         ),
 466         TP_fast_assign(
 467                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 468                 __entry->dev = sc->mp->m_super->s_dev;
 469                 __entry->type = sc->sm->sm_type;
 470                 __entry->btnum = cur->bc_btnum;
 471                 __entry->level = level;
 472                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 473                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 474                 __entry->ptr = cur->bc_levels[level].ptr;
 475                 __entry->ret_ip = ret_ip;
 476         ),
 477         TP_printk("dev %d:%d type %s btree %s level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS",
 478                   MAJOR(__entry->dev), MINOR(__entry->dev),
 479                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 480                   __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
 481                   __entry->level,
 482                   __entry->ptr,
 483                   __entry->agno,
 484                   __entry->bno,
 485                   __entry->ret_ip)
 486 );
 487
 488 TRACE_EVENT(xchk_ifork_btree_error,
 489         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 490                  int level, void *ret_ip),
 491         TP_ARGS(sc, cur, level, ret_ip),
 492         TP_STRUCT__entry(
 493                 __field(dev_t, dev)
 494                 __field(xfs_ino_t, ino)
 495                 __field(int, whichfork)
 496                 __field(unsigned int, type)
 497                 __field(xfs_btnum_t, btnum)
 498                 __field(int, level)
 499                 __field(xfs_agnumber_t, agno)
 500                 __field(xfs_agblock_t, bno)
 501                 __field(int, ptr)
 502                 __field(void *, ret_ip)
 503         ),
 504         TP_fast_assign(
 505                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 506                 __entry->dev = sc->mp->m_super->s_dev;
 507                 __entry->ino = sc->ip->i_ino;
 508                 __entry->whichfork = cur->bc_ino.whichfork;
 509                 __entry->type = sc->sm->sm_type;
 510                 __entry->btnum = cur->bc_btnum;
 511                 __entry->level = level;
 512                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 513                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 514                 __entry->ptr = cur->bc_levels[level].ptr;
 515                 __entry->ret_ip = ret_ip;
 516         ),
 517         TP_printk("dev %d:%d ino 0x%llx fork %s type %s btree %s level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS",
 518                   MAJOR(__entry->dev), MINOR(__entry->dev),
 519                   __entry->ino,
 520                   __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
 521                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 522                   __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
 523                   __entry->level,
 524                   __entry->ptr,
 525                   __entry->agno,
 526                   __entry->bno,
 527                   __entry->ret_ip)
 528 );
 529
 530 DECLARE_EVENT_CLASS(xchk_sbtree_class,
 531         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 532                  int level),
 533         TP_ARGS(sc, cur, level),
 534         TP_STRUCT__entry(
 535                 __field(dev_t, dev)
 536                 __field(int, type)
 537                 __field(xfs_btnum_t, btnum)
 538                 __field(xfs_agnumber_t, agno)
 539                 __field(xfs_agblock_t, bno)
 540                 __field(int, level)
 541                 __field(int, nlevels)
 542                 __field(int, ptr)
 543         ),
 544         TP_fast_assign(
 545                 xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
 546
 547                 __entry->dev = sc->mp->m_super->s_dev;
 548                 __entry->type = sc->sm->sm_type;
 549                 __entry->btnum = cur->bc_btnum;
 550                 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
 551                 __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
 552                 __entry->level = level;
 553                 __entry->nlevels = cur->bc_nlevels;
 554                 __entry->ptr = cur->bc_levels[level].ptr;
 555         ),
 556         TP_printk("dev %d:%d type %s btree %s agno 0x%x agbno 0x%x level %d nlevels %d ptr %d",
 557                   MAJOR(__entry->dev), MINOR(__entry->dev),
 558                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 559                   __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
 560                   __entry->agno,
 561                   __entry->bno,
 562                   __entry->level,
 563                   __entry->nlevels,
 564                   __entry->ptr)
 565 )
 566 #define DEFINE_SCRUB_SBTREE_EVENT(name) \
 567 DEFINE_EVENT(xchk_sbtree_class, name, \
 568         TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, \
 569                  int level), \
 570         TP_ARGS(sc, cur, level))
 571
 572 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_rec);
 573 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_key);
 574
 575 TRACE_EVENT(xchk_xref_error,
 576         TP_PROTO(struct xfs_scrub *sc, int error, void *ret_ip),
 577         TP_ARGS(sc, error, ret_ip),
 578         TP_STRUCT__entry(
 579                 __field(dev_t, dev)
 580                 __field(int, type)
 581                 __field(int, error)
 582                 __field(void *, ret_ip)
 583         ),
 584         TP_fast_assign(
 585                 __entry->dev = sc->mp->m_super->s_dev;
 586                 __entry->type = sc->sm->sm_type;
 587                 __entry->error = error;
 588                 __entry->ret_ip = ret_ip;
 589         ),
 590         TP_printk("dev %d:%d type %s xref error %d ret_ip %pS",
 591                   MAJOR(__entry->dev), MINOR(__entry->dev),
 592                   __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
 593                   __entry->error,
 594                   __entry->ret_ip)
 595 );
 596
 597 TRACE_EVENT(xchk_iallocbt_check_cluster,
 598         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
 599                  xfs_agino_t startino, xfs_daddr_t map_daddr,
 600                  unsigned short map_len, unsigned int chunk_ino,
 601                  unsigned int nr_inodes, uint16_t cluster_mask,
 602                  uint16_t holemask, unsigned int cluster_ino),
 603         TP_ARGS(mp, agno, startino, map_daddr, map_len, chunk_ino, nr_inodes,
 604                 cluster_mask, holemask, cluster_ino),
 605         TP_STRUCT__entry(
 606                 __field(dev_t, dev)
 607                 __field(xfs_agnumber_t, agno)
 608                 __field(xfs_agino_t, startino)
 609                 __field(xfs_daddr_t, map_daddr)
 610                 __field(unsigned short, map_len)
 611                 __field(unsigned int, chunk_ino)
 612                 __field(unsigned int, nr_inodes)
 613                 __field(unsigned int, cluster_ino)
 614                 __field(uint16_t, cluster_mask)
 615                 __field(uint16_t, holemask)
 616         ),
 617         TP_fast_assign(
 618                 __entry->dev = mp->m_super->s_dev;
 619                 __entry->agno = agno;
 620                 __entry->startino = startino;
 621                 __entry->map_daddr = map_daddr;
 622                 __entry->map_len = map_len;
 623                 __entry->chunk_ino = chunk_ino;
 624                 __entry->nr_inodes = nr_inodes;
 625                 __entry->cluster_mask = cluster_mask;
 626                 __entry->holemask = holemask;
 627                 __entry->cluster_ino = cluster_ino;
 628         ),
 629         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",
 630                   MAJOR(__entry->dev), MINOR(__entry->dev),
 631                   __entry->agno,
 632                   __entry->startino,
 633                   __entry->map_daddr,
 634                   __entry->map_len,
 635                   __entry->chunk_ino,
 636                   __entry->nr_inodes,
 637                   __entry->cluster_mask,
 638                   __entry->holemask,
 639                   __entry->cluster_ino)
 640 )
 641
 642 TRACE_EVENT(xchk_fscounters_calc,
 643         TP_PROTO(struct xfs_mount *mp, uint64_t icount, uint64_t ifree,
 644                  uint64_t fdblocks, uint64_t delalloc),
 645         TP_ARGS(mp, icount, ifree, fdblocks, delalloc),
 646         TP_STRUCT__entry(
 647                 __field(dev_t, dev)
 648                 __field(int64_t, icount_sb)
 649                 __field(uint64_t, icount_calculated)
 650                 __field(int64_t, ifree_sb)
 651                 __field(uint64_t, ifree_calculated)
 652                 __field(int64_t, fdblocks_sb)
 653                 __field(uint64_t, fdblocks_calculated)
 654                 __field(uint64_t, delalloc)
 655         ),
 656         TP_fast_assign(
 657                 __entry->dev = mp->m_super->s_dev;
 658                 __entry->icount_sb = mp->m_sb.sb_icount;
 659                 __entry->icount_calculated = icount;
 660                 __entry->ifree_sb = mp->m_sb.sb_ifree;
 661                 __entry->ifree_calculated = ifree;
 662                 __entry->fdblocks_sb = mp->m_sb.sb_fdblocks;
 663                 __entry->fdblocks_calculated = fdblocks;
 664                 __entry->delalloc = delalloc;
 665         ),
 666         TP_printk("dev %d:%d icount %lld:%llu ifree %lld::%llu fdblocks %lld::%llu delalloc %llu",
 667                   MAJOR(__entry->dev), MINOR(__entry->dev),
 668                   __entry->icount_sb,
 669                   __entry->icount_calculated,
 670                   __entry->ifree_sb,
 671                   __entry->ifree_calculated,
 672                   __entry->fdblocks_sb,
 673                   __entry->fdblocks_calculated,
 674                   __entry->delalloc)
 675 )
 676
 677 TRACE_EVENT(xchk_fscounters_within_range,
 678         TP_PROTO(struct xfs_mount *mp, uint64_t expected, int64_t curr_value,
 679                  int64_t old_value),
 680         TP_ARGS(mp, expected, curr_value, old_value),
 681         TP_STRUCT__entry(
 682                 __field(dev_t, dev)
 683                 __field(uint64_t, expected)
 684                 __field(int64_t, curr_value)
 685                 __field(int64_t, old_value)
 686         ),
 687         TP_fast_assign(
 688                 __entry->dev = mp->m_super->s_dev;
 689                 __entry->expected = expected;
 690                 __entry->curr_value = curr_value;
 691                 __entry->old_value = old_value;
 692         ),
 693         TP_printk("dev %d:%d expected %llu curr_value %lld old_value %lld",
 694                   MAJOR(__entry->dev), MINOR(__entry->dev),
 695                   __entry->expected,
 696                   __entry->curr_value,
 697                   __entry->old_value)
 698 )
 699
 700 TRACE_EVENT(xchk_refcount_incorrect,
 701         TP_PROTO(struct xfs_perag *pag, const struct xfs_refcount_irec *irec,
 702                  xfs_nlink_t seen),
 703         TP_ARGS(pag, irec, seen),
 704         TP_STRUCT__entry(
 705                 __field(dev_t, dev)
 706                 __field(xfs_agnumber_t, agno)
 707                 __field(enum xfs_refc_domain, domain)
 708                 __field(xfs_agblock_t, startblock)
 709                 __field(xfs_extlen_t, blockcount)
 710                 __field(xfs_nlink_t, refcount)
 711                 __field(xfs_nlink_t, seen)
 712         ),
 713         TP_fast_assign(
 714                 __entry->dev = pag->pag_mount->m_super->s_dev;
 715                 __entry->agno = pag->pag_agno;
 716                 __entry->domain = irec->rc_domain;
 717                 __entry->startblock = irec->rc_startblock;
 718                 __entry->blockcount = irec->rc_blockcount;
 719                 __entry->refcount = irec->rc_refcount;
 720                 __entry->seen = seen;
 721         ),
 722         TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u seen %u",
 723                   MAJOR(__entry->dev), MINOR(__entry->dev),
 724                   __entry->agno,
 725                   __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS),
 726                   __entry->startblock,
 727                   __entry->blockcount,
 728                   __entry->refcount,
 729                   __entry->seen)
 730 )
 731
 732 TRACE_EVENT(xfile_create,
 733         TP_PROTO(struct xfile *xf),
 734         TP_ARGS(xf),
 735         TP_STRUCT__entry(
 736                 __field(dev_t, dev)
 737                 __field(unsigned long, ino)
 738                 __array(char, pathname, 256)
 739         ),
 740         TP_fast_assign(
 741                 char            pathname[257];
 742                 char            *path;
 743
 744                 __entry->ino = file_inode(xf->file)->i_ino;
 745                 memset(pathname, 0, sizeof(pathname));
 746                 path = file_path(xf->file, pathname, sizeof(pathname) - 1);
 747                 if (IS_ERR(path))
 748                         path = "(unknown)";
 749                 strncpy(__entry->pathname, path, sizeof(__entry->pathname));
 750         ),
 751         TP_printk("xfino 0x%lx path '%s'",
 752                   __entry->ino,
 753                   __entry->pathname)
 754 );
 755
 756 TRACE_EVENT(xfile_destroy,
 757         TP_PROTO(struct xfile *xf),
 758         TP_ARGS(xf),
 759         TP_STRUCT__entry(
 760                 __field(unsigned long, ino)
 761                 __field(unsigned long long, bytes)
 762                 __field(loff_t, size)
 763         ),
 764         TP_fast_assign(
 765                 struct xfile_stat       statbuf;
 766                 int                     ret;
 767
 768                 ret = xfile_stat(xf, &statbuf);
 769                 if (!ret) {
 770                         __entry->bytes = statbuf.bytes;
 771                         __entry->size = statbuf.size;
 772                 } else {
 773                         __entry->bytes = -1;
 774                         __entry->size = -1;
 775                 }
 776                 __entry->ino = file_inode(xf->file)->i_ino;
 777         ),
 778         TP_printk("xfino 0x%lx mem_bytes 0x%llx isize 0x%llx",
 779                   __entry->ino,
 780                   __entry->bytes,
 781                   __entry->size)
 782 );
 783
 784 DECLARE_EVENT_CLASS(xfile_class,
 785         TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount),
 786         TP_ARGS(xf, pos, bytecount),
 787         TP_STRUCT__entry(
 788                 __field(unsigned long, ino)
 789                 __field(unsigned long long, bytes_used)
 790                 __field(loff_t, pos)
 791                 __field(loff_t, size)
 792                 __field(unsigned long long, bytecount)
 793         ),
 794         TP_fast_assign(
 795                 struct xfile_stat       statbuf;
 796                 int                     ret;
 797
 798                 ret = xfile_stat(xf, &statbuf);
 799                 if (!ret) {
 800                         __entry->bytes_used = statbuf.bytes;
 801                         __entry->size = statbuf.size;
 802                 } else {
 803                         __entry->bytes_used = -1;
 804                         __entry->size = -1;
 805                 }
 806                 __entry->ino = file_inode(xf->file)->i_ino;
 807                 __entry->pos = pos;
 808                 __entry->bytecount = bytecount;
 809         ),
 810         TP_printk("xfino 0x%lx mem_bytes 0x%llx pos 0x%llx bytecount 0x%llx isize 0x%llx",
 811                   __entry->ino,
 812                   __entry->bytes_used,
 813                   __entry->pos,
 814                   __entry->bytecount,
 815                   __entry->size)
 816 );
 817 #define DEFINE_XFILE_EVENT(name) \
 818 DEFINE_EVENT(xfile_class, name, \
 819         TP_PROTO(struct xfile *xf, loff_t pos, unsigned long long bytecount), \
 820         TP_ARGS(xf, pos, bytecount))
 821 DEFINE_XFILE_EVENT(xfile_pread);
 822 DEFINE_XFILE_EVENT(xfile_pwrite);
 823 DEFINE_XFILE_EVENT(xfile_seek_data);
 824
 825 TRACE_EVENT(xfarray_create,
 826         TP_PROTO(struct xfarray *xfa, unsigned long long required_capacity),
 827         TP_ARGS(xfa, required_capacity),
 828         TP_STRUCT__entry(
 829                 __field(unsigned long, ino)
 830                 __field(uint64_t, max_nr)
 831                 __field(size_t, obj_size)
 832                 __field(int, obj_size_log)
 833                 __field(unsigned long long, required_capacity)
 834         ),
 835         TP_fast_assign(
 836                 __entry->max_nr = xfa->max_nr;
 837                 __entry->obj_size = xfa->obj_size;
 838                 __entry->obj_size_log = xfa->obj_size_log;
 839                 __entry->ino = file_inode(xfa->xfile->file)->i_ino;
 840                 __entry->required_capacity = required_capacity;
 841         ),
 842         TP_printk("xfino 0x%lx max_nr %llu reqd_nr %llu objsz %zu objszlog %d",
 843                   __entry->ino,
 844                   __entry->max_nr,
 845                   __entry->required_capacity,
 846                   __entry->obj_size,
 847                   __entry->obj_size_log)
 848 );
 849
 850 TRACE_EVENT(xfarray_isort,
 851         TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
 852         TP_ARGS(si, lo, hi),
 853         TP_STRUCT__entry(
 854                 __field(unsigned long, ino)
 855                 __field(unsigned long long, lo)
 856                 __field(unsigned long long, hi)
 857         ),
 858         TP_fast_assign(
 859                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
 860                 __entry->lo = lo;
 861                 __entry->hi = hi;
 862         ),
 863         TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu",
 864                   __entry->ino,
 865                   __entry->lo,
 866                   __entry->hi,
 867                   __entry->hi - __entry->lo)
 868 );
 869
 870 TRACE_EVENT(xfarray_qsort,
 871         TP_PROTO(struct xfarray_sortinfo *si, uint64_t lo, uint64_t hi),
 872         TP_ARGS(si, lo, hi),
 873         TP_STRUCT__entry(
 874                 __field(unsigned long, ino)
 875                 __field(unsigned long long, lo)
 876                 __field(unsigned long long, hi)
 877                 __field(int, stack_depth)
 878                 __field(int, max_stack_depth)
 879         ),
 880         TP_fast_assign(
 881                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
 882                 __entry->lo = lo;
 883                 __entry->hi = hi;
 884                 __entry->stack_depth = si->stack_depth;
 885                 __entry->max_stack_depth = si->max_stack_depth;
 886         ),
 887         TP_printk("xfino 0x%lx lo %llu hi %llu elts %llu stack %d/%d",
 888                   __entry->ino,
 889                   __entry->lo,
 890                   __entry->hi,
 891                   __entry->hi - __entry->lo,
 892                   __entry->stack_depth,
 893                   __entry->max_stack_depth)
 894 );
 895
 896 TRACE_EVENT(xfarray_sort,
 897         TP_PROTO(struct xfarray_sortinfo *si, size_t bytes),
 898         TP_ARGS(si, bytes),
 899         TP_STRUCT__entry(
 900                 __field(unsigned long, ino)
 901                 __field(unsigned long long, nr)
 902                 __field(size_t, obj_size)
 903                 __field(size_t, bytes)
 904                 __field(unsigned int, max_stack_depth)
 905         ),
 906         TP_fast_assign(
 907                 __entry->nr = si->array->nr;
 908                 __entry->obj_size = si->array->obj_size;
 909                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
 910                 __entry->bytes = bytes;
 911                 __entry->max_stack_depth = si->max_stack_depth;
 912         ),
 913         TP_printk("xfino 0x%lx nr %llu objsz %zu stack %u bytes %zu",
 914                   __entry->ino,
 915                   __entry->nr,
 916                   __entry->obj_size,
 917                   __entry->max_stack_depth,
 918                   __entry->bytes)
 919 );
 920
 921 TRACE_EVENT(xfarray_sort_stats,
 922         TP_PROTO(struct xfarray_sortinfo *si, int error),
 923         TP_ARGS(si, error),
 924         TP_STRUCT__entry(
 925                 __field(unsigned long, ino)
 926 #ifdef DEBUG
 927                 __field(unsigned long long, loads)
 928                 __field(unsigned long long, stores)
 929                 __field(unsigned long long, compares)
 930                 __field(unsigned long long, heapsorts)
 931 #endif
 932                 __field(unsigned int, max_stack_depth)
 933                 __field(unsigned int, max_stack_used)
 934                 __field(int, error)
 935         ),
 936         TP_fast_assign(
 937                 __entry->ino = file_inode(si->array->xfile->file)->i_ino;
 938 #ifdef DEBUG
 939                 __entry->loads = si->loads;
 940                 __entry->stores = si->stores;
 941                 __entry->compares = si->compares;
 942                 __entry->heapsorts = si->heapsorts;
 943 #endif
 944                 __entry->max_stack_depth = si->max_stack_depth;
 945                 __entry->max_stack_used = si->max_stack_used;
 946                 __entry->error = error;
 947         ),
 948         TP_printk(
 949 #ifdef DEBUG
 950                   "xfino 0x%lx loads %llu stores %llu compares %llu heapsorts %llu stack_depth %u/%u error %d",
 951 #else
 952                   "xfino 0x%lx stack_depth %u/%u error %d",
 953 #endif
 954                   __entry->ino,
 955 #ifdef DEBUG
 956                   __entry->loads,
 957                   __entry->stores,
 958                   __entry->compares,
 959                   __entry->heapsorts,
 960 #endif
 961                   __entry->max_stack_used,
 962                   __entry->max_stack_depth,
 963                   __entry->error)
 964 );
 965
 966 /* repair tracepoints */
 967 #if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR)
 968
 969 DECLARE_EVENT_CLASS(xrep_extent_class,
 970         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len),
 971         TP_ARGS(pag, agbno, len),
 972         TP_STRUCT__entry(
 973                 __field(dev_t, dev)
 974                 __field(xfs_agnumber_t, agno)
 975                 __field(xfs_agblock_t, agbno)
 976                 __field(xfs_extlen_t, len)
 977         ),
 978         TP_fast_assign(
 979                 __entry->dev = pag->pag_mount->m_super->s_dev;
 980                 __entry->agno = pag->pag_agno;
 981                 __entry->agbno = agbno;
 982                 __entry->len = len;
 983         ),
 984         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
 985                   MAJOR(__entry->dev), MINOR(__entry->dev),
 986                   __entry->agno,
 987                   __entry->agbno,
 988                   __entry->len)
 989 );
 990 #define DEFINE_REPAIR_EXTENT_EVENT(name) \
 991 DEFINE_EVENT(xrep_extent_class, name, \
 992         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len), \
 993         TP_ARGS(pag, agbno, len))
 994 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_unmap_extent);
 995 DEFINE_REPAIR_EXTENT_EVENT(xreap_dispose_free_extent);
 996 DEFINE_REPAIR_EXTENT_EVENT(xreap_agextent_binval);
 997 DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert);
 998
 999 DECLARE_EVENT_CLASS(xrep_reap_find_class,
1000         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len,
1001                 bool crosslinked),
1002         TP_ARGS(pag, agbno, len, crosslinked),
1003         TP_STRUCT__entry(
1004                 __field(dev_t, dev)
1005                 __field(xfs_agnumber_t, agno)
1006                 __field(xfs_agblock_t, agbno)
1007                 __field(xfs_extlen_t, len)
1008                 __field(bool, crosslinked)
1009         ),
1010         TP_fast_assign(
1011                 __entry->dev = pag->pag_mount->m_super->s_dev;
1012                 __entry->agno = pag->pag_agno;
1013                 __entry->agbno = agbno;
1014                 __entry->len = len;
1015                 __entry->crosslinked = crosslinked;
1016         ),
1017         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x crosslinked %d",
1018                   MAJOR(__entry->dev), MINOR(__entry->dev),
1019                   __entry->agno,
1020                   __entry->agbno,
1021                   __entry->len,
1022                   __entry->crosslinked ? 1 : 0)
1023 );
1024 #define DEFINE_REPAIR_REAP_FIND_EVENT(name) \
1025 DEFINE_EVENT(xrep_reap_find_class, name, \
1026         TP_PROTO(struct xfs_perag *pag, xfs_agblock_t agbno, xfs_extlen_t len, \
1027                  bool crosslinked), \
1028         TP_ARGS(pag, agbno, len, crosslinked))
1029 DEFINE_REPAIR_REAP_FIND_EVENT(xreap_agextent_select);
1030
1031 DECLARE_EVENT_CLASS(xrep_rmap_class,
1032         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1033                  xfs_agblock_t agbno, xfs_extlen_t len,
1034                  uint64_t owner, uint64_t offset, unsigned int flags),
1035         TP_ARGS(mp, agno, agbno, len, owner, offset, flags),
1036         TP_STRUCT__entry(
1037                 __field(dev_t, dev)
1038                 __field(xfs_agnumber_t, agno)
1039                 __field(xfs_agblock_t, agbno)
1040                 __field(xfs_extlen_t, len)
1041                 __field(uint64_t, owner)
1042                 __field(uint64_t, offset)
1043                 __field(unsigned int, flags)
1044         ),
1045         TP_fast_assign(
1046                 __entry->dev = mp->m_super->s_dev;
1047                 __entry->agno = agno;
1048                 __entry->agbno = agbno;
1049                 __entry->len = len;
1050                 __entry->owner = owner;
1051                 __entry->offset = offset;
1052                 __entry->flags = flags;
1053         ),
1054         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
1055                   MAJOR(__entry->dev), MINOR(__entry->dev),
1056                   __entry->agno,
1057                   __entry->agbno,
1058                   __entry->len,
1059                   __entry->owner,
1060                   __entry->offset,
1061                   __entry->flags)
1062 );
1063 #define DEFINE_REPAIR_RMAP_EVENT(name) \
1064 DEFINE_EVENT(xrep_rmap_class, name, \
1065         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
1066                  xfs_agblock_t agbno, xfs_extlen_t len, \
1067                  uint64_t owner, uint64_t offset, unsigned int flags), \
1068         TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
1069 DEFINE_REPAIR_RMAP_EVENT(xrep_alloc_extent_fn);
1070 DEFINE_REPAIR_RMAP_EVENT(xrep_ialloc_extent_fn);
1071 DEFINE_REPAIR_RMAP_EVENT(xrep_rmap_extent_fn);
1072 DEFINE_REPAIR_RMAP_EVENT(xrep_bmap_extent_fn);
1073
1074 TRACE_EVENT(xrep_refcount_extent_fn,
1075         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1076                  struct xfs_refcount_irec *irec),
1077         TP_ARGS(mp, agno, irec),
1078         TP_STRUCT__entry(
1079                 __field(dev_t, dev)
1080                 __field(xfs_agnumber_t, agno)
1081                 __field(xfs_agblock_t, startblock)
1082                 __field(xfs_extlen_t, blockcount)
1083                 __field(xfs_nlink_t, refcount)
1084         ),
1085         TP_fast_assign(
1086                 __entry->dev = mp->m_super->s_dev;
1087                 __entry->agno = agno;
1088                 __entry->startblock = irec->rc_startblock;
1089                 __entry->blockcount = irec->rc_blockcount;
1090                 __entry->refcount = irec->rc_refcount;
1091         ),
1092         TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x refcount %u",
1093                   MAJOR(__entry->dev), MINOR(__entry->dev),
1094                   __entry->agno,
1095                   __entry->startblock,
1096                   __entry->blockcount,
1097                   __entry->refcount)
1098 )
1099
1100 TRACE_EVENT(xrep_findroot_block,
1101         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
1102                  uint32_t magic, uint16_t level),
1103         TP_ARGS(mp, agno, agbno, magic, level),
1104         TP_STRUCT__entry(
1105                 __field(dev_t, dev)
1106                 __field(xfs_agnumber_t, agno)
1107                 __field(xfs_agblock_t, agbno)
1108                 __field(uint32_t, magic)
1109                 __field(uint16_t, level)
1110         ),
1111         TP_fast_assign(
1112                 __entry->dev = mp->m_super->s_dev;
1113                 __entry->agno = agno;
1114                 __entry->agbno = agbno;
1115                 __entry->magic = magic;
1116                 __entry->level = level;
1117         ),
1118         TP_printk("dev %d:%d agno 0x%x agbno 0x%x magic 0x%x level %u",
1119                   MAJOR(__entry->dev), MINOR(__entry->dev),
1120                   __entry->agno,
1121                   __entry->agbno,
1122                   __entry->magic,
1123                   __entry->level)
1124 )
1125 TRACE_EVENT(xrep_calc_ag_resblks,
1126         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1127                  xfs_agino_t icount, xfs_agblock_t aglen, xfs_agblock_t freelen,
1128                  xfs_agblock_t usedlen),
1129         TP_ARGS(mp, agno, icount, aglen, freelen, usedlen),
1130         TP_STRUCT__entry(
1131                 __field(dev_t, dev)
1132                 __field(xfs_agnumber_t, agno)
1133                 __field(xfs_agino_t, icount)
1134                 __field(xfs_agblock_t, aglen)
1135                 __field(xfs_agblock_t, freelen)
1136                 __field(xfs_agblock_t, usedlen)
1137         ),
1138         TP_fast_assign(
1139                 __entry->dev = mp->m_super->s_dev;
1140                 __entry->agno = agno;
1141                 __entry->icount = icount;
1142                 __entry->aglen = aglen;
1143                 __entry->freelen = freelen;
1144                 __entry->usedlen = usedlen;
1145         ),
1146         TP_printk("dev %d:%d agno 0x%x icount %u aglen %u freelen %u usedlen %u",
1147                   MAJOR(__entry->dev), MINOR(__entry->dev),
1148                   __entry->agno,
1149                   __entry->icount,
1150                   __entry->aglen,
1151                   __entry->freelen,
1152                   __entry->usedlen)
1153 )
1154 TRACE_EVENT(xrep_calc_ag_resblks_btsize,
1155         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1156                  xfs_agblock_t bnobt_sz, xfs_agblock_t inobt_sz,
1157                  xfs_agblock_t rmapbt_sz, xfs_agblock_t refcbt_sz),
1158         TP_ARGS(mp, agno, bnobt_sz, inobt_sz, rmapbt_sz, refcbt_sz),
1159         TP_STRUCT__entry(
1160                 __field(dev_t, dev)
1161                 __field(xfs_agnumber_t, agno)
1162                 __field(xfs_agblock_t, bnobt_sz)
1163                 __field(xfs_agblock_t, inobt_sz)
1164                 __field(xfs_agblock_t, rmapbt_sz)
1165                 __field(xfs_agblock_t, refcbt_sz)
1166         ),
1167         TP_fast_assign(
1168                 __entry->dev = mp->m_super->s_dev;
1169                 __entry->agno = agno;
1170                 __entry->bnobt_sz = bnobt_sz;
1171                 __entry->inobt_sz = inobt_sz;
1172                 __entry->rmapbt_sz = rmapbt_sz;
1173                 __entry->refcbt_sz = refcbt_sz;
1174         ),
1175         TP_printk("dev %d:%d agno 0x%x bnobt %u inobt %u rmapbt %u refcountbt %u",
1176                   MAJOR(__entry->dev), MINOR(__entry->dev),
1177                   __entry->agno,
1178                   __entry->bnobt_sz,
1179                   __entry->inobt_sz,
1180                   __entry->rmapbt_sz,
1181                   __entry->refcbt_sz)
1182 )
1183 TRACE_EVENT(xrep_reset_counters,
1184         TP_PROTO(struct xfs_mount *mp),
1185         TP_ARGS(mp),
1186         TP_STRUCT__entry(
1187                 __field(dev_t, dev)
1188         ),
1189         TP_fast_assign(
1190                 __entry->dev = mp->m_super->s_dev;
1191         ),
1192         TP_printk("dev %d:%d",
1193                   MAJOR(__entry->dev), MINOR(__entry->dev))
1194 )
1195
1196 TRACE_EVENT(xrep_ialloc_insert,
1197         TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
1198                  xfs_agino_t startino, uint16_t holemask, uint8_t count,
1199                  uint8_t freecount, uint64_t freemask),
1200         TP_ARGS(mp, agno, startino, holemask, count, freecount, freemask),
1201         TP_STRUCT__entry(
1202                 __field(dev_t, dev)
1203                 __field(xfs_agnumber_t, agno)
1204                 __field(xfs_agino_t, startino)
1205                 __field(uint16_t, holemask)
1206                 __field(uint8_t, count)
1207                 __field(uint8_t, freecount)
1208                 __field(uint64_t, freemask)
1209         ),
1210         TP_fast_assign(
1211                 __entry->dev = mp->m_super->s_dev;
1212                 __entry->agno = agno;
1213                 __entry->startino = startino;
1214                 __entry->holemask = holemask;
1215                 __entry->count = count;
1216                 __entry->freecount = freecount;
1217                 __entry->freemask = freemask;
1218         ),
1219         TP_printk("dev %d:%d agno 0x%x startino 0x%x holemask 0x%x count %u freecount %u freemask 0x%llx",
1220                   MAJOR(__entry->dev), MINOR(__entry->dev),
1221                   __entry->agno,
1222                   __entry->startino,
1223                   __entry->holemask,
1224                   __entry->count,
1225                   __entry->freecount,
1226                   __entry->freemask)
1227 )
1228
1229 #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
1230
1231 #endif /* _TRACE_XFS_SCRUB_TRACE_H */
1232
1233 #undef TRACE_INCLUDE_PATH
1234 #define TRACE_INCLUDE_PATH .
1235 #define TRACE_INCLUDE_FILE scrub/trace
1236 #include <trace/define_trace.h>