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