| // SPDX-License-Identifier: GPL-2.0-or-later |
| /* |
| * Copyright (C) 2017-2023 Oracle. All Rights Reserved. |
| * Author: Darrick J. Wong <djwong@kernel.org> |
| */ |
| #include "xfs.h" |
| #include "xfs_fs.h" |
| #include "xfs_shared.h" |
| #include "xfs_format.h" |
| #include "xfs_trans_resv.h" |
| #include "xfs_mount.h" |
| #include "xfs_log_format.h" |
| #include "xfs_trans.h" |
| #include "xfs_rtbitmap.h" |
| #include "xfs_inode.h" |
| #include "xfs_bmap.h" |
| #include "xfs_bit.h" |
| #include "scrub/scrub.h" |
| #include "scrub/common.h" |
| #include "scrub/repair.h" |
| #include "scrub/rtbitmap.h" |
| |
| /* Set us up with the realtime metadata locked. */ |
| int |
| xchk_setup_rtbitmap( |
| struct xfs_scrub *sc) |
| { |
| struct xfs_mount *mp = sc->mp; |
| struct xchk_rtbitmap *rtb; |
| int error; |
| |
| rtb = kzalloc(sizeof(struct xchk_rtbitmap), XCHK_GFP_FLAGS); |
| if (!rtb) |
| return -ENOMEM; |
| sc->buf = rtb; |
| |
| if (xchk_could_repair(sc)) { |
| error = xrep_setup_rtbitmap(sc, rtb); |
| if (error) |
| return error; |
| } |
| |
| error = xchk_trans_alloc(sc, rtb->resblks); |
| if (error) |
| return error; |
| |
| error = xchk_install_live_inode(sc, sc->mp->m_rbmip); |
| if (error) |
| return error; |
| |
| error = xchk_ino_dqattach(sc); |
| if (error) |
| return error; |
| |
| xchk_ilock(sc, XFS_ILOCK_EXCL | XFS_ILOCK_RTBITMAP); |
| |
| /* |
| * Now that we've locked the rtbitmap, we can't race with growfsrt |
| * trying to expand the bitmap or change the size of the rt volume. |
| * Hence it is safe to compute and check the geometry values. |
| */ |
| if (mp->m_sb.sb_rblocks) { |
| rtb->rextents = xfs_rtb_to_rtx(mp, mp->m_sb.sb_rblocks); |
| rtb->rextslog = xfs_compute_rextslog(rtb->rextents); |
| rtb->rbmblocks = xfs_rtbitmap_blockcount(mp, rtb->rextents); |
| } |
| return 0; |
| } |
| |
| /* Realtime bitmap. */ |
| |
| /* Scrub a free extent record from the realtime bitmap. */ |
| STATIC int |
| xchk_rtbitmap_rec( |
| struct xfs_mount *mp, |
| struct xfs_trans *tp, |
| const struct xfs_rtalloc_rec *rec, |
| void *priv) |
| { |
| struct xfs_scrub *sc = priv; |
| xfs_rtblock_t startblock; |
| xfs_filblks_t blockcount; |
| |
| startblock = xfs_rtx_to_rtb(mp, rec->ar_startext); |
| blockcount = xfs_rtx_to_rtb(mp, rec->ar_extcount); |
| |
| if (!xfs_verify_rtbext(mp, startblock, blockcount)) |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0); |
| return 0; |
| } |
| |
| /* Make sure the entire rtbitmap file is mapped with written extents. */ |
| STATIC int |
| xchk_rtbitmap_check_extents( |
| struct xfs_scrub *sc) |
| { |
| struct xfs_bmbt_irec map; |
| struct xfs_iext_cursor icur; |
| struct xfs_mount *mp = sc->mp; |
| struct xfs_inode *ip = sc->ip; |
| xfs_fileoff_t off = 0; |
| xfs_fileoff_t endoff; |
| int error = 0; |
| |
| /* Mappings may not cross or lie beyond EOF. */ |
| endoff = XFS_B_TO_FSB(mp, ip->i_disk_size); |
| if (xfs_iext_lookup_extent(ip, &ip->i_df, endoff, &icur, &map)) { |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, endoff); |
| return 0; |
| } |
| |
| while (off < endoff) { |
| int nmap = 1; |
| |
| if (xchk_should_terminate(sc, &error) || |
| (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) |
| break; |
| |
| /* Make sure we have a written extent. */ |
| error = xfs_bmapi_read(ip, off, endoff - off, &map, &nmap, |
| XFS_DATA_FORK); |
| if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, off, &error)) |
| break; |
| |
| if (nmap != 1 || !xfs_bmap_is_written_extent(&map)) { |
| xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, off); |
| break; |
| } |
| |
| off += map.br_blockcount; |
| } |
| |
| return error; |
| } |
| |
| /* Scrub the realtime bitmap. */ |
| int |
| xchk_rtbitmap( |
| struct xfs_scrub *sc) |
| { |
| struct xfs_mount *mp = sc->mp; |
| struct xchk_rtbitmap *rtb = sc->buf; |
| int error; |
| |
| /* Is sb_rextents correct? */ |
| if (mp->m_sb.sb_rextents != rtb->rextents) { |
| xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino); |
| return 0; |
| } |
| |
| /* Is sb_rextslog correct? */ |
| if (mp->m_sb.sb_rextslog != rtb->rextslog) { |
| xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino); |
| return 0; |
| } |
| |
| /* |
| * Is sb_rbmblocks large enough to handle the current rt volume? In no |
| * case can we exceed 4bn bitmap blocks since the super field is a u32. |
| */ |
| if (rtb->rbmblocks > U32_MAX) { |
| xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino); |
| return 0; |
| } |
| if (mp->m_sb.sb_rbmblocks != rtb->rbmblocks) { |
| xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino); |
| return 0; |
| } |
| |
| /* The bitmap file length must be aligned to an fsblock. */ |
| if (mp->m_rbmip->i_disk_size & mp->m_blockmask) { |
| xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino); |
| return 0; |
| } |
| |
| /* |
| * Is the bitmap file itself large enough to handle the rt volume? |
| * growfsrt expands the bitmap file before updating sb_rextents, so the |
| * file can be larger than sb_rbmblocks. |
| */ |
| if (mp->m_rbmip->i_disk_size < XFS_FSB_TO_B(mp, rtb->rbmblocks)) { |
| xchk_ino_set_corrupt(sc, mp->m_rbmip->i_ino); |
| return 0; |
| } |
| |
| /* Invoke the fork scrubber. */ |
| error = xchk_metadata_inode_forks(sc); |
| if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) |
| return error; |
| |
| error = xchk_rtbitmap_check_extents(sc); |
| if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) |
| return error; |
| |
| error = xfs_rtalloc_query_all(mp, sc->tp, xchk_rtbitmap_rec, sc); |
| if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error)) |
| return error; |
| |
| return 0; |
| } |
| |
| /* xref check that the extent is not free in the rtbitmap */ |
| void |
| xchk_xref_is_used_rt_space( |
| struct xfs_scrub *sc, |
| xfs_rtblock_t rtbno, |
| xfs_extlen_t len) |
| { |
| xfs_rtxnum_t startext; |
| xfs_rtxnum_t endext; |
| bool is_free; |
| int error; |
| |
| if (xchk_skip_xref(sc->sm)) |
| return; |
| |
| startext = xfs_rtb_to_rtx(sc->mp, rtbno); |
| endext = xfs_rtb_to_rtx(sc->mp, rtbno + len - 1); |
| xfs_ilock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); |
| error = xfs_rtalloc_extent_is_free(sc->mp, sc->tp, startext, |
| endext - startext + 1, &is_free); |
| if (!xchk_should_check_xref(sc, &error, NULL)) |
| goto out_unlock; |
| if (is_free) |
| xchk_ino_xref_set_corrupt(sc, sc->mp->m_rbmip->i_ino); |
| out_unlock: |
| xfs_iunlock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); |
| } |