Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300// 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_platform.h"#include "xfs_fs.h"#include "xfs_shared.h"#include "xfs_format.h"#include "xfs_trans_resv.h"#include "xfs_mount.h"#include "xfs_btree.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 "xfs_rtgroup.h"#include "xfs_sb.h"#include "xfs_rmap.h"#include "xfs_rtrmap_btree.h"#include "xfs_exchmaps.h"#include "xfs_zone_alloc.h"#include "scrub/scrub.h"#include "scrub/common.h"#include "scrub/repair.h"#include "scrub/tempexch.h"#include "scrub/rtbitmap.h"#include "scrub/btree.h"
/* Set us up with the realtime metadata locked. */intxchk_setup_rtbitmap( struct xfs_scrub *sc){ struct xfs_mount *mp = sc->mp; struct xchk_rtbitmap *rtb; int error;
if (xchk_need_intent_drain(sc)) xchk_fsgates_enable(sc, XCHK_FSGATES_DRAIN);
rtb = kzalloc_flex(*rtb, words, xchk_rtbitmap_wordcnt(sc), XCHK_GFP_FLAGS); if (!rtb) return -ENOMEM; sc->buf = rtb; rtb->sc = sc;
error = xchk_rtgroup_init(sc, sc->sm->sm_agno, &sc->sr); if (error) return error;
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, rtg_bitmap(sc->sr.rtg)); if (error) return error;
error = xchk_ino_dqattach(sc); if (error) return error;
error = xchk_rtgroup_lock(sc, &sc->sr, XCHK_RTGLOCK_ALL); if (error) return error;
/* * 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_blen_to_rtbxlen(mp, mp->m_sb.sb_rblocks); rtb->rextslog = xfs_compute_rextslog(rtb->rextents); rtb->rbmblocks = xfs_rtbitmap_blockcount(mp); }
return 0;}
/* Per-rtgroup bitmap contents. */
/* Cross-reference rtbitmap entries with other metadata. */STATIC voidxchk_rtbitmap_xref( struct xchk_rtbitmap *rtb, xfs_rtblock_t startblock, xfs_rtblock_t blockcount){ struct xfs_scrub *sc = rtb->sc; xfs_rgblock_t rgbno = xfs_rtb_to_rgbno(sc->mp, startblock);
if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) return; if (!sc->sr.rmap_cur) return;
xchk_xref_has_no_rt_owner(sc, rgbno, blockcount); xchk_xref_is_not_rt_shared(sc, rgbno, blockcount); xchk_xref_is_not_rt_cow_staging(sc, rgbno, blockcount);
if (rtb->next_free_rgbno < rgbno) xchk_xref_has_rt_owner(sc, rtb->next_free_rgbno, rgbno - rtb->next_free_rgbno); rtb->next_free_rgbno = rgbno + blockcount;}
/* Scrub a free extent record from the realtime bitmap. */STATIC intxchk_rtbitmap_rec( struct xfs_rtgroup *rtg, struct xfs_trans *tp, const struct xfs_rtalloc_rec *rec, void *priv){ struct xchk_rtbitmap *rtb = priv; struct xfs_scrub *sc = rtb->sc; xfs_rtblock_t startblock; xfs_filblks_t blockcount;
startblock = xfs_rtx_to_rtb(rtg, rec->ar_startext); blockcount = xfs_rtxlen_to_extlen(rtg_mount(rtg), rec->ar_extcount);
if (!xfs_verify_rtbext(rtg_mount(rtg), startblock, blockcount)) xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
xchk_rtbitmap_xref(rtb, startblock, blockcount);
if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT) return -ECANCELED;
return 0;}
/* Make sure the entire rtbitmap file is mapped with written extents. */STATIC intxchk_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 this group's realtime bitmap. */intxchk_rtbitmap( struct xfs_scrub *sc){ struct xfs_mount *mp = sc->mp; struct xfs_rtgroup *rtg = sc->sr.rtg; struct xfs_inode *rbmip = rtg_bitmap(rtg); struct xchk_rtbitmap *rtb = sc->buf; xfs_rgblock_t last_rgbno; int error;
/* Is sb_rextents correct? */ if (mp->m_sb.sb_rextents != rtb->rextents) { xchk_ip_set_corrupt(sc, rbmip); return 0; }
/* Is sb_rextslog correct? */ if (mp->m_sb.sb_rextslog != rtb->rextslog) { xchk_ip_set_corrupt(sc, rbmip); 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_ip_set_corrupt(sc, rbmip); return 0; } if (mp->m_sb.sb_rbmblocks != rtb->rbmblocks) { xchk_ip_set_corrupt(sc, rbmip); return 0; }
/* The bitmap file length must be aligned to an fsblock. */ if (rbmip->i_disk_size & mp->m_blockmask) { xchk_ip_set_corrupt(sc, rbmip); 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 (rbmip->i_disk_size < XFS_FSB_TO_B(mp, rtb->rbmblocks)) { xchk_ip_set_corrupt(sc, rbmip); 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;
rtb->next_free_rgbno = 0; error = xfs_rtalloc_query_all(rtg, sc->tp, xchk_rtbitmap_rec, rtb); if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error)) return error;
/* * Check that the are rmappings for all rt extents between the end of * the last free extent we saw and the last possible extent in the rt * group. */ last_rgbno = rtg->rtg_extents * mp->m_sb.sb_rextsize; if (rtb->next_free_rgbno < last_rgbno) xchk_xref_has_rt_owner(sc, rtb->next_free_rgbno, last_rgbno - rtb->next_free_rgbno); return 0;}
/* xref check that the extent is not free in the rtbitmap */voidxchk_xref_is_used_rt_space( struct xfs_scrub *sc, xfs_rtblock_t rtbno, xfs_extlen_t len){ struct xfs_rtgroup *rtg = sc->sr.rtg; xfs_rtxnum_t startext; xfs_rtxnum_t endext; bool is_free; int error;
if (xchk_skip_xref(sc->sm)) return;
if (xfs_has_zoned(sc->mp)) { if (!xfs_zone_rgbno_is_valid(rtg, xfs_rtb_to_rgbno(sc->mp, rtbno) + len - 1)) xchk_ip_xref_set_corrupt(sc, rtg_rmap(rtg)); return; }
startext = xfs_rtb_to_rtx(sc->mp, rtbno); endext = xfs_rtb_to_rtx(sc->mp, rtbno + len - 1); error = xfs_rtalloc_extent_is_free(rtg, sc->tp, startext, endext - startext + 1, &is_free); if (!xchk_should_check_xref(sc, &error, NULL)) return; if (is_free) xchk_ip_xref_set_corrupt(sc, rtg_bitmap(rtg));}