fs/xfs/scrub/rtbitmap.c

   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 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_trans_resv.h"
  11 #include "xfs_mount.h"
  12 #include "xfs_log_format.h"
  13 #include "xfs_trans.h"
  14 #include "xfs_rtbitmap.h"
  15 #include "xfs_inode.h"
  16 #include "xfs_bmap.h"
  17 #include "xfs_bit.h"
  18 #include "xfs_sb.h"
  19 #include "scrub/scrub.h"
  20 #include "scrub/common.h"
  21 #include "scrub/repair.h"
  22 #include "scrub/rtbitmap.h"
  23
  24 /* Set us up with the realtime metadata locked. */
  25 int
  26 xchk_setup_rtbitmap(
  27         struct xfs_scrub        *sc)
  28 {
  29         struct xfs_mount        *mp = sc->mp;
  30         struct xchk_rtbitmap    *rtb;
  31         int                     error;
  32
  33         rtb = kzalloc(sizeof(struct xchk_rtbitmap), XCHK_GFP_FLAGS);
  34         if (!rtb)
  35                 return -ENOMEM;
  36         sc->buf = rtb;
  37
  38         error = xchk_rtgroup_init(sc, sc->sm->sm_agno, &sc->sr);
  39         if (error)
  40                 return error;
  41
  42         if (xchk_could_repair(sc)) {
  43                 error = xrep_setup_rtbitmap(sc, rtb);
  44                 if (error)
  45                         return error;
  46         }
  47
  48         error = xchk_trans_alloc(sc, rtb->resblks);
  49         if (error)
  50                 return error;
  51
  52         error = xchk_install_live_inode(sc,
  53                         sc->sr.rtg->rtg_inodes[XFS_RTGI_BITMAP]);
  54         if (error)
  55                 return error;
  56
  57         error = xchk_ino_dqattach(sc);
  58         if (error)
  59                 return error;
  60
  61         /*
  62          * Now that we've locked the rtbitmap, we can't race with growfsrt
  63          * trying to expand the bitmap or change the size of the rt volume.
  64          * Hence it is safe to compute and check the geometry values.
  65          */
  66         xchk_rtgroup_lock(&sc->sr, XFS_RTGLOCK_BITMAP);
  67         if (mp->m_sb.sb_rblocks) {
  68                 rtb->rextents = xfs_blen_to_rtbxlen(mp, mp->m_sb.sb_rblocks);
  69                 rtb->rextslog = xfs_compute_rextslog(rtb->rextents);
  70                 rtb->rbmblocks = xfs_rtbitmap_blockcount(mp);
  71         }
  72
  73         return 0;
  74 }
  75
  76 /* Realtime bitmap. */
  77
  78 /* Scrub a free extent record from the realtime bitmap. */
  79 STATIC int
  80 xchk_rtbitmap_rec(
  81         struct xfs_rtgroup      *rtg,
  82         struct xfs_trans        *tp,
  83         const struct xfs_rtalloc_rec *rec,
  84         void                    *priv)
  85 {
  86         struct xfs_scrub        *sc = priv;
  87         xfs_rtblock_t           startblock;
  88         xfs_filblks_t           blockcount;
  89
  90         startblock = xfs_rtx_to_rtb(rtg, rec->ar_startext);
  91         blockcount = xfs_rtxlen_to_extlen(rtg_mount(rtg), rec->ar_extcount);
  92
  93         if (!xfs_verify_rtbext(rtg_mount(rtg), startblock, blockcount))
  94                 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
  95         return 0;
  96 }
  97
  98 /* Make sure the entire rtbitmap file is mapped with written extents. */
  99 STATIC int
 100 xchk_rtbitmap_check_extents(
 101         struct xfs_scrub        *sc)
 102 {
 103         struct xfs_bmbt_irec    map;
 104         struct xfs_iext_cursor  icur;
 105         struct xfs_mount        *mp = sc->mp;
 106         struct xfs_inode        *ip = sc->ip;
 107         xfs_fileoff_t           off = 0;
 108         xfs_fileoff_t           endoff;
 109         int                     error = 0;
 110
 111         /* Mappings may not cross or lie beyond EOF. */
 112         endoff = XFS_B_TO_FSB(mp, ip->i_disk_size);
 113         if (xfs_iext_lookup_extent(ip, &ip->i_df, endoff, &icur, &map)) {
 114                 xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, endoff);
 115                 return 0;
 116         }
 117
 118         while (off < endoff) {
 119                 int             nmap = 1;
 120
 121                 if (xchk_should_terminate(sc, &error) ||
 122                     (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
 123                         break;
 124
 125                 /* Make sure we have a written extent. */
 126                 error = xfs_bmapi_read(ip, off, endoff - off, &map, &nmap,
 127                                 XFS_DATA_FORK);
 128                 if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, off, &error))
 129                         break;
 130
 131                 if (nmap != 1 || !xfs_bmap_is_written_extent(&map)) {
 132                         xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, off);
 133                         break;
 134                 }
 135
 136                 off += map.br_blockcount;
 137         }
 138
 139         return error;
 140 }
 141
 142 /* Scrub the realtime bitmap. */
 143 int
 144 xchk_rtbitmap(
 145         struct xfs_scrub        *sc)
 146 {
 147         struct xfs_mount        *mp = sc->mp;
 148         struct xfs_rtgroup      *rtg = sc->sr.rtg;
 149         struct xfs_inode        *rbmip = rtg->rtg_inodes[XFS_RTGI_BITMAP];
 150         struct xchk_rtbitmap    *rtb = sc->buf;
 151         int                     error;
 152
 153         /* Is sb_rextents correct? */
 154         if (mp->m_sb.sb_rextents != rtb->rextents) {
 155                 xchk_ino_set_corrupt(sc, rbmip->i_ino);
 156                 return 0;
 157         }
 158
 159         /* Is sb_rextslog correct? */
 160         if (mp->m_sb.sb_rextslog != rtb->rextslog) {
 161                 xchk_ino_set_corrupt(sc, rbmip->i_ino);
 162                 return 0;
 163         }
 164
 165         /*
 166          * Is sb_rbmblocks large enough to handle the current rt volume?  In no
 167          * case can we exceed 4bn bitmap blocks since the super field is a u32.
 168          */
 169         if (rtb->rbmblocks > U32_MAX) {
 170                 xchk_ino_set_corrupt(sc, rbmip->i_ino);
 171                 return 0;
 172         }
 173         if (mp->m_sb.sb_rbmblocks != rtb->rbmblocks) {
 174                 xchk_ino_set_corrupt(sc, rbmip->i_ino);
 175                 return 0;
 176         }
 177
 178         /* The bitmap file length must be aligned to an fsblock. */
 179         if (rbmip->i_disk_size & mp->m_blockmask) {
 180                 xchk_ino_set_corrupt(sc, rbmip->i_ino);
 181                 return 0;
 182         }
 183
 184         /*
 185          * Is the bitmap file itself large enough to handle the rt volume?
 186          * growfsrt expands the bitmap file before updating sb_rextents, so the
 187          * file can be larger than sb_rbmblocks.
 188          */
 189         if (rbmip->i_disk_size < XFS_FSB_TO_B(mp, rtb->rbmblocks)) {
 190                 xchk_ino_set_corrupt(sc, rbmip->i_ino);
 191                 return 0;
 192         }
 193
 194         /* Invoke the fork scrubber. */
 195         error = xchk_metadata_inode_forks(sc);
 196         if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
 197                 return error;
 198
 199         error = xchk_rtbitmap_check_extents(sc);
 200         if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
 201                 return error;
 202
 203         error = xfs_rtalloc_query_all(rtg, sc->tp, xchk_rtbitmap_rec, sc);
 204         if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
 205                 return error;
 206
 207         return 0;
 208 }
 209
 210 /* xref check that the extent is not free in the rtbitmap */
 211 void
 212 xchk_xref_is_used_rt_space(
 213         struct xfs_scrub        *sc,
 214         xfs_rtblock_t           rtbno,
 215         xfs_extlen_t            len)
 216 {
 217         struct xfs_rtgroup      *rtg = sc->sr.rtg;
 218         struct xfs_inode        *rbmip = rtg->rtg_inodes[XFS_RTGI_BITMAP];
 219         xfs_rtxnum_t            startext;
 220         xfs_rtxnum_t            endext;
 221         bool                    is_free;
 222         int                     error;
 223
 224         if (xchk_skip_xref(sc->sm))
 225                 return;
 226
 227         startext = xfs_rtb_to_rtx(sc->mp, rtbno);
 228         endext = xfs_rtb_to_rtx(sc->mp, rtbno + len - 1);
 229         error = xfs_rtalloc_extent_is_free(rtg, sc->tp, startext,
 230                         endext - startext + 1, &is_free);
 231         if (!xchk_should_check_xref(sc, &error, NULL))
 232                 return;
 233         if (is_free)
 234                 xchk_ino_xref_set_corrupt(sc, rbmip->i_ino);
 235 }