Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Copyright (C) 2017 Oracle.  All Rights Reserved.
0004  * Author: Darrick J. Wong <darrick.wong@oracle.com>
0005  *
0006  * NOTE: none of these tracepoints shall be considered a stable kernel ABI
0007  * as they can change at any time.  See xfs_trace.h for documentation of
0008  * specific units found in tracepoint output.
0009  */
0010 #undef TRACE_SYSTEM
0011 #define TRACE_SYSTEM xfs_scrub
0012 
0013 #if !defined(_TRACE_XFS_SCRUB_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
0014 #define _TRACE_XFS_SCRUB_TRACE_H
0015 
0016 #include <linux/tracepoint.h>
0017 #include "xfs_bit.h"
0018 
0019 /*
0020  * ftrace's __print_symbolic requires that all enum values be wrapped in the
0021  * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace
0022  * ring buffer.  Somehow this was only worth mentioning in the ftrace sample
0023  * code.
0024  */
0025 TRACE_DEFINE_ENUM(XFS_BTNUM_BNOi);
0026 TRACE_DEFINE_ENUM(XFS_BTNUM_CNTi);
0027 TRACE_DEFINE_ENUM(XFS_BTNUM_BMAPi);
0028 TRACE_DEFINE_ENUM(XFS_BTNUM_INOi);
0029 TRACE_DEFINE_ENUM(XFS_BTNUM_FINOi);
0030 TRACE_DEFINE_ENUM(XFS_BTNUM_RMAPi);
0031 TRACE_DEFINE_ENUM(XFS_BTNUM_REFCi);
0032 
0033 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PROBE);
0034 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SB);
0035 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGF);
0036 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGFL);
0037 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_AGI);
0038 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BNOBT);
0039 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_CNTBT);
0040 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INOBT);
0041 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FINOBT);
0042 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RMAPBT);
0043 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_REFCNTBT);
0044 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_INODE);
0045 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTD);
0046 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTA);
0047 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_BMBTC);
0048 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_DIR);
0049 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_XATTR);
0050 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_SYMLINK);
0051 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PARENT);
0052 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTBITMAP);
0053 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTSUM);
0054 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_UQUOTA);
0055 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_GQUOTA);
0056 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_PQUOTA);
0057 TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_FSCOUNTERS);
0058 
0059 #define XFS_SCRUB_TYPE_STRINGS \
0060     { XFS_SCRUB_TYPE_PROBE,     "probe" }, \
0061     { XFS_SCRUB_TYPE_SB,        "sb" }, \
0062     { XFS_SCRUB_TYPE_AGF,       "agf" }, \
0063     { XFS_SCRUB_TYPE_AGFL,      "agfl" }, \
0064     { XFS_SCRUB_TYPE_AGI,       "agi" }, \
0065     { XFS_SCRUB_TYPE_BNOBT,     "bnobt" }, \
0066     { XFS_SCRUB_TYPE_CNTBT,     "cntbt" }, \
0067     { XFS_SCRUB_TYPE_INOBT,     "inobt" }, \
0068     { XFS_SCRUB_TYPE_FINOBT,    "finobt" }, \
0069     { XFS_SCRUB_TYPE_RMAPBT,    "rmapbt" }, \
0070     { XFS_SCRUB_TYPE_REFCNTBT,  "refcountbt" }, \
0071     { XFS_SCRUB_TYPE_INODE,     "inode" }, \
0072     { XFS_SCRUB_TYPE_BMBTD,     "bmapbtd" }, \
0073     { XFS_SCRUB_TYPE_BMBTA,     "bmapbta" }, \
0074     { XFS_SCRUB_TYPE_BMBTC,     "bmapbtc" }, \
0075     { XFS_SCRUB_TYPE_DIR,       "directory" }, \
0076     { XFS_SCRUB_TYPE_XATTR,     "xattr" }, \
0077     { XFS_SCRUB_TYPE_SYMLINK,   "symlink" }, \
0078     { XFS_SCRUB_TYPE_PARENT,    "parent" }, \
0079     { XFS_SCRUB_TYPE_RTBITMAP,  "rtbitmap" }, \
0080     { XFS_SCRUB_TYPE_RTSUM,     "rtsummary" }, \
0081     { XFS_SCRUB_TYPE_UQUOTA,    "usrquota" }, \
0082     { XFS_SCRUB_TYPE_GQUOTA,    "grpquota" }, \
0083     { XFS_SCRUB_TYPE_PQUOTA,    "prjquota" }, \
0084     { XFS_SCRUB_TYPE_FSCOUNTERS,    "fscounters" }
0085 
0086 #define XFS_SCRUB_FLAG_STRINGS \
0087     { XFS_SCRUB_IFLAG_REPAIR,       "repair" }, \
0088     { XFS_SCRUB_OFLAG_CORRUPT,      "corrupt" }, \
0089     { XFS_SCRUB_OFLAG_PREEN,        "preen" }, \
0090     { XFS_SCRUB_OFLAG_XFAIL,        "xfail" }, \
0091     { XFS_SCRUB_OFLAG_XCORRUPT,     "xcorrupt" }, \
0092     { XFS_SCRUB_OFLAG_INCOMPLETE,       "incomplete" }, \
0093     { XFS_SCRUB_OFLAG_WARNING,      "warning" }, \
0094     { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED, "norepair" }
0095 
0096 DECLARE_EVENT_CLASS(xchk_class,
0097     TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm,
0098          int error),
0099     TP_ARGS(ip, sm, error),
0100     TP_STRUCT__entry(
0101         __field(dev_t, dev)
0102         __field(xfs_ino_t, ino)
0103         __field(unsigned int, type)
0104         __field(xfs_agnumber_t, agno)
0105         __field(xfs_ino_t, inum)
0106         __field(unsigned int, gen)
0107         __field(unsigned int, flags)
0108         __field(int, error)
0109     ),
0110     TP_fast_assign(
0111         __entry->dev = ip->i_mount->m_super->s_dev;
0112         __entry->ino = ip->i_ino;
0113         __entry->type = sm->sm_type;
0114         __entry->agno = sm->sm_agno;
0115         __entry->inum = sm->sm_ino;
0116         __entry->gen = sm->sm_gen;
0117         __entry->flags = sm->sm_flags;
0118         __entry->error = error;
0119     ),
0120     TP_printk("dev %d:%d ino 0x%llx type %s agno 0x%x inum 0x%llx gen 0x%x flags (%s) error %d",
0121           MAJOR(__entry->dev), MINOR(__entry->dev),
0122           __entry->ino,
0123           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0124           __entry->agno,
0125           __entry->inum,
0126           __entry->gen,
0127           __print_flags(__entry->flags, "|", XFS_SCRUB_FLAG_STRINGS),
0128           __entry->error)
0129 )
0130 #define DEFINE_SCRUB_EVENT(name) \
0131 DEFINE_EVENT(xchk_class, name, \
0132     TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, \
0133          int error), \
0134     TP_ARGS(ip, sm, error))
0135 
0136 DEFINE_SCRUB_EVENT(xchk_start);
0137 DEFINE_SCRUB_EVENT(xchk_done);
0138 DEFINE_SCRUB_EVENT(xchk_deadlock_retry);
0139 DEFINE_SCRUB_EVENT(xrep_attempt);
0140 DEFINE_SCRUB_EVENT(xrep_done);
0141 
0142 TRACE_EVENT(xchk_op_error,
0143     TP_PROTO(struct xfs_scrub *sc, xfs_agnumber_t agno,
0144          xfs_agblock_t bno, int error, void *ret_ip),
0145     TP_ARGS(sc, agno, bno, error, ret_ip),
0146     TP_STRUCT__entry(
0147         __field(dev_t, dev)
0148         __field(unsigned int, type)
0149         __field(xfs_agnumber_t, agno)
0150         __field(xfs_agblock_t, bno)
0151         __field(int, error)
0152         __field(void *, ret_ip)
0153     ),
0154     TP_fast_assign(
0155         __entry->dev = sc->mp->m_super->s_dev;
0156         __entry->type = sc->sm->sm_type;
0157         __entry->agno = agno;
0158         __entry->bno = bno;
0159         __entry->error = error;
0160         __entry->ret_ip = ret_ip;
0161     ),
0162     TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x error %d ret_ip %pS",
0163           MAJOR(__entry->dev), MINOR(__entry->dev),
0164           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0165           __entry->agno,
0166           __entry->bno,
0167           __entry->error,
0168           __entry->ret_ip)
0169 );
0170 
0171 TRACE_EVENT(xchk_file_op_error,
0172     TP_PROTO(struct xfs_scrub *sc, int whichfork,
0173          xfs_fileoff_t offset, int error, void *ret_ip),
0174     TP_ARGS(sc, whichfork, offset, error, ret_ip),
0175     TP_STRUCT__entry(
0176         __field(dev_t, dev)
0177         __field(xfs_ino_t, ino)
0178         __field(int, whichfork)
0179         __field(unsigned int, type)
0180         __field(xfs_fileoff_t, offset)
0181         __field(int, error)
0182         __field(void *, ret_ip)
0183     ),
0184     TP_fast_assign(
0185         __entry->dev = sc->ip->i_mount->m_super->s_dev;
0186         __entry->ino = sc->ip->i_ino;
0187         __entry->whichfork = whichfork;
0188         __entry->type = sc->sm->sm_type;
0189         __entry->offset = offset;
0190         __entry->error = error;
0191         __entry->ret_ip = ret_ip;
0192     ),
0193     TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx error %d ret_ip %pS",
0194           MAJOR(__entry->dev), MINOR(__entry->dev),
0195           __entry->ino,
0196           __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
0197           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0198           __entry->offset,
0199           __entry->error,
0200           __entry->ret_ip)
0201 );
0202 
0203 DECLARE_EVENT_CLASS(xchk_block_error_class,
0204     TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, void *ret_ip),
0205     TP_ARGS(sc, daddr, ret_ip),
0206     TP_STRUCT__entry(
0207         __field(dev_t, dev)
0208         __field(unsigned int, type)
0209         __field(xfs_agnumber_t, agno)
0210         __field(xfs_agblock_t, agbno)
0211         __field(void *, ret_ip)
0212     ),
0213     TP_fast_assign(
0214         __entry->dev = sc->mp->m_super->s_dev;
0215         __entry->type = sc->sm->sm_type;
0216         __entry->agno = xfs_daddr_to_agno(sc->mp, daddr);
0217         __entry->agbno = xfs_daddr_to_agbno(sc->mp, daddr);
0218         __entry->ret_ip = ret_ip;
0219     ),
0220     TP_printk("dev %d:%d type %s agno 0x%x agbno 0x%x ret_ip %pS",
0221           MAJOR(__entry->dev), MINOR(__entry->dev),
0222           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0223           __entry->agno,
0224           __entry->agbno,
0225           __entry->ret_ip)
0226 )
0227 
0228 #define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \
0229 DEFINE_EVENT(xchk_block_error_class, name, \
0230     TP_PROTO(struct xfs_scrub *sc, xfs_daddr_t daddr, \
0231          void *ret_ip), \
0232     TP_ARGS(sc, daddr, ret_ip))
0233 
0234 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_fs_error);
0235 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_error);
0236 DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_preen);
0237 
0238 DECLARE_EVENT_CLASS(xchk_ino_error_class,
0239     TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, void *ret_ip),
0240     TP_ARGS(sc, ino, ret_ip),
0241     TP_STRUCT__entry(
0242         __field(dev_t, dev)
0243         __field(xfs_ino_t, ino)
0244         __field(unsigned int, type)
0245         __field(void *, ret_ip)
0246     ),
0247     TP_fast_assign(
0248         __entry->dev = sc->mp->m_super->s_dev;
0249         __entry->ino = ino;
0250         __entry->type = sc->sm->sm_type;
0251         __entry->ret_ip = ret_ip;
0252     ),
0253     TP_printk("dev %d:%d ino 0x%llx type %s ret_ip %pS",
0254           MAJOR(__entry->dev), MINOR(__entry->dev),
0255           __entry->ino,
0256           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0257           __entry->ret_ip)
0258 )
0259 
0260 #define DEFINE_SCRUB_INO_ERROR_EVENT(name) \
0261 DEFINE_EVENT(xchk_ino_error_class, name, \
0262     TP_PROTO(struct xfs_scrub *sc, xfs_ino_t ino, \
0263          void *ret_ip), \
0264     TP_ARGS(sc, ino, ret_ip))
0265 
0266 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_error);
0267 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_preen);
0268 DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_warning);
0269 
0270 DECLARE_EVENT_CLASS(xchk_fblock_error_class,
0271     TP_PROTO(struct xfs_scrub *sc, int whichfork,
0272          xfs_fileoff_t offset, void *ret_ip),
0273     TP_ARGS(sc, whichfork, offset, ret_ip),
0274     TP_STRUCT__entry(
0275         __field(dev_t, dev)
0276         __field(xfs_ino_t, ino)
0277         __field(int, whichfork)
0278         __field(unsigned int, type)
0279         __field(xfs_fileoff_t, offset)
0280         __field(void *, ret_ip)
0281     ),
0282     TP_fast_assign(
0283         __entry->dev = sc->ip->i_mount->m_super->s_dev;
0284         __entry->ino = sc->ip->i_ino;
0285         __entry->whichfork = whichfork;
0286         __entry->type = sc->sm->sm_type;
0287         __entry->offset = offset;
0288         __entry->ret_ip = ret_ip;
0289     ),
0290     TP_printk("dev %d:%d ino 0x%llx fork %s type %s fileoff 0x%llx ret_ip %pS",
0291           MAJOR(__entry->dev), MINOR(__entry->dev),
0292           __entry->ino,
0293           __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
0294           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0295           __entry->offset,
0296           __entry->ret_ip)
0297 );
0298 
0299 #define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \
0300 DEFINE_EVENT(xchk_fblock_error_class, name, \
0301     TP_PROTO(struct xfs_scrub *sc, int whichfork, \
0302          xfs_fileoff_t offset, void *ret_ip), \
0303     TP_ARGS(sc, whichfork, offset, ret_ip))
0304 
0305 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_error);
0306 DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_warning);
0307 
0308 TRACE_EVENT(xchk_incomplete,
0309     TP_PROTO(struct xfs_scrub *sc, void *ret_ip),
0310     TP_ARGS(sc, ret_ip),
0311     TP_STRUCT__entry(
0312         __field(dev_t, dev)
0313         __field(unsigned int, type)
0314         __field(void *, ret_ip)
0315     ),
0316     TP_fast_assign(
0317         __entry->dev = sc->mp->m_super->s_dev;
0318         __entry->type = sc->sm->sm_type;
0319         __entry->ret_ip = ret_ip;
0320     ),
0321     TP_printk("dev %d:%d type %s ret_ip %pS",
0322           MAJOR(__entry->dev), MINOR(__entry->dev),
0323           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0324           __entry->ret_ip)
0325 );
0326 
0327 TRACE_EVENT(xchk_btree_op_error,
0328     TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
0329          int level, int error, void *ret_ip),
0330     TP_ARGS(sc, cur, level, error, ret_ip),
0331     TP_STRUCT__entry(
0332         __field(dev_t, dev)
0333         __field(unsigned int, type)
0334         __field(xfs_btnum_t, btnum)
0335         __field(int, level)
0336         __field(xfs_agnumber_t, agno)
0337         __field(xfs_agblock_t, bno)
0338         __field(int, ptr)
0339         __field(int, error)
0340         __field(void *, ret_ip)
0341     ),
0342     TP_fast_assign(
0343         xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
0344 
0345         __entry->dev = sc->mp->m_super->s_dev;
0346         __entry->type = sc->sm->sm_type;
0347         __entry->btnum = cur->bc_btnum;
0348         __entry->level = level;
0349         __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
0350         __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
0351         __entry->ptr = cur->bc_levels[level].ptr;
0352         __entry->error = error;
0353         __entry->ret_ip = ret_ip;
0354     ),
0355     TP_printk("dev %d:%d type %s btree %s level %d ptr %d agno 0x%x agbno 0x%x error %d ret_ip %pS",
0356           MAJOR(__entry->dev), MINOR(__entry->dev),
0357           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0358           __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
0359           __entry->level,
0360           __entry->ptr,
0361           __entry->agno,
0362           __entry->bno,
0363           __entry->error,
0364           __entry->ret_ip)
0365 );
0366 
0367 TRACE_EVENT(xchk_ifork_btree_op_error,
0368     TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
0369          int level, int error, void *ret_ip),
0370     TP_ARGS(sc, cur, level, error, ret_ip),
0371     TP_STRUCT__entry(
0372         __field(dev_t, dev)
0373         __field(xfs_ino_t, ino)
0374         __field(int, whichfork)
0375         __field(unsigned int, type)
0376         __field(xfs_btnum_t, btnum)
0377         __field(int, level)
0378         __field(int, ptr)
0379         __field(xfs_agnumber_t, agno)
0380         __field(xfs_agblock_t, bno)
0381         __field(int, error)
0382         __field(void *, ret_ip)
0383     ),
0384     TP_fast_assign(
0385         xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
0386         __entry->dev = sc->mp->m_super->s_dev;
0387         __entry->ino = sc->ip->i_ino;
0388         __entry->whichfork = cur->bc_ino.whichfork;
0389         __entry->type = sc->sm->sm_type;
0390         __entry->btnum = cur->bc_btnum;
0391         __entry->level = level;
0392         __entry->ptr = cur->bc_levels[level].ptr;
0393         __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
0394         __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
0395         __entry->error = error;
0396         __entry->ret_ip = ret_ip;
0397     ),
0398     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",
0399           MAJOR(__entry->dev), MINOR(__entry->dev),
0400           __entry->ino,
0401           __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
0402           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0403           __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
0404           __entry->level,
0405           __entry->ptr,
0406           __entry->agno,
0407           __entry->bno,
0408           __entry->error,
0409           __entry->ret_ip)
0410 );
0411 
0412 TRACE_EVENT(xchk_btree_error,
0413     TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
0414          int level, void *ret_ip),
0415     TP_ARGS(sc, cur, level, ret_ip),
0416     TP_STRUCT__entry(
0417         __field(dev_t, dev)
0418         __field(unsigned int, type)
0419         __field(xfs_btnum_t, btnum)
0420         __field(int, level)
0421         __field(xfs_agnumber_t, agno)
0422         __field(xfs_agblock_t, bno)
0423         __field(int, ptr)
0424         __field(void *, ret_ip)
0425     ),
0426     TP_fast_assign(
0427         xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
0428         __entry->dev = sc->mp->m_super->s_dev;
0429         __entry->type = sc->sm->sm_type;
0430         __entry->btnum = cur->bc_btnum;
0431         __entry->level = level;
0432         __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
0433         __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
0434         __entry->ptr = cur->bc_levels[level].ptr;
0435         __entry->ret_ip = ret_ip;
0436     ),
0437     TP_printk("dev %d:%d type %s btree %s level %d ptr %d agno 0x%x agbno 0x%x ret_ip %pS",
0438           MAJOR(__entry->dev), MINOR(__entry->dev),
0439           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0440           __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
0441           __entry->level,
0442           __entry->ptr,
0443           __entry->agno,
0444           __entry->bno,
0445           __entry->ret_ip)
0446 );
0447 
0448 TRACE_EVENT(xchk_ifork_btree_error,
0449     TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
0450          int level, void *ret_ip),
0451     TP_ARGS(sc, cur, level, ret_ip),
0452     TP_STRUCT__entry(
0453         __field(dev_t, dev)
0454         __field(xfs_ino_t, ino)
0455         __field(int, whichfork)
0456         __field(unsigned int, type)
0457         __field(xfs_btnum_t, btnum)
0458         __field(int, level)
0459         __field(xfs_agnumber_t, agno)
0460         __field(xfs_agblock_t, bno)
0461         __field(int, ptr)
0462         __field(void *, ret_ip)
0463     ),
0464     TP_fast_assign(
0465         xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
0466         __entry->dev = sc->mp->m_super->s_dev;
0467         __entry->ino = sc->ip->i_ino;
0468         __entry->whichfork = cur->bc_ino.whichfork;
0469         __entry->type = sc->sm->sm_type;
0470         __entry->btnum = cur->bc_btnum;
0471         __entry->level = level;
0472         __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
0473         __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
0474         __entry->ptr = cur->bc_levels[level].ptr;
0475         __entry->ret_ip = ret_ip;
0476     ),
0477     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",
0478           MAJOR(__entry->dev), MINOR(__entry->dev),
0479           __entry->ino,
0480           __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS),
0481           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0482           __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
0483           __entry->level,
0484           __entry->ptr,
0485           __entry->agno,
0486           __entry->bno,
0487           __entry->ret_ip)
0488 );
0489 
0490 DECLARE_EVENT_CLASS(xchk_sbtree_class,
0491     TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
0492          int level),
0493     TP_ARGS(sc, cur, level),
0494     TP_STRUCT__entry(
0495         __field(dev_t, dev)
0496         __field(int, type)
0497         __field(xfs_btnum_t, btnum)
0498         __field(xfs_agnumber_t, agno)
0499         __field(xfs_agblock_t, bno)
0500         __field(int, level)
0501         __field(int, nlevels)
0502         __field(int, ptr)
0503     ),
0504     TP_fast_assign(
0505         xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
0506 
0507         __entry->dev = sc->mp->m_super->s_dev;
0508         __entry->type = sc->sm->sm_type;
0509         __entry->btnum = cur->bc_btnum;
0510         __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsbno);
0511         __entry->bno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno);
0512         __entry->level = level;
0513         __entry->nlevels = cur->bc_nlevels;
0514         __entry->ptr = cur->bc_levels[level].ptr;
0515     ),
0516     TP_printk("dev %d:%d type %s btree %s agno 0x%x agbno 0x%x level %d nlevels %d ptr %d",
0517           MAJOR(__entry->dev), MINOR(__entry->dev),
0518           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0519           __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS),
0520           __entry->agno,
0521           __entry->bno,
0522           __entry->level,
0523           __entry->nlevels,
0524           __entry->ptr)
0525 )
0526 #define DEFINE_SCRUB_SBTREE_EVENT(name) \
0527 DEFINE_EVENT(xchk_sbtree_class, name, \
0528     TP_PROTO(struct xfs_scrub *sc, struct xfs_btree_cur *cur, \
0529          int level), \
0530     TP_ARGS(sc, cur, level))
0531 
0532 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_rec);
0533 DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_key);
0534 
0535 TRACE_EVENT(xchk_xref_error,
0536     TP_PROTO(struct xfs_scrub *sc, int error, void *ret_ip),
0537     TP_ARGS(sc, error, ret_ip),
0538     TP_STRUCT__entry(
0539         __field(dev_t, dev)
0540         __field(int, type)
0541         __field(int, error)
0542         __field(void *, ret_ip)
0543     ),
0544     TP_fast_assign(
0545         __entry->dev = sc->mp->m_super->s_dev;
0546         __entry->type = sc->sm->sm_type;
0547         __entry->error = error;
0548         __entry->ret_ip = ret_ip;
0549     ),
0550     TP_printk("dev %d:%d type %s xref error %d ret_ip %pS",
0551           MAJOR(__entry->dev), MINOR(__entry->dev),
0552           __print_symbolic(__entry->type, XFS_SCRUB_TYPE_STRINGS),
0553           __entry->error,
0554           __entry->ret_ip)
0555 );
0556 
0557 TRACE_EVENT(xchk_iallocbt_check_cluster,
0558     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
0559          xfs_agino_t startino, xfs_daddr_t map_daddr,
0560          unsigned short map_len, unsigned int chunk_ino,
0561          unsigned int nr_inodes, uint16_t cluster_mask,
0562          uint16_t holemask, unsigned int cluster_ino),
0563     TP_ARGS(mp, agno, startino, map_daddr, map_len, chunk_ino, nr_inodes,
0564         cluster_mask, holemask, cluster_ino),
0565     TP_STRUCT__entry(
0566         __field(dev_t, dev)
0567         __field(xfs_agnumber_t, agno)
0568         __field(xfs_agino_t, startino)
0569         __field(xfs_daddr_t, map_daddr)
0570         __field(unsigned short, map_len)
0571         __field(unsigned int, chunk_ino)
0572         __field(unsigned int, nr_inodes)
0573         __field(unsigned int, cluster_ino)
0574         __field(uint16_t, cluster_mask)
0575         __field(uint16_t, holemask)
0576     ),
0577     TP_fast_assign(
0578         __entry->dev = mp->m_super->s_dev;
0579         __entry->agno = agno;
0580         __entry->startino = startino;
0581         __entry->map_daddr = map_daddr;
0582         __entry->map_len = map_len;
0583         __entry->chunk_ino = chunk_ino;
0584         __entry->nr_inodes = nr_inodes;
0585         __entry->cluster_mask = cluster_mask;
0586         __entry->holemask = holemask;
0587         __entry->cluster_ino = cluster_ino;
0588     ),
0589     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",
0590           MAJOR(__entry->dev), MINOR(__entry->dev),
0591           __entry->agno,
0592           __entry->startino,
0593           __entry->map_daddr,
0594           __entry->map_len,
0595           __entry->chunk_ino,
0596           __entry->nr_inodes,
0597           __entry->cluster_mask,
0598           __entry->holemask,
0599           __entry->cluster_ino)
0600 )
0601 
0602 TRACE_EVENT(xchk_fscounters_calc,
0603     TP_PROTO(struct xfs_mount *mp, uint64_t icount, uint64_t ifree,
0604          uint64_t fdblocks, uint64_t delalloc),
0605     TP_ARGS(mp, icount, ifree, fdblocks, delalloc),
0606     TP_STRUCT__entry(
0607         __field(dev_t, dev)
0608         __field(int64_t, icount_sb)
0609         __field(uint64_t, icount_calculated)
0610         __field(int64_t, ifree_sb)
0611         __field(uint64_t, ifree_calculated)
0612         __field(int64_t, fdblocks_sb)
0613         __field(uint64_t, fdblocks_calculated)
0614         __field(uint64_t, delalloc)
0615     ),
0616     TP_fast_assign(
0617         __entry->dev = mp->m_super->s_dev;
0618         __entry->icount_sb = mp->m_sb.sb_icount;
0619         __entry->icount_calculated = icount;
0620         __entry->ifree_sb = mp->m_sb.sb_ifree;
0621         __entry->ifree_calculated = ifree;
0622         __entry->fdblocks_sb = mp->m_sb.sb_fdblocks;
0623         __entry->fdblocks_calculated = fdblocks;
0624         __entry->delalloc = delalloc;
0625     ),
0626     TP_printk("dev %d:%d icount %lld:%llu ifree %lld::%llu fdblocks %lld::%llu delalloc %llu",
0627           MAJOR(__entry->dev), MINOR(__entry->dev),
0628           __entry->icount_sb,
0629           __entry->icount_calculated,
0630           __entry->ifree_sb,
0631           __entry->ifree_calculated,
0632           __entry->fdblocks_sb,
0633           __entry->fdblocks_calculated,
0634           __entry->delalloc)
0635 )
0636 
0637 TRACE_EVENT(xchk_fscounters_within_range,
0638     TP_PROTO(struct xfs_mount *mp, uint64_t expected, int64_t curr_value,
0639          int64_t old_value),
0640     TP_ARGS(mp, expected, curr_value, old_value),
0641     TP_STRUCT__entry(
0642         __field(dev_t, dev)
0643         __field(uint64_t, expected)
0644         __field(int64_t, curr_value)
0645         __field(int64_t, old_value)
0646     ),
0647     TP_fast_assign(
0648         __entry->dev = mp->m_super->s_dev;
0649         __entry->expected = expected;
0650         __entry->curr_value = curr_value;
0651         __entry->old_value = old_value;
0652     ),
0653     TP_printk("dev %d:%d expected %llu curr_value %lld old_value %lld",
0654           MAJOR(__entry->dev), MINOR(__entry->dev),
0655           __entry->expected,
0656           __entry->curr_value,
0657           __entry->old_value)
0658 )
0659 
0660 /* repair tracepoints */
0661 #if IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR)
0662 
0663 DECLARE_EVENT_CLASS(xrep_extent_class,
0664     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
0665          xfs_agblock_t agbno, xfs_extlen_t len),
0666     TP_ARGS(mp, agno, agbno, len),
0667     TP_STRUCT__entry(
0668         __field(dev_t, dev)
0669         __field(xfs_agnumber_t, agno)
0670         __field(xfs_agblock_t, agbno)
0671         __field(xfs_extlen_t, len)
0672     ),
0673     TP_fast_assign(
0674         __entry->dev = mp->m_super->s_dev;
0675         __entry->agno = agno;
0676         __entry->agbno = agbno;
0677         __entry->len = len;
0678     ),
0679     TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x",
0680           MAJOR(__entry->dev), MINOR(__entry->dev),
0681           __entry->agno,
0682           __entry->agbno,
0683           __entry->len)
0684 );
0685 #define DEFINE_REPAIR_EXTENT_EVENT(name) \
0686 DEFINE_EVENT(xrep_extent_class, name, \
0687     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
0688          xfs_agblock_t agbno, xfs_extlen_t len), \
0689     TP_ARGS(mp, agno, agbno, len))
0690 DEFINE_REPAIR_EXTENT_EVENT(xrep_dispose_btree_extent);
0691 DEFINE_REPAIR_EXTENT_EVENT(xrep_agfl_insert);
0692 
0693 DECLARE_EVENT_CLASS(xrep_rmap_class,
0694     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
0695          xfs_agblock_t agbno, xfs_extlen_t len,
0696          uint64_t owner, uint64_t offset, unsigned int flags),
0697     TP_ARGS(mp, agno, agbno, len, owner, offset, flags),
0698     TP_STRUCT__entry(
0699         __field(dev_t, dev)
0700         __field(xfs_agnumber_t, agno)
0701         __field(xfs_agblock_t, agbno)
0702         __field(xfs_extlen_t, len)
0703         __field(uint64_t, owner)
0704         __field(uint64_t, offset)
0705         __field(unsigned int, flags)
0706     ),
0707     TP_fast_assign(
0708         __entry->dev = mp->m_super->s_dev;
0709         __entry->agno = agno;
0710         __entry->agbno = agbno;
0711         __entry->len = len;
0712         __entry->owner = owner;
0713         __entry->offset = offset;
0714         __entry->flags = flags;
0715     ),
0716     TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x",
0717           MAJOR(__entry->dev), MINOR(__entry->dev),
0718           __entry->agno,
0719           __entry->agbno,
0720           __entry->len,
0721           __entry->owner,
0722           __entry->offset,
0723           __entry->flags)
0724 );
0725 #define DEFINE_REPAIR_RMAP_EVENT(name) \
0726 DEFINE_EVENT(xrep_rmap_class, name, \
0727     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
0728          xfs_agblock_t agbno, xfs_extlen_t len, \
0729          uint64_t owner, uint64_t offset, unsigned int flags), \
0730     TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
0731 DEFINE_REPAIR_RMAP_EVENT(xrep_alloc_extent_fn);
0732 DEFINE_REPAIR_RMAP_EVENT(xrep_ialloc_extent_fn);
0733 DEFINE_REPAIR_RMAP_EVENT(xrep_rmap_extent_fn);
0734 DEFINE_REPAIR_RMAP_EVENT(xrep_bmap_extent_fn);
0735 
0736 TRACE_EVENT(xrep_refcount_extent_fn,
0737     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
0738          struct xfs_refcount_irec *irec),
0739     TP_ARGS(mp, agno, irec),
0740     TP_STRUCT__entry(
0741         __field(dev_t, dev)
0742         __field(xfs_agnumber_t, agno)
0743         __field(xfs_agblock_t, startblock)
0744         __field(xfs_extlen_t, blockcount)
0745         __field(xfs_nlink_t, refcount)
0746     ),
0747     TP_fast_assign(
0748         __entry->dev = mp->m_super->s_dev;
0749         __entry->agno = agno;
0750         __entry->startblock = irec->rc_startblock;
0751         __entry->blockcount = irec->rc_blockcount;
0752         __entry->refcount = irec->rc_refcount;
0753     ),
0754     TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x refcount %u",
0755           MAJOR(__entry->dev), MINOR(__entry->dev),
0756           __entry->agno,
0757           __entry->startblock,
0758           __entry->blockcount,
0759           __entry->refcount)
0760 )
0761 
0762 TRACE_EVENT(xrep_init_btblock,
0763     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
0764          xfs_btnum_t btnum),
0765     TP_ARGS(mp, agno, agbno, btnum),
0766     TP_STRUCT__entry(
0767         __field(dev_t, dev)
0768         __field(xfs_agnumber_t, agno)
0769         __field(xfs_agblock_t, agbno)
0770         __field(uint32_t, btnum)
0771     ),
0772     TP_fast_assign(
0773         __entry->dev = mp->m_super->s_dev;
0774         __entry->agno = agno;
0775         __entry->agbno = agbno;
0776         __entry->btnum = btnum;
0777     ),
0778     TP_printk("dev %d:%d agno 0x%x agbno 0x%x btree %s",
0779           MAJOR(__entry->dev), MINOR(__entry->dev),
0780           __entry->agno,
0781           __entry->agbno,
0782           __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS))
0783 )
0784 TRACE_EVENT(xrep_findroot_block,
0785     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
0786          uint32_t magic, uint16_t level),
0787     TP_ARGS(mp, agno, agbno, magic, level),
0788     TP_STRUCT__entry(
0789         __field(dev_t, dev)
0790         __field(xfs_agnumber_t, agno)
0791         __field(xfs_agblock_t, agbno)
0792         __field(uint32_t, magic)
0793         __field(uint16_t, level)
0794     ),
0795     TP_fast_assign(
0796         __entry->dev = mp->m_super->s_dev;
0797         __entry->agno = agno;
0798         __entry->agbno = agbno;
0799         __entry->magic = magic;
0800         __entry->level = level;
0801     ),
0802     TP_printk("dev %d:%d agno 0x%x agbno 0x%x magic 0x%x level %u",
0803           MAJOR(__entry->dev), MINOR(__entry->dev),
0804           __entry->agno,
0805           __entry->agbno,
0806           __entry->magic,
0807           __entry->level)
0808 )
0809 TRACE_EVENT(xrep_calc_ag_resblks,
0810     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
0811          xfs_agino_t icount, xfs_agblock_t aglen, xfs_agblock_t freelen,
0812          xfs_agblock_t usedlen),
0813     TP_ARGS(mp, agno, icount, aglen, freelen, usedlen),
0814     TP_STRUCT__entry(
0815         __field(dev_t, dev)
0816         __field(xfs_agnumber_t, agno)
0817         __field(xfs_agino_t, icount)
0818         __field(xfs_agblock_t, aglen)
0819         __field(xfs_agblock_t, freelen)
0820         __field(xfs_agblock_t, usedlen)
0821     ),
0822     TP_fast_assign(
0823         __entry->dev = mp->m_super->s_dev;
0824         __entry->agno = agno;
0825         __entry->icount = icount;
0826         __entry->aglen = aglen;
0827         __entry->freelen = freelen;
0828         __entry->usedlen = usedlen;
0829     ),
0830     TP_printk("dev %d:%d agno 0x%x icount %u aglen %u freelen %u usedlen %u",
0831           MAJOR(__entry->dev), MINOR(__entry->dev),
0832           __entry->agno,
0833           __entry->icount,
0834           __entry->aglen,
0835           __entry->freelen,
0836           __entry->usedlen)
0837 )
0838 TRACE_EVENT(xrep_calc_ag_resblks_btsize,
0839     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
0840          xfs_agblock_t bnobt_sz, xfs_agblock_t inobt_sz,
0841          xfs_agblock_t rmapbt_sz, xfs_agblock_t refcbt_sz),
0842     TP_ARGS(mp, agno, bnobt_sz, inobt_sz, rmapbt_sz, refcbt_sz),
0843     TP_STRUCT__entry(
0844         __field(dev_t, dev)
0845         __field(xfs_agnumber_t, agno)
0846         __field(xfs_agblock_t, bnobt_sz)
0847         __field(xfs_agblock_t, inobt_sz)
0848         __field(xfs_agblock_t, rmapbt_sz)
0849         __field(xfs_agblock_t, refcbt_sz)
0850     ),
0851     TP_fast_assign(
0852         __entry->dev = mp->m_super->s_dev;
0853         __entry->agno = agno;
0854         __entry->bnobt_sz = bnobt_sz;
0855         __entry->inobt_sz = inobt_sz;
0856         __entry->rmapbt_sz = rmapbt_sz;
0857         __entry->refcbt_sz = refcbt_sz;
0858     ),
0859     TP_printk("dev %d:%d agno 0x%x bnobt %u inobt %u rmapbt %u refcountbt %u",
0860           MAJOR(__entry->dev), MINOR(__entry->dev),
0861           __entry->agno,
0862           __entry->bnobt_sz,
0863           __entry->inobt_sz,
0864           __entry->rmapbt_sz,
0865           __entry->refcbt_sz)
0866 )
0867 TRACE_EVENT(xrep_reset_counters,
0868     TP_PROTO(struct xfs_mount *mp),
0869     TP_ARGS(mp),
0870     TP_STRUCT__entry(
0871         __field(dev_t, dev)
0872     ),
0873     TP_fast_assign(
0874         __entry->dev = mp->m_super->s_dev;
0875     ),
0876     TP_printk("dev %d:%d",
0877           MAJOR(__entry->dev), MINOR(__entry->dev))
0878 )
0879 
0880 TRACE_EVENT(xrep_ialloc_insert,
0881     TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
0882          xfs_agino_t startino, uint16_t holemask, uint8_t count,
0883          uint8_t freecount, uint64_t freemask),
0884     TP_ARGS(mp, agno, startino, holemask, count, freecount, freemask),
0885     TP_STRUCT__entry(
0886         __field(dev_t, dev)
0887         __field(xfs_agnumber_t, agno)
0888         __field(xfs_agino_t, startino)
0889         __field(uint16_t, holemask)
0890         __field(uint8_t, count)
0891         __field(uint8_t, freecount)
0892         __field(uint64_t, freemask)
0893     ),
0894     TP_fast_assign(
0895         __entry->dev = mp->m_super->s_dev;
0896         __entry->agno = agno;
0897         __entry->startino = startino;
0898         __entry->holemask = holemask;
0899         __entry->count = count;
0900         __entry->freecount = freecount;
0901         __entry->freemask = freemask;
0902     ),
0903     TP_printk("dev %d:%d agno 0x%x startino 0x%x holemask 0x%x count %u freecount %u freemask 0x%llx",
0904           MAJOR(__entry->dev), MINOR(__entry->dev),
0905           __entry->agno,
0906           __entry->startino,
0907           __entry->holemask,
0908           __entry->count,
0909           __entry->freecount,
0910           __entry->freemask)
0911 )
0912 
0913 #endif /* IS_ENABLED(CONFIG_XFS_ONLINE_REPAIR) */
0914 
0915 #endif /* _TRACE_XFS_SCRUB_TRACE_H */
0916 
0917 #undef TRACE_INCLUDE_PATH
0918 #define TRACE_INCLUDE_PATH .
0919 #define TRACE_INCLUDE_FILE scrub/trace
0920 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!