/* * Disposal of Blocks from Old Metadata * * Now that we've constructed a new btree to replace the damaged one, we want * to dispose of the blocks that (we think) the old btree was using. * Previously, we used the rmapbt to collect the extents (bitmap) with the * rmap owner corresponding to the tree we rebuilt, collected extents for any * blocks with the same rmap owner that are owned by another data structure * (sublist), and subtracted sublist from bitmap. In theory the extents * remaining in bitmap are the old btree's blocks. * * Unfortunately, it's possible that the btree was crosslinked with other * blocks on disk. The rmap data can tell us if there are multiple owners, so * if the rmapbt says there is an owner of this block other than @oinfo, then * the block is crosslinked. Remove the reverse mapping and continue. * * If there is one rmap record, we can free the block, which removes the * reverse mapping but doesn't add the block to the free space. Our repair * strategy is to hope the other metadata objects crosslinked on this block * will be rebuilt (atop different blocks), thereby removing all the cross * links. * * If there are no rmap records at all, we also free the block. If the btree * being rebuilt lives in the free space (bnobt/cntbt/rmapbt) then there isn't * supposed to be a rmap record and everything is ok. For other btrees there * had to have been an rmap entry for the block to have ended up on @bitmap, * so if it's gone now there's something wrong and the fs will shut down. * * Note: If there are multiple rmap records with only the same rmap owner as * the btree we're trying to rebuild and the block is indeed owned by another * data structure with the same rmap owner, then the block will be in sublist * and therefore doesn't need disposal. If there are multiple rmap records * with only the same rmap owner but the block is not owned by something with * the same rmap owner, the block will be freed. * * The caller is responsible for locking the AG headers/inode for the entire * rebuild operation so that nothing else can sneak in and change the incore * state while we're not looking. We must also invalidate any buffers * associated with @bitmap.
*/
/* Information about reaping extents after a repair. */ struct xreap_state { struct xfs_scrub *sc;
/* If true, roll the transaction before reaping the next extent. */ bool force_roll;
/* Number of deferred reaps attached to the current transaction. */ unsignedint deferred;
/* Number of invalidated buffers logged to the current transaction. */ unsignedint invalidated;
/* Number of deferred reaps queued during the whole reap sequence. */ unsignedlonglong total_deferred;
};
/* Put a block back on the AGFL. */ STATICint
xreap_put_freelist( struct xfs_scrub *sc,
xfs_agblock_t agbno)
{ struct xfs_buf *agfl_bp; int error;
/* Make sure there's space on the freelist. */
error = xrep_fix_freelist(sc, 0); if (error) return error;
/* * Since we're "freeing" a lost block onto the AGFL, we have to * create an rmap for the block prior to merging it or else other * parts will break.
*/
error = xfs_rmap_alloc(sc->tp, sc->sa.agf_bp, sc->sa.pag, agbno, 1,
&XFS_RMAP_OINFO_AG); if (error) return error;
/* Put the block on the AGFL. */
error = xfs_alloc_read_agfl(sc->sa.pag, sc->tp, &agfl_bp); if (error) return error;
/* Are there any uncommitted reap operations? */ staticinlinebool xreap_dirty(conststruct xreap_state *rs)
{ if (rs->force_roll) returntrue; if (rs->deferred) returntrue; if (rs->invalidated) returntrue; if (rs->total_deferred) returntrue; returnfalse;
}
#define XREAP_MAX_BINVAL (2048)
/* * Decide if we want to roll the transaction after reaping an extent. We don't * want to overrun the transaction reservation, so we prohibit more than * 128 EFIs per transaction. For the same reason, we limit the number * of buffer invalidations to 2048.
*/ staticinlinebool xreap_want_roll(conststruct xreap_state *rs)
{ if (rs->force_roll) returntrue; if (rs->deferred > XREP_MAX_ITRUNCATE_EFIS) returntrue; if (rs->invalidated > XREAP_MAX_BINVAL) returntrue; returnfalse;
}
/* * Decide if we want to finish the deferred ops that are attached to the scrub * transaction. We don't want to queue huge chains of deferred ops because * that can consume a lot of log space and kernel memory. Hence we trigger a * xfs_defer_finish if there are more than 2048 deferred reap operations or the * caller did some real work.
*/ staticinlinebool
xreap_want_defer_finish(conststruct xreap_state *rs)
{ if (rs->force_roll) returntrue; if (rs->total_deferred > XREAP_MAX_DEFER_CHAIN) returntrue; returnfalse;
}
/* * Compute the maximum length of a buffer cache scan (in units of sectors), * given a quantity of fs blocks.
*/
xfs_daddr_t
xrep_bufscan_max_sectors( struct xfs_mount *mp,
xfs_extlen_t fsblocks)
{ int max_fsbs;
/* Remote xattr values are the largest buffers that we support. */
max_fsbs = xfs_attr3_max_rmt_blocks(mp);
/* * Return an incore buffer from a sector scan, or NULL if there are no buffers * left to return.
*/ struct xfs_buf *
xrep_bufscan_advance( struct xfs_mount *mp, struct xrep_bufscan *scan)
{
scan->__sector_count += scan->daddr_step; while (scan->__sector_count <= scan->max_sectors) { struct xfs_buf *bp = NULL; int error;
/* Try to invalidate the incore buffers for an extent that we're freeing. */ STATICvoid
xreap_agextent_binval( struct xreap_state *rs,
xfs_agblock_t agbno,
xfs_extlen_t *aglenp)
{ struct xfs_scrub *sc = rs->sc; struct xfs_perag *pag = sc->sa.pag; struct xfs_mount *mp = sc->mp;
xfs_agblock_t agbno_next = agbno + *aglenp;
xfs_agblock_t bno = agbno;
/* * Avoid invalidating AG headers and post-EOFS blocks because we never * own those.
*/ if (!xfs_verify_agbno(pag, agbno) ||
!xfs_verify_agbno(pag, agbno_next - 1)) return;
/* * If there are incore buffers for these blocks, invalidate them. We * assume that the lack of any other known owners means that the buffer * can be locked without risk of deadlocking. The buffer cache cannot * detect aliasing, so employ nested loops to scan for incore buffers * of any plausible size.
*/ while (bno < agbno_next) { struct xrep_bufscan scan = {
.daddr = xfs_agbno_to_daddr(pag, bno),
.max_sectors = xrep_bufscan_max_sectors(mp,
agbno_next - bno),
.daddr_step = XFS_FSB_TO_BB(mp, 1),
}; struct xfs_buf *bp;
/* * Stop invalidating if we've hit the limit; we should * still have enough reservation left to free however * far we've gotten.
*/ if (rs->invalidated > XREAP_MAX_BINVAL) {
*aglenp -= agbno_next - bno; goto out;
}
}
/* * Figure out the longest run of blocks that we can dispose of with a single * call. Cross-linked blocks should have their reverse mappings removed, but * single-owner extents can be freed. AGFL blocks can only be put back one at * a time.
*/ STATICint
xreap_agextent_select( struct xreap_state *rs,
xfs_agblock_t agbno,
xfs_agblock_t agbno_next, bool *crosslinked,
xfs_extlen_t *aglenp)
{ struct xfs_scrub *sc = rs->sc; struct xfs_btree_cur *cur;
xfs_agblock_t bno = agbno + 1;
xfs_extlen_t len = 1; int error;
/* * Determine if there are any other rmap records covering the first * block of this extent. If so, the block is crosslinked.
*/
cur = xfs_rmapbt_init_cursor(sc->mp, sc->tp, sc->sa.agf_bp,
sc->sa.pag);
error = xfs_rmap_has_other_keys(cur, agbno, 1, rs->oinfo,
crosslinked); if (error) goto out_cur;
/* AGFL blocks can only be deal with one at a time. */ if (rs->resv == XFS_AG_RESV_AGFL) goto out_found;
/* * Figure out how many of the subsequent blocks have the same crosslink * status.
*/ while (bno < agbno_next) { bool also_crosslinked;
/* * Dispose of as much of the beginning of this AG extent as possible. The * number of blocks disposed of will be returned in @aglenp.
*/ STATICint
xreap_agextent_iter( struct xreap_state *rs,
xfs_agblock_t agbno,
xfs_extlen_t *aglenp, bool crosslinked)
{ struct xfs_scrub *sc = rs->sc;
xfs_fsblock_t fsbno; int error = 0;
ASSERT(rs->resv != XFS_AG_RESV_METAFILE);
fsbno = xfs_agbno_to_fsb(sc->sa.pag, agbno);
/* * If there are other rmappings, this block is cross linked and must * not be freed. Remove the reverse mapping and move on. Otherwise, * we were the only owner of the block, so free the extent, which will * also remove the rmap. * * XXX: XFS doesn't support detecting the case where a single block * metadata structure is crosslinked with a multi-block structure * because the buffer cache doesn't detect aliasing problems, so we * can't fix 100% of crosslinking problems (yet). The verifiers will * blow on writeout, the filesystem will shut down, and the admin gets * to run xfs_repair.
*/ if (crosslinked) {
trace_xreap_dispose_unmap_extent(pag_group(sc->sa.pag), agbno,
*aglenp);
if (rs->oinfo == &XFS_RMAP_OINFO_COW) { /* * If we're unmapping CoW staging extents, remove the * records from the refcountbt, which will remove the * rmap record as well.
*/
xfs_refcount_free_cow_extent(sc->tp, false, fsbno,
*aglenp);
rs->force_roll = true; return 0;
}
/* * Invalidate as many buffers as we can, starting at agbno. If this * function sets *aglenp to zero, the transaction is full of logged * buffer invalidations, so we need to return early so that we can * roll and retry.
*/
xreap_agextent_binval(rs, agbno, aglenp); if (*aglenp == 0) {
ASSERT(xreap_want_roll(rs)); return 0;
}
/* * If we're getting rid of CoW staging extents, use deferred work items * to remove the refcountbt records (which removes the rmap records) * and free the extent. We're not worried about the system going down * here because log recovery walks the refcount btree to clean out the * CoW staging extents.
*/ if (rs->oinfo == &XFS_RMAP_OINFO_COW) {
ASSERT(rs->resv == XFS_AG_RESV_NONE);
/* Put blocks back on the AGFL one at a time. */ if (rs->resv == XFS_AG_RESV_AGFL) {
ASSERT(*aglenp == 1);
error = xreap_put_freelist(sc, agbno); if (error) return error;
rs->force_roll = true; return 0;
}
/* * Use deferred frees to get rid of the old btree blocks to try to * minimize the window in which we could crash and lose the old blocks. * Add a defer ops barrier every other extent to avoid stressing the * system with large EFIs.
*/
error = xfs_free_extent_later(sc->tp, fsbno, *aglenp, rs->oinfo,
rs->resv, XFS_FREE_EXTENT_SKIP_DISCARD); if (error) return error;
/* * We're reaping blocks after repairing file metadata, which means that * we have to init the xchk_ag structure ourselves.
*/
sc->sa.pag = xfs_perag_get(sc->mp, agno); if (!sc->sa.pag) return -EFSCORRUPTED;
error = xfs_alloc_read_agf(sc->sa.pag, sc->tp, 0, &sc->sa.agf_bp); if (error) goto out_pag;
while (agbno < agbno_next) {
xfs_extlen_t aglen; bool crosslinked;
error = xreap_agextent_iter(rs, agbno, &aglen, crosslinked); if (error) goto out_agf;
if (xreap_want_defer_finish(rs)) { /* * Holds the AGF buffer across the deferred chain * processing.
*/
error = xrep_defer_finish(sc); if (error) goto out_agf;
xreap_defer_finish_reset(rs);
} elseif (xreap_want_roll(rs)) { /* * Hold the AGF buffer across the transaction roll so * that we don't have to reattach it to the scrub * context.
*/
xfs_trans_bhold(sc->tp, sc->sa.agf_bp);
error = xfs_trans_roll_inode(&sc->tp, sc->ip);
xfs_trans_bjoin(sc->tp, sc->sa.agf_bp); if (error) goto out_agf;
xreap_reset(rs);
}
/* * Dispose of every block of every fs metadata extent in the bitmap. * Do not use this to dispose of the mappings in an ondisk inode fork.
*/ int
xrep_reap_fsblocks( struct xfs_scrub *sc, struct xfsb_bitmap *bitmap, conststruct xfs_owner_info *oinfo)
{ struct xreap_state rs = {
.sc = sc,
.oinfo = oinfo,
.resv = XFS_AG_RESV_NONE,
}; int error;
error = xfsb_bitmap_walk(bitmap, xreap_fsmeta_extent, &rs); if (error) return error;
if (xreap_dirty(&rs)) return xrep_defer_finish(sc);
return 0;
}
#ifdef CONFIG_XFS_RT /* * Figure out the longest run of blocks that we can dispose of with a single * call. Cross-linked blocks should have their reverse mappings removed, but * single-owner extents can be freed. Units are rt blocks, not rt extents.
*/ STATICint
xreap_rgextent_select( struct xreap_state *rs,
xfs_rgblock_t rgbno,
xfs_rgblock_t rgbno_next, bool *crosslinked,
xfs_extlen_t *rglenp)
{ struct xfs_scrub *sc = rs->sc; struct xfs_btree_cur *cur;
xfs_rgblock_t bno = rgbno + 1;
xfs_extlen_t len = 1; int error;
/* * Determine if there are any other rmap records covering the first * block of this extent. If so, the block is crosslinked.
*/
cur = xfs_rtrmapbt_init_cursor(sc->tp, sc->sr.rtg);
error = xfs_rmap_has_other_keys(cur, rgbno, 1, rs->oinfo,
crosslinked); if (error) goto out_cur;
/* * Figure out how many of the subsequent blocks have the same crosslink * status.
*/ while (bno < rgbno_next) { bool also_crosslinked;
/* * Dispose of as much of the beginning of this rtgroup extent as possible. * The number of blocks disposed of will be returned in @rglenp.
*/ STATICint
xreap_rgextent_iter( struct xreap_state *rs,
xfs_rgblock_t rgbno,
xfs_extlen_t *rglenp, bool crosslinked)
{ struct xfs_scrub *sc = rs->sc;
xfs_rtblock_t rtbno; int error;
/* * The only caller so far is CoW fork repair, so we only know how to * unlink or free CoW staging extents. Here we don't have to worry * about invalidating buffers!
*/ if (rs->oinfo != &XFS_RMAP_OINFO_COW) {
ASSERT(rs->oinfo == &XFS_RMAP_OINFO_COW); return -EFSCORRUPTED;
}
ASSERT(rs->resv == XFS_AG_RESV_NONE);
rtbno = xfs_rgbno_to_rtb(sc->sr.rtg, rgbno);
/* * If there are other rmappings, this block is cross linked and must * not be freed. Remove the forward and reverse mapping and move on.
*/ if (crosslinked) {
trace_xreap_dispose_unmap_extent(rtg_group(sc->sr.rtg), rgbno,
*rglenp);
/* * The CoW staging extent is not crosslinked. Use deferred work items * to remove the refcountbt records (which removes the rmap records) * and free the extent. We're not worried about the system going down * here because log recovery walks the refcount btree to clean out the * CoW staging extents.
*/
xfs_refcount_free_cow_extent(sc->tp, true, rtbno, *rglenp);
error = xfs_free_extent_later(sc->tp, rtbno, *rglenp, NULL,
rs->resv,
XFS_FREE_EXTENT_REALTIME |
XFS_FREE_EXTENT_SKIP_DISCARD); if (error) return error;
/* * Break a rt file metadata extent into sub-extents by fate (crosslinked, not * crosslinked), and dispose of each sub-extent separately. The extent must * be aligned to a realtime extent.
*/ STATICint
xreap_rtmeta_extent(
uint64_t rtbno,
uint64_t len, void *priv)
{ struct xreap_state *rs = priv; struct xfs_scrub *sc = rs->sc;
xfs_rgblock_t rgbno = xfs_rtb_to_rgbno(sc->mp, rtbno);
xfs_rgblock_t rgbno_next = rgbno + len; int error = 0;
ASSERT(sc->ip != NULL);
ASSERT(!sc->sr.rtg);
/* * We're reaping blocks after repairing file metadata, which means that * we have to init the xchk_ag structure ourselves.
*/
sc->sr.rtg = xfs_rtgroup_get(sc->mp, xfs_rtb_to_rgno(sc->mp, rtbno)); if (!sc->sr.rtg) return -EFSCORRUPTED;
xfs_rtgroup_lock(sc->sr.rtg, XREAP_RTGLOCK_ALL);
while (rgbno < rgbno_next) {
xfs_extlen_t rglen; bool crosslinked;
/* * Dispose of every block of every rt metadata extent in the bitmap. * Do not use this to dispose of the mappings in an ondisk inode fork.
*/ int
xrep_reap_rtblocks( struct xfs_scrub *sc, struct xrtb_bitmap *bitmap, conststruct xfs_owner_info *oinfo)
{ struct xreap_state rs = {
.sc = sc,
.oinfo = oinfo,
.resv = XFS_AG_RESV_NONE,
}; int error;
error = xrtb_bitmap_walk(bitmap, xreap_rtmeta_extent, &rs); if (error) return error;
if (xreap_dirty(&rs)) return xrep_defer_finish(sc);
return 0;
} #endif/* CONFIG_XFS_RT */
/* * Dispose of every block of an old metadata btree that used to be rooted in a * metadata directory file.
*/ int
xrep_reap_metadir_fsblocks( struct xfs_scrub *sc, struct xfsb_bitmap *bitmap)
{ /* * Reap old metadir btree blocks with XFS_AG_RESV_NONE because the old * blocks are no longer mapped by the inode, and inode metadata space * reservations can only account freed space to the i_nblocks.
*/ struct xfs_owner_info oinfo; struct xreap_state rs = {
.sc = sc,
.oinfo = &oinfo,
.resv = XFS_AG_RESV_NONE,
}; int error;
error = xfsb_bitmap_walk(bitmap, xreap_fsmeta_extent, &rs); if (error) return error;
if (xreap_dirty(&rs)) {
error = xrep_defer_finish(sc); if (error) return error;
}
return xrep_reset_metafile_resv(sc);
}
/* * Metadata files are not supposed to share blocks with anything else. * If blocks are shared, we remove the reverse mapping (thus reducing the * crosslink factor); if blocks are not shared, we also need to free them. * * This first step determines the longest subset of the passed-in imap * (starting at its beginning) that is either crosslinked or not crosslinked. * The blockcount will be adjust down as needed.
*/ STATICint
xreap_bmapi_select( struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork, struct xfs_bmbt_irec *imap, bool *crosslinked)
{ struct xfs_owner_info oinfo; struct xfs_btree_cur *cur;
xfs_filblks_t len = 1;
xfs_agblock_t bno;
xfs_agblock_t agbno;
xfs_agblock_t agbno_next; int error;
/* * Decide if this buffer can be joined to a transaction. This is true for most * buffers, but there are two cases that we want to catch: large remote xattr * value buffers are not logged and can overflow the buffer log item dirty * bitmap size; and oversized cached buffers if things have really gone * haywire.
*/ staticinlinebool
xreap_buf_loggable( conststruct xfs_buf *bp)
{ int i;
for (i = 0; i < bp->b_map_count; i++) { int chunks; int map_size;
/* * Invalidate any buffers for this file mapping. The @imap blockcount may be * adjusted downward if we need to roll the transaction.
*/ STATICint
xreap_bmapi_binval( struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork, struct xfs_bmbt_irec *imap)
{ struct xfs_mount *mp = sc->mp; struct xfs_perag *pag = sc->sa.pag; int bmap_flags = xfs_bmapi_aflag(whichfork);
xfs_fileoff_t off;
xfs_fileoff_t max_off;
xfs_extlen_t scan_blocks;
xfs_agblock_t bno;
xfs_agblock_t agbno;
xfs_agblock_t agbno_next; unsignedint invalidated = 0; int error;
/* * Avoid invalidating AG headers and post-EOFS blocks because we never * own those.
*/
agbno = bno = XFS_FSB_TO_AGBNO(sc->mp, imap->br_startblock);
agbno_next = agbno + imap->br_blockcount; if (!xfs_verify_agbno(pag, agbno) ||
!xfs_verify_agbno(pag, agbno_next - 1)) return 0;
/* * Buffers for file blocks can span multiple contiguous mappings. This * means that for each block in the mapping, there could exist an * xfs_buf indexed by that block with any length up to the maximum * buffer size (remote xattr values) or to the next hole in the fork. * To set up our binval scan, first we need to figure out the location * of the next hole.
*/
off = imap->br_startoff + imap->br_blockcount;
max_off = off + xfs_attr3_max_rmt_blocks(mp); while (off < max_off) { struct xfs_bmbt_irec hmap; int nhmaps = 1;
/* * If there are incore buffers for these blocks, invalidate them. If * we can't (try)lock the buffer we assume it's owned by someone else * and leave it alone. The buffer cache cannot detect aliasing, so * employ nested loops to detect incore buffers of any plausible size.
*/ while (bno < agbno_next) { struct xrep_bufscan scan = {
.daddr = xfs_agbno_to_daddr(pag, bno),
.max_sectors = xrep_bufscan_max_sectors(mp,
scan_blocks),
.daddr_step = XFS_FSB_TO_BB(mp, 1),
}; struct xfs_buf *bp;
/* * Stop invalidating if we've hit the limit; we should * still have enough reservation left to free however * much of the mapping we've seen so far.
*/ if (invalidated > XREAP_MAX_BINVAL) {
imap->br_blockcount = agbno_next - bno; goto out;
}
}
/* * Dispose of as much of the beginning of this file fork mapping as possible. * The number of blocks disposed of is returned in @imap->br_blockcount.
*/ STATICint
xrep_reap_bmapi_iter( struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork, struct xfs_bmbt_irec *imap, bool crosslinked)
{ int error;
if (crosslinked) { /* * If there are other rmappings, this block is cross linked and * must not be freed. Remove the reverse mapping, leave the * buffer cache in its possibly confused state, and move on. * We don't want to risk discarding valid data buffers from * anybody else who thinks they own the block, even though that * runs the risk of stale buffer warnings in the future.
*/
trace_xreap_dispose_unmap_extent(pag_group(sc->sa.pag),
XFS_FSB_TO_AGBNO(sc->mp, imap->br_startblock),
imap->br_blockcount);
/* * Schedule removal of the mapping from the fork. We use * deferred log intents in this function to control the exact * sequence of metadata updates.
*/
xfs_bmap_unmap_extent(sc->tp, ip, whichfork, imap);
xfs_trans_mod_dquot_byino(sc->tp, ip, XFS_TRANS_DQ_BCOUNT,
-(int64_t)imap->br_blockcount);
xfs_rmap_unmap_extent(sc->tp, ip, whichfork, imap); return 0;
}
/* * If the block is not crosslinked, we can invalidate all the incore * buffers for the extent, and then free the extent. This is a bit of * a mess since we don't detect discontiguous buffers that are indexed * by a block starting before the first block of the extent but overlap * anyway.
*/
trace_xreap_dispose_free_extent(pag_group(sc->sa.pag),
XFS_FSB_TO_AGBNO(sc->mp, imap->br_startblock),
imap->br_blockcount);
/* * Invalidate as many buffers as we can, starting at the beginning of * this mapping. If this function sets blockcount to zero, the * transaction is full of logged buffer invalidations, so we need to * return early so that we can roll and retry.
*/
error = xreap_bmapi_binval(sc, ip, whichfork, imap); if (error || imap->br_blockcount == 0) return error;
/* * Schedule removal of the mapping from the fork. We use deferred log * intents in this function to control the exact sequence of metadata * updates.
*/
xfs_bmap_unmap_extent(sc->tp, ip, whichfork, imap);
xfs_trans_mod_dquot_byino(sc->tp, ip, XFS_TRANS_DQ_BCOUNT,
-(int64_t)imap->br_blockcount); return xfs_free_extent_later(sc->tp, imap->br_startblock,
imap->br_blockcount, NULL, XFS_AG_RESV_NONE,
XFS_FREE_EXTENT_SKIP_DISCARD);
}
/* * Dispose of as much of this file extent as we can. Upon successful return, * the imap will reflect the mapping that was removed from the fork.
*/ STATICint
xreap_ifork_extent( struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork, struct xfs_bmbt_irec *imap)
{
xfs_agnumber_t agno; bool crosslinked; int error;
error = xfs_alloc_read_agf(sc->sa.pag, sc->tp, 0, &sc->sa.agf_bp); if (error) goto out_pag;
/* * Decide the fate of the blocks at the beginning of the mapping, then * update the mapping to use it with the unmap calls.
*/
error = xreap_bmapi_select(sc, ip, whichfork, imap, &crosslinked); if (error) goto out_agf;
/* * Dispose of each block mapped to the given fork of the given file. Callers * must hold ILOCK_EXCL, and ip can only be sc->ip or sc->tempip. The fork * must not have any delalloc reservations.
*/ int
xrep_reap_ifork( struct xfs_scrub *sc, struct xfs_inode *ip, int whichfork)
{
xfs_fileoff_t off = 0; int bmap_flags = xfs_bmapi_aflag(whichfork); int error;
while (off < XFS_MAX_FILEOFF) { struct xfs_bmbt_irec imap; int nimaps = 1;
/* Read the next extent, skip past holes and delalloc. */
error = xfs_bmapi_read(ip, off, XFS_MAX_FILEOFF - off, &imap,
&nimaps, bmap_flags); if (error) return error; if (nimaps != 1 || imap.br_startblock == DELAYSTARTBLOCK) {
ASSERT(0); return -EFSCORRUPTED;
}
/* * If this is a real space mapping, reap as much of it as we * can in a single transaction.
*/ if (xfs_bmap_is_real_extent(&imap)) {
error = xreap_ifork_extent(sc, ip, whichfork, &imap); if (error) return error;
error = xfs_defer_finish(&sc->tp); if (error) return error;
}
off = imap.br_startoff + imap.br_blockcount;
}
return 0;
}
Messung V0.5
¤ Dauer der Verarbeitung: 0.3 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
