fs/xfs/scrub/common.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 <[email protected]>
   5  */
   6 #ifndef __XFS_SCRUB_COMMON_H__
   7 #define __XFS_SCRUB_COMMON_H__
   8
   9 int xchk_trans_alloc(struct xfs_scrub *sc, uint resblks);
  10 int xchk_trans_alloc_empty(struct xfs_scrub *sc);
  11 void xchk_trans_cancel(struct xfs_scrub *sc);
  12
  13 bool xchk_process_error(struct xfs_scrub *sc, xfs_agnumber_t agno,
  14                 xfs_agblock_t bno, int *error);
  15 bool xchk_fblock_process_error(struct xfs_scrub *sc, int whichfork,
  16                 xfs_fileoff_t offset, int *error);
  17
  18 bool xchk_xref_process_error(struct xfs_scrub *sc,
  19                 xfs_agnumber_t agno, xfs_agblock_t bno, int *error);
  20 bool xchk_fblock_xref_process_error(struct xfs_scrub *sc,
  21                 int whichfork, xfs_fileoff_t offset, int *error);
  22
  23 void xchk_block_set_preen(struct xfs_scrub *sc,
  24                 struct xfs_buf *bp);
  25 void xchk_ino_set_preen(struct xfs_scrub *sc, xfs_ino_t ino);
  26
  27 void xchk_set_corrupt(struct xfs_scrub *sc);
  28 void xchk_block_set_corrupt(struct xfs_scrub *sc,
  29                 struct xfs_buf *bp);
  30 void xchk_ino_set_corrupt(struct xfs_scrub *sc, xfs_ino_t ino);
  31 void xchk_fblock_set_corrupt(struct xfs_scrub *sc, int whichfork,
  32                 xfs_fileoff_t offset);
  33 #ifdef CONFIG_XFS_QUOTA
  34 void xchk_qcheck_set_corrupt(struct xfs_scrub *sc, unsigned int dqtype,
  35                 xfs_dqid_t id);
  36 #endif
  37
  38 void xchk_block_xref_set_corrupt(struct xfs_scrub *sc,
  39                 struct xfs_buf *bp);
  40 void xchk_ino_xref_set_corrupt(struct xfs_scrub *sc,
  41                 xfs_ino_t ino);
  42 void xchk_fblock_xref_set_corrupt(struct xfs_scrub *sc,
  43                 int whichfork, xfs_fileoff_t offset);
  44
  45 void xchk_ino_set_warning(struct xfs_scrub *sc, xfs_ino_t ino);
  46 void xchk_fblock_set_warning(struct xfs_scrub *sc, int whichfork,
  47                 xfs_fileoff_t offset);
  48
  49 void xchk_set_incomplete(struct xfs_scrub *sc);
  50 int xchk_checkpoint_log(struct xfs_mount *mp);
  51
  52 /* Are we set up for a cross-referencing check? */
  53 bool xchk_should_check_xref(struct xfs_scrub *sc, int *error,
  54                            struct xfs_btree_cur **curpp);
  55
  56 /* Setup functions */
  57 int xchk_setup_agheader(struct xfs_scrub *sc);
  58 int xchk_setup_fs(struct xfs_scrub *sc);
  59 int xchk_setup_ag_allocbt(struct xfs_scrub *sc);
  60 int xchk_setup_ag_iallocbt(struct xfs_scrub *sc);
  61 int xchk_setup_ag_rmapbt(struct xfs_scrub *sc);
  62 int xchk_setup_ag_refcountbt(struct xfs_scrub *sc);
  63 int xchk_setup_inode(struct xfs_scrub *sc);
  64 int xchk_setup_inode_bmap(struct xfs_scrub *sc);
  65 int xchk_setup_inode_bmap_data(struct xfs_scrub *sc);
  66 int xchk_setup_directory(struct xfs_scrub *sc);
  67 int xchk_setup_xattr(struct xfs_scrub *sc);
  68 int xchk_setup_symlink(struct xfs_scrub *sc);
  69 int xchk_setup_parent(struct xfs_scrub *sc);
  70 int xchk_setup_dirtree(struct xfs_scrub *sc);
  71 #ifdef CONFIG_XFS_RT
  72 int xchk_setup_rtbitmap(struct xfs_scrub *sc);
  73 int xchk_setup_rtsummary(struct xfs_scrub *sc);
  74 #else
  75 static inline int
  76 xchk_setup_rtbitmap(struct xfs_scrub *sc)
  77 {
  78         return -ENOENT;
  79 }
  80 static inline int
  81 xchk_setup_rtsummary(struct xfs_scrub *sc)
  82 {
  83         return -ENOENT;
  84 }
  85 #endif
  86 #ifdef CONFIG_XFS_QUOTA
  87 int xchk_ino_dqattach(struct xfs_scrub *sc);
  88 int xchk_setup_quota(struct xfs_scrub *sc);
  89 int xchk_setup_quotacheck(struct xfs_scrub *sc);
  90 #else
  91 static inline int
  92 xchk_ino_dqattach(struct xfs_scrub *sc)
  93 {
  94         return 0;
  95 }
  96 static inline int
  97 xchk_setup_quota(struct xfs_scrub *sc)
  98 {
  99         return -ENOENT;
 100 }
 101 static inline int
 102 xchk_setup_quotacheck(struct xfs_scrub *sc)
 103 {
 104         return -ENOENT;
 105 }
 106 #endif
 107 int xchk_setup_fscounters(struct xfs_scrub *sc);
 108 int xchk_setup_nlinks(struct xfs_scrub *sc);
 109
 110 void xchk_ag_free(struct xfs_scrub *sc, struct xchk_ag *sa);
 111 int xchk_ag_init(struct xfs_scrub *sc, xfs_agnumber_t agno,
 112                 struct xchk_ag *sa);
 113 int xchk_perag_drain_and_lock(struct xfs_scrub *sc);
 114
 115 /*
 116  * Grab all AG resources, treating the inability to grab the perag structure as
 117  * a fs corruption.  This is intended for callers checking an ondisk reference
 118  * to a given AG, which means that the AG must still exist.
 119  */
 120 static inline int
 121 xchk_ag_init_existing(
 122         struct xfs_scrub        *sc,
 123         xfs_agnumber_t          agno,
 124         struct xchk_ag          *sa)
 125 {
 126         int                     error = xchk_ag_init(sc, agno, sa);
 127
 128         return error == -ENOENT ? -EFSCORRUPTED : error;
 129 }
 130
 131 int xchk_ag_read_headers(struct xfs_scrub *sc, xfs_agnumber_t agno,
 132                 struct xchk_ag *sa);
 133 void xchk_ag_btcur_free(struct xchk_ag *sa);
 134 void xchk_ag_btcur_init(struct xfs_scrub *sc, struct xchk_ag *sa);
 135 int xchk_count_rmap_ownedby_ag(struct xfs_scrub *sc, struct xfs_btree_cur *cur,
 136                 const struct xfs_owner_info *oinfo, xfs_filblks_t *blocks);
 137
 138 int xchk_setup_ag_btree(struct xfs_scrub *sc, bool force_log);
 139 int xchk_iget_for_scrubbing(struct xfs_scrub *sc);
 140 int xchk_setup_inode_contents(struct xfs_scrub *sc, unsigned int resblks);
 141 int xchk_install_live_inode(struct xfs_scrub *sc, struct xfs_inode *ip);
 142
 143 void xchk_ilock(struct xfs_scrub *sc, unsigned int ilock_flags);
 144 bool xchk_ilock_nowait(struct xfs_scrub *sc, unsigned int ilock_flags);
 145 void xchk_iunlock(struct xfs_scrub *sc, unsigned int ilock_flags);
 146
 147 void xchk_buffer_recheck(struct xfs_scrub *sc, struct xfs_buf *bp);
 148
 149 /*
 150  * Grab the inode at @inum.  The caller must have created a scrub transaction
 151  * so that we can confirm the inumber by walking the inobt and not deadlock on
 152  * a loop in the inobt.
 153  */
 154 int xchk_iget(struct xfs_scrub *sc, xfs_ino_t inum, struct xfs_inode **ipp);
 155 int xchk_iget_agi(struct xfs_scrub *sc, xfs_ino_t inum,
 156                 struct xfs_buf **agi_bpp, struct xfs_inode **ipp);
 157 void xchk_irele(struct xfs_scrub *sc, struct xfs_inode *ip);
 158 int xchk_install_handle_inode(struct xfs_scrub *sc, struct xfs_inode *ip);
 159
 160 /*
 161  * Safe version of (untrusted) xchk_iget that uses an empty transaction to
 162  * avoid deadlocking on loops in the inobt.  This should only be used in a
 163  * scrub or repair setup routine, and only prior to grabbing a transaction.
 164  */
 165 static inline int
 166 xchk_iget_safe(struct xfs_scrub *sc, xfs_ino_t inum, struct xfs_inode **ipp)
 167 {
 168         int     error;
 169
 170         ASSERT(sc->tp == NULL);
 171
 172         error = xchk_trans_alloc(sc, 0);
 173         if (error)
 174                 return error;
 175         error = xchk_iget(sc, inum, ipp);
 176         xchk_trans_cancel(sc);
 177         return error;
 178 }
 179
 180 /*
 181  * Don't bother cross-referencing if we already found corruption or cross
 182  * referencing discrepancies.
 183  */
 184 static inline bool xchk_skip_xref(struct xfs_scrub_metadata *sm)
 185 {
 186         return sm->sm_flags & (XFS_SCRUB_OFLAG_CORRUPT |
 187                                XFS_SCRUB_OFLAG_XCORRUPT);
 188 }
 189
 190 bool xchk_dir_looks_zapped(struct xfs_inode *dp);
 191 bool xchk_pptr_looks_zapped(struct xfs_inode *ip);
 192
 193 #ifdef CONFIG_XFS_ONLINE_REPAIR
 194 /* Decide if a repair is required. */
 195 static inline bool xchk_needs_repair(const struct xfs_scrub_metadata *sm)
 196 {
 197         return sm->sm_flags & (XFS_SCRUB_OFLAG_CORRUPT |
 198                                XFS_SCRUB_OFLAG_XCORRUPT |
 199                                XFS_SCRUB_OFLAG_PREEN);
 200 }
 201
 202 /*
 203  * "Should we prepare for a repair?"
 204  *
 205  * Return true if the caller permits us to repair metadata and we're not
 206  * setting up for a post-repair evaluation.
 207  */
 208 static inline bool xchk_could_repair(const struct xfs_scrub *sc)
 209 {
 210         return (sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR) &&
 211                 !(sc->flags & XREP_ALREADY_FIXED);
 212 }
 213 #else
 214 # define xchk_needs_repair(sc)          (false)
 215 # define xchk_could_repair(sc)          (false)
 216 #endif /* CONFIG_XFS_ONLINE_REPAIR */
 217
 218 int xchk_metadata_inode_forks(struct xfs_scrub *sc);
 219
 220 /*
 221  * Helper macros to allocate and format xfile description strings.
 222  * Callers must kfree the pointer returned.
 223  */
 224 #define xchk_xfile_descr(sc, fmt, ...) \
 225         kasprintf(XCHK_GFP_FLAGS, "XFS (%s): " fmt, \
 226                         (sc)->mp->m_super->s_id, ##__VA_ARGS__)
 227 #define xchk_xfile_ag_descr(sc, fmt, ...) \
 228         kasprintf(XCHK_GFP_FLAGS, "XFS (%s): AG 0x%x " fmt, \
 229                         (sc)->mp->m_super->s_id, \
 230                         (sc)->sa.pag ? (sc)->sa.pag->pag_agno : (sc)->sm->sm_agno, \
 231                         ##__VA_ARGS__)
 232 #define xchk_xfile_ino_descr(sc, fmt, ...) \
 233         kasprintf(XCHK_GFP_FLAGS, "XFS (%s): inode 0x%llx " fmt, \
 234                         (sc)->mp->m_super->s_id, \
 235                         (sc)->ip ? (sc)->ip->i_ino : (sc)->sm->sm_ino, \
 236                         ##__VA_ARGS__)
 237
 238 /*
 239  * Setting up a hook to wait for intents to drain is costly -- we have to take
 240  * the CPU hotplug lock and force an i-cache flush on all CPUs once to set it
 241  * up, and again to tear it down.  These costs add up quickly, so we only want
 242  * to enable the drain waiter if the drain actually detected a conflict with
 243  * running intent chains.
 244  */
 245 static inline bool xchk_need_intent_drain(struct xfs_scrub *sc)
 246 {
 247         return sc->flags & XCHK_NEED_DRAIN;
 248 }
 249
 250 void xchk_fsgates_enable(struct xfs_scrub *sc, unsigned int scrub_fshooks);
 251
 252 int xchk_inode_is_allocated(struct xfs_scrub *sc, xfs_agino_t agino,
 253                 bool *inuse);
 254
 255 #endif  /* __XFS_SCRUB_COMMON_H__ */