From: "Darrick J. Wong" <darrick.wong@oracle.com> To: david@fromorbit.com, darrick.wong@oracle.com Cc: linux-fsdevel@vger.kernel.org, vishal.l.verma@intel.com, xfs@oss.sgi.com Subject: [PATCH 063/119] xfs: adjust refcount of an extent of blocks in refcount btree Date: Thu, 16 Jun 2016 18:24:35 -0700 [thread overview] Message-ID: <146612667589.12839.17197885347586278821.stgit@birch.djwong.org> (raw) In-Reply-To: <146612627129.12839.3827886950949809165.stgit@birch.djwong.org> Provide functions to adjust the reference counts for an extent of physical blocks stored in the refcount btree. v2: Refactor the left/right split code into a single function. Track the number of btree shape changes and record updates during a refcount update so that we can decide if we need to get a fresh transaction to continue. Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com> --- fs/xfs/libxfs/xfs_refcount.c | 783 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_error.h | 4 2 files changed, 786 insertions(+), 1 deletion(-) diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c index 4d483b5..d13393b 100644 --- a/fs/xfs/libxfs/xfs_refcount.c +++ b/fs/xfs/libxfs/xfs_refcount.c @@ -37,6 +37,12 @@ #include "xfs_bit.h" #include "xfs_refcount.h" +/* Allowable refcount adjustment amounts. */ +enum xfs_refc_adjust_op { + XFS_REFCOUNT_ADJUST_INCREASE = 1, + XFS_REFCOUNT_ADJUST_DECREASE = -1, +}; + /* * Look up the first record less than or equal to [bno, len] in the btree * given by cur. @@ -175,3 +181,780 @@ out_error: cur->bc_private.a.agno, error, _RET_IP_); return error; } + +/* + * Adjusting the Reference Count + * + * As stated elsewhere, the reference count btree (refcbt) stores + * >1 reference counts for extents of physical blocks. In this + * operation, we're either raising or lowering the reference count of + * some subrange stored in the tree: + * + * <------ adjustment range ------> + * ----+ +---+-----+ +--+--------+--------- + * 2 | | 3 | 4 | |17| 55 | 10 + * ----+ +---+-----+ +--+--------+--------- + * X axis is physical blocks number; + * reference counts are the numbers inside the rectangles + * + * The first thing we need to do is to ensure that there are no + * refcount extents crossing either boundary of the range to be + * adjusted. For any extent that does cross a boundary, split it into + * two extents so that we can increment the refcount of one of the + * pieces later: + * + * <------ adjustment range ------> + * ----+ +---+-----+ +--+--------+----+---- + * 2 | | 3 | 2 | |17| 55 | 10 | 10 + * ----+ +---+-----+ +--+--------+----+---- + * + * For this next step, let's assume that all the physical blocks in + * the adjustment range are mapped to a file and are therefore in use + * at least once. Therefore, we can infer that any gap in the + * refcount tree within the adjustment range represents a physical + * extent with refcount == 1: + * + * <------ adjustment range ------> + * ----+---+---+-----+-+--+--------+----+---- + * 2 |"1"| 3 | 2 |1|17| 55 | 10 | 10 + * ----+---+---+-----+-+--+--------+----+---- + * ^ + * + * For each extent that falls within the interval range, figure out + * which extent is to the left or the right of that extent. Now we + * have a left, current, and right extent. If the new reference count + * of the center extent enables us to merge left, center, and right + * into one record covering all three, do so. If the center extent is + * at the left end of the range, abuts the left extent, and its new + * reference count matches the left extent's record, then merge them. + * If the center extent is at the right end of the range, abuts the + * right extent, and the reference counts match, merge those. In the + * example, we can left merge (assuming an increment operation): + * + * <------ adjustment range ------> + * --------+---+-----+-+--+--------+----+---- + * 2 | 3 | 2 |1|17| 55 | 10 | 10 + * --------+---+-----+-+--+--------+----+---- + * ^ + * + * For all other extents within the range, adjust the reference count + * or delete it if the refcount falls below 2. If we were + * incrementing, the end result looks like this: + * + * <------ adjustment range ------> + * --------+---+-----+-+--+--------+----+---- + * 2 | 4 | 3 |2|18| 56 | 11 | 10 + * --------+---+-----+-+--+--------+----+---- + * + * The result of a decrement operation looks as such: + * + * <------ adjustment range ------> + * ----+ +---+ +--+--------+----+---- + * 2 | | 2 | |16| 54 | 9 | 10 + * ----+ +---+ +--+--------+----+---- + * DDDD 111111DD + * + * The blocks marked "D" are freed; the blocks marked "1" are only + * referenced once and therefore the record is removed from the + * refcount btree. + */ + +#define RCNEXT(rc) ((rc).rc_startblock + (rc).rc_blockcount) +/* + * Split a refcount extent that crosses agbno. + */ +STATIC int +xfs_refcount_split_extent( + struct xfs_btree_cur *cur, + xfs_agblock_t agbno, + bool *shape_changed) +{ + struct xfs_refcount_irec rcext, tmp; + int found_rec; + int error; + + *shape_changed = false; + error = xfs_refcountbt_lookup_le(cur, agbno, &found_rec); + if (error) + goto out_error; + if (!found_rec) + return 0; + + error = xfs_refcountbt_get_rec(cur, &rcext, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + if (rcext.rc_startblock == agbno || RCNEXT(rcext) <= agbno) + return 0; + + *shape_changed = true; + trace_xfs_refcount_split_extent(cur->bc_mp, cur->bc_private.a.agno, + &rcext, agbno); + + /* Establish the right extent. */ + tmp = rcext; + tmp.rc_startblock = agbno; + tmp.rc_blockcount -= (agbno - rcext.rc_startblock); + error = xfs_refcountbt_update(cur, &tmp); + if (error) + goto out_error; + + /* Insert the left extent. */ + tmp = rcext; + tmp.rc_blockcount = agbno - rcext.rc_startblock; + error = xfs_refcountbt_insert(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + return error; + +out_error: + trace_xfs_refcount_split_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Merge the left, center, and right extents. + */ +STATIC int +xfs_refcount_merge_center_extent( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *left, + struct xfs_refcount_irec *center, + unsigned long long extlen, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen) +{ + int error; + int found_rec; + + error = xfs_refcountbt_lookup_ge(cur, center->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + if (center->rc_refcount > 1) { + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + } + + error = xfs_refcountbt_lookup_le(cur, left->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + left->rc_blockcount = extlen; + error = xfs_refcountbt_update(cur, left); + if (error) + goto out_error; + + *aglen = 0; + return error; + +out_error: + trace_xfs_refcount_merge_center_extents_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Merge with the left extent. + */ +STATIC int +xfs_refcount_merge_left_extent( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *left, + struct xfs_refcount_irec *cleft, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen) +{ + int error; + int found_rec; + + if (cleft->rc_refcount > 1) { + error = xfs_refcountbt_lookup_le(cur, cleft->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + } + + error = xfs_refcountbt_lookup_le(cur, left->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + left->rc_blockcount += cleft->rc_blockcount; + error = xfs_refcountbt_update(cur, left); + if (error) + goto out_error; + + *agbno += cleft->rc_blockcount; + *aglen -= cleft->rc_blockcount; + return error; + +out_error: + trace_xfs_refcount_merge_left_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Merge with the right extent. + */ +STATIC int +xfs_refcount_merge_right_extent( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *right, + struct xfs_refcount_irec *cright, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen) +{ + int error; + int found_rec; + + if (cright->rc_refcount > 1) { + error = xfs_refcountbt_lookup_le(cur, cright->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + } + + error = xfs_refcountbt_lookup_le(cur, right->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + right->rc_startblock -= cright->rc_blockcount; + right->rc_blockcount += cright->rc_blockcount; + error = xfs_refcountbt_update(cur, right); + if (error) + goto out_error; + + *aglen -= cright->rc_blockcount; + return error; + +out_error: + trace_xfs_refcount_merge_right_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Find the left extent and the one after it (cleft). This function assumes + * that we've already split any extent crossing agbno. + */ +STATIC int +xfs_refcount_find_left_extents( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *left, + struct xfs_refcount_irec *cleft, + xfs_agblock_t agbno, + xfs_extlen_t aglen) +{ + struct xfs_refcount_irec tmp; + int error; + int found_rec; + + left->rc_blockcount = cleft->rc_blockcount = 0; + error = xfs_refcountbt_lookup_le(cur, agbno - 1, &found_rec); + if (error) + goto out_error; + if (!found_rec) + return 0; + + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + if (RCNEXT(tmp) != agbno) + return 0; + /* We have a left extent; retrieve (or invent) the next right one */ + *left = tmp; + + error = xfs_btree_increment(cur, 0, &found_rec); + if (error) + goto out_error; + if (found_rec) { + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + /* if tmp starts at the end of our range, just use that */ + if (tmp.rc_startblock == agbno) + *cleft = tmp; + else { + /* + * There's a gap in the refcntbt at the start of the + * range we're interested in (refcount == 1) so + * create the implied extent and pass it back. + */ + cleft->rc_startblock = agbno; + cleft->rc_blockcount = min(aglen, + tmp.rc_startblock - agbno); + cleft->rc_refcount = 1; + } + } else { + /* + * No extents, so pretend that there's one covering the whole + * range. + */ + cleft->rc_startblock = agbno; + cleft->rc_blockcount = aglen; + cleft->rc_refcount = 1; + } + trace_xfs_refcount_find_left_extent(cur->bc_mp, cur->bc_private.a.agno, + left, cleft, agbno); + return error; + +out_error: + trace_xfs_refcount_find_left_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Find the right extent and the one before it (cright). This function + * assumes that we've already split any extents crossing agbno + aglen. + */ +STATIC int +xfs_refcount_find_right_extents( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *right, + struct xfs_refcount_irec *cright, + xfs_agblock_t agbno, + xfs_extlen_t aglen) +{ + struct xfs_refcount_irec tmp; + int error; + int found_rec; + + right->rc_blockcount = cright->rc_blockcount = 0; + error = xfs_refcountbt_lookup_ge(cur, agbno + aglen, &found_rec); + if (error) + goto out_error; + if (!found_rec) + return 0; + + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + if (tmp.rc_startblock != agbno + aglen) + return 0; + /* We have a right extent; retrieve (or invent) the next left one */ + *right = tmp; + + error = xfs_btree_decrement(cur, 0, &found_rec); + if (error) + goto out_error; + if (found_rec) { + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + /* if tmp ends at the end of our range, just use that */ + if (RCNEXT(tmp) == agbno + aglen) + *cright = tmp; + else { + /* + * There's a gap in the refcntbt at the end of the + * range we're interested in (refcount == 1) so + * create the implied extent and pass it back. + */ + cright->rc_startblock = max(agbno, RCNEXT(tmp)); + cright->rc_blockcount = right->rc_startblock - + cright->rc_startblock; + cright->rc_refcount = 1; + } + } else { + /* + * No extents, so pretend that there's one covering the whole + * range. + */ + cright->rc_startblock = agbno; + cright->rc_blockcount = aglen; + cright->rc_refcount = 1; + } + trace_xfs_refcount_find_right_extent(cur->bc_mp, cur->bc_private.a.agno, + cright, right, agbno + aglen); + return error; + +out_error: + trace_xfs_refcount_find_right_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} +#undef RCNEXT + +/* + * Try to merge with any extents on the boundaries of the adjustment range. + */ +STATIC int +xfs_refcount_merge_extents( + struct xfs_btree_cur *cur, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen, + enum xfs_refc_adjust_op adjust, + bool *shape_changed) +{ + struct xfs_refcount_irec left = {0}, cleft = {0}; + struct xfs_refcount_irec cright = {0}, right = {0}; + int error; + unsigned long long ulen; + bool cequal; + + *shape_changed = false; + /* + * Find the extent just below agbno [left], just above agbno [cleft], + * just below (agbno + aglen) [cright], and just above (agbno + aglen) + * [right]. + */ + error = xfs_refcount_find_left_extents(cur, &left, &cleft, *agbno, + *aglen); + if (error) + return error; + error = xfs_refcount_find_right_extents(cur, &right, &cright, *agbno, + *aglen); + if (error) + return error; + + /* No left or right extent to merge; exit. */ + if (left.rc_blockcount == 0 && right.rc_blockcount == 0) + return 0; + + *shape_changed = true; + cequal = (cleft.rc_startblock == cright.rc_startblock) && + (cleft.rc_blockcount == cright.rc_blockcount); + + /* Try to merge left, cleft, and right. cleft must == cright. */ + ulen = (unsigned long long)left.rc_blockcount + cleft.rc_blockcount + + right.rc_blockcount; + if (left.rc_blockcount != 0 && right.rc_blockcount != 0 && + cleft.rc_blockcount != 0 && cright.rc_blockcount != 0 && + cequal && + left.rc_refcount == cleft.rc_refcount + adjust && + right.rc_refcount == cleft.rc_refcount + adjust && + ulen < MAXREFCEXTLEN) { + trace_xfs_refcount_merge_center_extents(cur->bc_mp, + cur->bc_private.a.agno, &left, &cleft, &right); + return xfs_refcount_merge_center_extent(cur, &left, &cleft, + ulen, agbno, aglen); + } + + /* Try to merge left and cleft. */ + ulen = (unsigned long long)left.rc_blockcount + cleft.rc_blockcount; + if (left.rc_blockcount != 0 && cleft.rc_blockcount != 0 && + left.rc_refcount == cleft.rc_refcount + adjust && + ulen < MAXREFCEXTLEN) { + trace_xfs_refcount_merge_left_extent(cur->bc_mp, + cur->bc_private.a.agno, &left, &cleft); + error = xfs_refcount_merge_left_extent(cur, &left, &cleft, + agbno, aglen); + if (error) + return error; + + /* + * If we just merged left + cleft and cleft == cright, + * we no longer have a cright to merge with right. We're done. + */ + if (cequal) + return 0; + } + + /* Try to merge cright and right. */ + ulen = (unsigned long long)right.rc_blockcount + cright.rc_blockcount; + if (right.rc_blockcount != 0 && cright.rc_blockcount != 0 && + right.rc_refcount == cright.rc_refcount + adjust && + ulen < MAXREFCEXTLEN) { + trace_xfs_refcount_merge_right_extent(cur->bc_mp, + cur->bc_private.a.agno, &cright, &right); + return xfs_refcount_merge_right_extent(cur, &right, &cright, + agbno, aglen); + } + + return error; +} + +/* + * While we're adjusting the refcounts records of an extent, we have + * to keep an eye on the number of extents we're dirtying -- run too + * many in a single transaction and we'll exceed the transaction's + * reservation and crash the fs. Each record adds 12 bytes to the + * log (plus any key updates) so we'll conservatively assume 24 bytes + * per record. We must also leave space for btree splits on both ends + * of the range and space for the CUD and a new CUI. + * + * XXX: This is a pretty hand-wavy estimate. The penalty for guessing + * true incorrectly is a shutdown FS; the penalty for guessing false + * incorrectly is more transaction rolls than might be necessary. + * Be conservative here. + */ +static bool +xfs_refcount_still_have_space( + struct xfs_btree_cur *cur) +{ + unsigned long overhead; + + overhead = cur->bc_private.a.priv.refc.shape_changes * + xfs_allocfree_log_count(cur->bc_mp, 1); + overhead *= cur->bc_mp->m_sb.sb_blocksize; + + /* + * Only allow 2 refcount extent updates per transaction if the + * refcount continue update "error" has been injected. + */ + if (cur->bc_private.a.priv.refc.nr_ops > 2 && + XFS_TEST_ERROR(false, cur->bc_mp, + XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE, + XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE)) + return false; + + if (cur->bc_private.a.priv.refc.nr_ops == 0) + return true; + else if (overhead > cur->bc_tp->t_log_res) + return false; + return cur->bc_tp->t_log_res - overhead > + cur->bc_private.a.priv.refc.nr_ops * 32; +} + +/* + * Adjust the refcounts of middle extents. At this point we should have + * split extents that crossed the adjustment range; merged with adjacent + * extents; and updated agbno/aglen to reflect the merges. Therefore, + * all we have to do is update the extents inside [agbno, agbno + aglen]. + */ +STATIC int +xfs_refcount_adjust_extents( + struct xfs_btree_cur *cur, + xfs_agblock_t agbno, + xfs_extlen_t aglen, + xfs_extlen_t *adjusted, + enum xfs_refc_adjust_op adj, + struct xfs_defer_ops *dfops, + struct xfs_owner_info *oinfo) +{ + struct xfs_refcount_irec ext, tmp; + int error; + int found_rec, found_tmp; + xfs_fsblock_t fsbno; + + /* Merging did all the work already. */ + if (aglen == 0) + return 0; + + error = xfs_refcountbt_lookup_ge(cur, agbno, &found_rec); + if (error) + goto out_error; + + while (aglen > 0 && xfs_refcount_still_have_space(cur)) { + error = xfs_refcountbt_get_rec(cur, &ext, &found_rec); + if (error) + goto out_error; + if (!found_rec) { + ext.rc_startblock = cur->bc_mp->m_sb.sb_agblocks; + ext.rc_blockcount = 0; + ext.rc_refcount = 0; + } + + /* + * Deal with a hole in the refcount tree; if a file maps to + * these blocks and there's no refcountbt recourd, pretend that + * there is one with refcount == 1. + */ + if (ext.rc_startblock != agbno) { + tmp.rc_startblock = agbno; + tmp.rc_blockcount = min(aglen, + ext.rc_startblock - agbno); + tmp.rc_refcount = 1 + adj; + trace_xfs_refcount_modify_extent(cur->bc_mp, + cur->bc_private.a.agno, &tmp); + + /* + * Either cover the hole (increment) or + * delete the range (decrement). + */ + if (tmp.rc_refcount) { + error = xfs_refcountbt_insert(cur, &tmp, + &found_tmp); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, + found_tmp == 1, out_error); + cur->bc_private.a.priv.refc.nr_ops++; + } else { + fsbno = XFS_AGB_TO_FSB(cur->bc_mp, + cur->bc_private.a.agno, + tmp.rc_startblock); + xfs_bmap_add_free(cur->bc_mp, dfops, fsbno, + tmp.rc_blockcount, oinfo); + } + + (*adjusted) += tmp.rc_blockcount; + agbno += tmp.rc_blockcount; + aglen -= tmp.rc_blockcount; + + error = xfs_refcountbt_lookup_ge(cur, agbno, + &found_rec); + if (error) + goto out_error; + } + + /* Stop if there's nothing left to modify */ + if (aglen == 0 || !xfs_refcount_still_have_space(cur)) + break; + + /* + * Adjust the reference count and either update the tree + * (incr) or free the blocks (decr). + */ + if (ext.rc_refcount == MAXREFCOUNT) + goto skip; + ext.rc_refcount += adj; + trace_xfs_refcount_modify_extent(cur->bc_mp, + cur->bc_private.a.agno, &ext); + if (ext.rc_refcount > 1) { + error = xfs_refcountbt_update(cur, &ext); + if (error) + goto out_error; + cur->bc_private.a.priv.refc.nr_ops++; + } else if (ext.rc_refcount == 1) { + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, + found_rec == 1, out_error); + cur->bc_private.a.priv.refc.nr_ops++; + goto advloop; + } else { + fsbno = XFS_AGB_TO_FSB(cur->bc_mp, + cur->bc_private.a.agno, + ext.rc_startblock); + xfs_bmap_add_free(cur->bc_mp, dfops, fsbno, + ext.rc_blockcount, oinfo); + } + +skip: + error = xfs_btree_increment(cur, 0, &found_rec); + if (error) + goto out_error; + +advloop: + (*adjusted) += ext.rc_blockcount; + agbno += ext.rc_blockcount; + aglen -= ext.rc_blockcount; + } + + return error; +out_error: + trace_xfs_refcount_modify_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* Adjust the reference count of a range of AG blocks. */ +STATIC int +xfs_refcount_adjust( + struct xfs_btree_cur *cur, + xfs_agblock_t agbno, + xfs_extlen_t aglen, + xfs_extlen_t *adjusted, + enum xfs_refc_adjust_op adj, + struct xfs_defer_ops *dfops, + struct xfs_owner_info *oinfo) +{ + xfs_extlen_t orig_aglen; + bool shape_changed; + int shape_changes = 0; + int error; + + *adjusted = 0; + switch (adj) { + case XFS_REFCOUNT_ADJUST_INCREASE: + trace_xfs_refcount_increase(cur->bc_mp, cur->bc_private.a.agno, + agbno, aglen); + break; + case XFS_REFCOUNT_ADJUST_DECREASE: + trace_xfs_refcount_decrease(cur->bc_mp, cur->bc_private.a.agno, + agbno, aglen); + break; + default: + ASSERT(0); + } + + /* + * Ensure that no rcextents cross the boundary of the adjustment range. + */ + error = xfs_refcount_split_extent(cur, agbno, &shape_changed); + if (error) + goto out_error; + if (shape_changed) + shape_changes++; + + error = xfs_refcount_split_extent(cur, agbno + aglen, &shape_changed); + if (error) + goto out_error; + if (shape_changed) + shape_changes++; + + /* + * Try to merge with the left or right extents of the range. + */ + orig_aglen = aglen; + error = xfs_refcount_merge_extents(cur, &agbno, &aglen, adj, + &shape_changed); + if (error) + goto out_error; + if (shape_changed) + shape_changes++; + (*adjusted) += orig_aglen - aglen; + if (shape_changes) + cur->bc_private.a.priv.refc.shape_changes++; + + /* Now that we've taken care of the ends, adjust the middle extents */ + error = xfs_refcount_adjust_extents(cur, agbno, aglen, adjusted, adj, + dfops, oinfo); + if (error) + goto out_error; + + return 0; + +out_error: + trace_xfs_refcount_adjust_error(cur->bc_mp, cur->bc_private.a.agno, + error, _RET_IP_); + return error; +} diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h index 6bc614c..ffeffb5 100644 --- a/fs/xfs/xfs_error.h +++ b/fs/xfs/xfs_error.h @@ -92,7 +92,8 @@ extern void xfs_verifier_error(struct xfs_buf *bp); #define XFS_ERRTAG_BMAPIFORMAT 21 #define XFS_ERRTAG_FREE_EXTENT 22 #define XFS_ERRTAG_RMAP_FINISH_ONE 23 -#define XFS_ERRTAG_MAX 24 +#define XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE 24 +#define XFS_ERRTAG_MAX 25 /* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc. @@ -121,6 +122,7 @@ extern void xfs_verifier_error(struct xfs_buf *bp); #define XFS_RANDOM_BMAPIFORMAT XFS_RANDOM_DEFAULT #define XFS_RANDOM_FREE_EXTENT 1 #define XFS_RANDOM_RMAP_FINISH_ONE 1 +#define XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE 1 #ifdef DEBUG extern int xfs_error_test_active;
WARNING: multiple messages have this Message-ID (diff)
From: "Darrick J. Wong" <darrick.wong@oracle.com> To: david@fromorbit.com, darrick.wong@oracle.com Cc: linux-fsdevel@vger.kernel.org, vishal.l.verma@intel.com, xfs@oss.sgi.com Subject: [PATCH 063/119] xfs: adjust refcount of an extent of blocks in refcount btree Date: Thu, 16 Jun 2016 18:24:35 -0700 [thread overview] Message-ID: <146612667589.12839.17197885347586278821.stgit@birch.djwong.org> (raw) In-Reply-To: <146612627129.12839.3827886950949809165.stgit@birch.djwong.org> Provide functions to adjust the reference counts for an extent of physical blocks stored in the refcount btree. v2: Refactor the left/right split code into a single function. Track the number of btree shape changes and record updates during a refcount update so that we can decide if we need to get a fresh transaction to continue. Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com> --- fs/xfs/libxfs/xfs_refcount.c | 783 ++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_error.h | 4 2 files changed, 786 insertions(+), 1 deletion(-) diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c index 4d483b5..d13393b 100644 --- a/fs/xfs/libxfs/xfs_refcount.c +++ b/fs/xfs/libxfs/xfs_refcount.c @@ -37,6 +37,12 @@ #include "xfs_bit.h" #include "xfs_refcount.h" +/* Allowable refcount adjustment amounts. */ +enum xfs_refc_adjust_op { + XFS_REFCOUNT_ADJUST_INCREASE = 1, + XFS_REFCOUNT_ADJUST_DECREASE = -1, +}; + /* * Look up the first record less than or equal to [bno, len] in the btree * given by cur. @@ -175,3 +181,780 @@ out_error: cur->bc_private.a.agno, error, _RET_IP_); return error; } + +/* + * Adjusting the Reference Count + * + * As stated elsewhere, the reference count btree (refcbt) stores + * >1 reference counts for extents of physical blocks. In this + * operation, we're either raising or lowering the reference count of + * some subrange stored in the tree: + * + * <------ adjustment range ------> + * ----+ +---+-----+ +--+--------+--------- + * 2 | | 3 | 4 | |17| 55 | 10 + * ----+ +---+-----+ +--+--------+--------- + * X axis is physical blocks number; + * reference counts are the numbers inside the rectangles + * + * The first thing we need to do is to ensure that there are no + * refcount extents crossing either boundary of the range to be + * adjusted. For any extent that does cross a boundary, split it into + * two extents so that we can increment the refcount of one of the + * pieces later: + * + * <------ adjustment range ------> + * ----+ +---+-----+ +--+--------+----+---- + * 2 | | 3 | 2 | |17| 55 | 10 | 10 + * ----+ +---+-----+ +--+--------+----+---- + * + * For this next step, let's assume that all the physical blocks in + * the adjustment range are mapped to a file and are therefore in use + * at least once. Therefore, we can infer that any gap in the + * refcount tree within the adjustment range represents a physical + * extent with refcount == 1: + * + * <------ adjustment range ------> + * ----+---+---+-----+-+--+--------+----+---- + * 2 |"1"| 3 | 2 |1|17| 55 | 10 | 10 + * ----+---+---+-----+-+--+--------+----+---- + * ^ + * + * For each extent that falls within the interval range, figure out + * which extent is to the left or the right of that extent. Now we + * have a left, current, and right extent. If the new reference count + * of the center extent enables us to merge left, center, and right + * into one record covering all three, do so. If the center extent is + * at the left end of the range, abuts the left extent, and its new + * reference count matches the left extent's record, then merge them. + * If the center extent is at the right end of the range, abuts the + * right extent, and the reference counts match, merge those. In the + * example, we can left merge (assuming an increment operation): + * + * <------ adjustment range ------> + * --------+---+-----+-+--+--------+----+---- + * 2 | 3 | 2 |1|17| 55 | 10 | 10 + * --------+---+-----+-+--+--------+----+---- + * ^ + * + * For all other extents within the range, adjust the reference count + * or delete it if the refcount falls below 2. If we were + * incrementing, the end result looks like this: + * + * <------ adjustment range ------> + * --------+---+-----+-+--+--------+----+---- + * 2 | 4 | 3 |2|18| 56 | 11 | 10 + * --------+---+-----+-+--+--------+----+---- + * + * The result of a decrement operation looks as such: + * + * <------ adjustment range ------> + * ----+ +---+ +--+--------+----+---- + * 2 | | 2 | |16| 54 | 9 | 10 + * ----+ +---+ +--+--------+----+---- + * DDDD 111111DD + * + * The blocks marked "D" are freed; the blocks marked "1" are only + * referenced once and therefore the record is removed from the + * refcount btree. + */ + +#define RCNEXT(rc) ((rc).rc_startblock + (rc).rc_blockcount) +/* + * Split a refcount extent that crosses agbno. + */ +STATIC int +xfs_refcount_split_extent( + struct xfs_btree_cur *cur, + xfs_agblock_t agbno, + bool *shape_changed) +{ + struct xfs_refcount_irec rcext, tmp; + int found_rec; + int error; + + *shape_changed = false; + error = xfs_refcountbt_lookup_le(cur, agbno, &found_rec); + if (error) + goto out_error; + if (!found_rec) + return 0; + + error = xfs_refcountbt_get_rec(cur, &rcext, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + if (rcext.rc_startblock == agbno || RCNEXT(rcext) <= agbno) + return 0; + + *shape_changed = true; + trace_xfs_refcount_split_extent(cur->bc_mp, cur->bc_private.a.agno, + &rcext, agbno); + + /* Establish the right extent. */ + tmp = rcext; + tmp.rc_startblock = agbno; + tmp.rc_blockcount -= (agbno - rcext.rc_startblock); + error = xfs_refcountbt_update(cur, &tmp); + if (error) + goto out_error; + + /* Insert the left extent. */ + tmp = rcext; + tmp.rc_blockcount = agbno - rcext.rc_startblock; + error = xfs_refcountbt_insert(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + return error; + +out_error: + trace_xfs_refcount_split_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Merge the left, center, and right extents. + */ +STATIC int +xfs_refcount_merge_center_extent( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *left, + struct xfs_refcount_irec *center, + unsigned long long extlen, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen) +{ + int error; + int found_rec; + + error = xfs_refcountbt_lookup_ge(cur, center->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + if (center->rc_refcount > 1) { + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + } + + error = xfs_refcountbt_lookup_le(cur, left->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + left->rc_blockcount = extlen; + error = xfs_refcountbt_update(cur, left); + if (error) + goto out_error; + + *aglen = 0; + return error; + +out_error: + trace_xfs_refcount_merge_center_extents_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Merge with the left extent. + */ +STATIC int +xfs_refcount_merge_left_extent( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *left, + struct xfs_refcount_irec *cleft, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen) +{ + int error; + int found_rec; + + if (cleft->rc_refcount > 1) { + error = xfs_refcountbt_lookup_le(cur, cleft->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + } + + error = xfs_refcountbt_lookup_le(cur, left->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + left->rc_blockcount += cleft->rc_blockcount; + error = xfs_refcountbt_update(cur, left); + if (error) + goto out_error; + + *agbno += cleft->rc_blockcount; + *aglen -= cleft->rc_blockcount; + return error; + +out_error: + trace_xfs_refcount_merge_left_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Merge with the right extent. + */ +STATIC int +xfs_refcount_merge_right_extent( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *right, + struct xfs_refcount_irec *cright, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen) +{ + int error; + int found_rec; + + if (cright->rc_refcount > 1) { + error = xfs_refcountbt_lookup_le(cur, cright->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + } + + error = xfs_refcountbt_lookup_le(cur, right->rc_startblock, + &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + right->rc_startblock -= cright->rc_blockcount; + right->rc_blockcount += cright->rc_blockcount; + error = xfs_refcountbt_update(cur, right); + if (error) + goto out_error; + + *aglen -= cright->rc_blockcount; + return error; + +out_error: + trace_xfs_refcount_merge_right_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Find the left extent and the one after it (cleft). This function assumes + * that we've already split any extent crossing agbno. + */ +STATIC int +xfs_refcount_find_left_extents( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *left, + struct xfs_refcount_irec *cleft, + xfs_agblock_t agbno, + xfs_extlen_t aglen) +{ + struct xfs_refcount_irec tmp; + int error; + int found_rec; + + left->rc_blockcount = cleft->rc_blockcount = 0; + error = xfs_refcountbt_lookup_le(cur, agbno - 1, &found_rec); + if (error) + goto out_error; + if (!found_rec) + return 0; + + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + if (RCNEXT(tmp) != agbno) + return 0; + /* We have a left extent; retrieve (or invent) the next right one */ + *left = tmp; + + error = xfs_btree_increment(cur, 0, &found_rec); + if (error) + goto out_error; + if (found_rec) { + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + /* if tmp starts at the end of our range, just use that */ + if (tmp.rc_startblock == agbno) + *cleft = tmp; + else { + /* + * There's a gap in the refcntbt at the start of the + * range we're interested in (refcount == 1) so + * create the implied extent and pass it back. + */ + cleft->rc_startblock = agbno; + cleft->rc_blockcount = min(aglen, + tmp.rc_startblock - agbno); + cleft->rc_refcount = 1; + } + } else { + /* + * No extents, so pretend that there's one covering the whole + * range. + */ + cleft->rc_startblock = agbno; + cleft->rc_blockcount = aglen; + cleft->rc_refcount = 1; + } + trace_xfs_refcount_find_left_extent(cur->bc_mp, cur->bc_private.a.agno, + left, cleft, agbno); + return error; + +out_error: + trace_xfs_refcount_find_left_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* + * Find the right extent and the one before it (cright). This function + * assumes that we've already split any extents crossing agbno + aglen. + */ +STATIC int +xfs_refcount_find_right_extents( + struct xfs_btree_cur *cur, + struct xfs_refcount_irec *right, + struct xfs_refcount_irec *cright, + xfs_agblock_t agbno, + xfs_extlen_t aglen) +{ + struct xfs_refcount_irec tmp; + int error; + int found_rec; + + right->rc_blockcount = cright->rc_blockcount = 0; + error = xfs_refcountbt_lookup_ge(cur, agbno + aglen, &found_rec); + if (error) + goto out_error; + if (!found_rec) + return 0; + + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, out_error); + + if (tmp.rc_startblock != agbno + aglen) + return 0; + /* We have a right extent; retrieve (or invent) the next left one */ + *right = tmp; + + error = xfs_btree_decrement(cur, 0, &found_rec); + if (error) + goto out_error; + if (found_rec) { + error = xfs_refcountbt_get_rec(cur, &tmp, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, found_rec == 1, + out_error); + + /* if tmp ends at the end of our range, just use that */ + if (RCNEXT(tmp) == agbno + aglen) + *cright = tmp; + else { + /* + * There's a gap in the refcntbt at the end of the + * range we're interested in (refcount == 1) so + * create the implied extent and pass it back. + */ + cright->rc_startblock = max(agbno, RCNEXT(tmp)); + cright->rc_blockcount = right->rc_startblock - + cright->rc_startblock; + cright->rc_refcount = 1; + } + } else { + /* + * No extents, so pretend that there's one covering the whole + * range. + */ + cright->rc_startblock = agbno; + cright->rc_blockcount = aglen; + cright->rc_refcount = 1; + } + trace_xfs_refcount_find_right_extent(cur->bc_mp, cur->bc_private.a.agno, + cright, right, agbno + aglen); + return error; + +out_error: + trace_xfs_refcount_find_right_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} +#undef RCNEXT + +/* + * Try to merge with any extents on the boundaries of the adjustment range. + */ +STATIC int +xfs_refcount_merge_extents( + struct xfs_btree_cur *cur, + xfs_agblock_t *agbno, + xfs_extlen_t *aglen, + enum xfs_refc_adjust_op adjust, + bool *shape_changed) +{ + struct xfs_refcount_irec left = {0}, cleft = {0}; + struct xfs_refcount_irec cright = {0}, right = {0}; + int error; + unsigned long long ulen; + bool cequal; + + *shape_changed = false; + /* + * Find the extent just below agbno [left], just above agbno [cleft], + * just below (agbno + aglen) [cright], and just above (agbno + aglen) + * [right]. + */ + error = xfs_refcount_find_left_extents(cur, &left, &cleft, *agbno, + *aglen); + if (error) + return error; + error = xfs_refcount_find_right_extents(cur, &right, &cright, *agbno, + *aglen); + if (error) + return error; + + /* No left or right extent to merge; exit. */ + if (left.rc_blockcount == 0 && right.rc_blockcount == 0) + return 0; + + *shape_changed = true; + cequal = (cleft.rc_startblock == cright.rc_startblock) && + (cleft.rc_blockcount == cright.rc_blockcount); + + /* Try to merge left, cleft, and right. cleft must == cright. */ + ulen = (unsigned long long)left.rc_blockcount + cleft.rc_blockcount + + right.rc_blockcount; + if (left.rc_blockcount != 0 && right.rc_blockcount != 0 && + cleft.rc_blockcount != 0 && cright.rc_blockcount != 0 && + cequal && + left.rc_refcount == cleft.rc_refcount + adjust && + right.rc_refcount == cleft.rc_refcount + adjust && + ulen < MAXREFCEXTLEN) { + trace_xfs_refcount_merge_center_extents(cur->bc_mp, + cur->bc_private.a.agno, &left, &cleft, &right); + return xfs_refcount_merge_center_extent(cur, &left, &cleft, + ulen, agbno, aglen); + } + + /* Try to merge left and cleft. */ + ulen = (unsigned long long)left.rc_blockcount + cleft.rc_blockcount; + if (left.rc_blockcount != 0 && cleft.rc_blockcount != 0 && + left.rc_refcount == cleft.rc_refcount + adjust && + ulen < MAXREFCEXTLEN) { + trace_xfs_refcount_merge_left_extent(cur->bc_mp, + cur->bc_private.a.agno, &left, &cleft); + error = xfs_refcount_merge_left_extent(cur, &left, &cleft, + agbno, aglen); + if (error) + return error; + + /* + * If we just merged left + cleft and cleft == cright, + * we no longer have a cright to merge with right. We're done. + */ + if (cequal) + return 0; + } + + /* Try to merge cright and right. */ + ulen = (unsigned long long)right.rc_blockcount + cright.rc_blockcount; + if (right.rc_blockcount != 0 && cright.rc_blockcount != 0 && + right.rc_refcount == cright.rc_refcount + adjust && + ulen < MAXREFCEXTLEN) { + trace_xfs_refcount_merge_right_extent(cur->bc_mp, + cur->bc_private.a.agno, &cright, &right); + return xfs_refcount_merge_right_extent(cur, &right, &cright, + agbno, aglen); + } + + return error; +} + +/* + * While we're adjusting the refcounts records of an extent, we have + * to keep an eye on the number of extents we're dirtying -- run too + * many in a single transaction and we'll exceed the transaction's + * reservation and crash the fs. Each record adds 12 bytes to the + * log (plus any key updates) so we'll conservatively assume 24 bytes + * per record. We must also leave space for btree splits on both ends + * of the range and space for the CUD and a new CUI. + * + * XXX: This is a pretty hand-wavy estimate. The penalty for guessing + * true incorrectly is a shutdown FS; the penalty for guessing false + * incorrectly is more transaction rolls than might be necessary. + * Be conservative here. + */ +static bool +xfs_refcount_still_have_space( + struct xfs_btree_cur *cur) +{ + unsigned long overhead; + + overhead = cur->bc_private.a.priv.refc.shape_changes * + xfs_allocfree_log_count(cur->bc_mp, 1); + overhead *= cur->bc_mp->m_sb.sb_blocksize; + + /* + * Only allow 2 refcount extent updates per transaction if the + * refcount continue update "error" has been injected. + */ + if (cur->bc_private.a.priv.refc.nr_ops > 2 && + XFS_TEST_ERROR(false, cur->bc_mp, + XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE, + XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE)) + return false; + + if (cur->bc_private.a.priv.refc.nr_ops == 0) + return true; + else if (overhead > cur->bc_tp->t_log_res) + return false; + return cur->bc_tp->t_log_res - overhead > + cur->bc_private.a.priv.refc.nr_ops * 32; +} + +/* + * Adjust the refcounts of middle extents. At this point we should have + * split extents that crossed the adjustment range; merged with adjacent + * extents; and updated agbno/aglen to reflect the merges. Therefore, + * all we have to do is update the extents inside [agbno, agbno + aglen]. + */ +STATIC int +xfs_refcount_adjust_extents( + struct xfs_btree_cur *cur, + xfs_agblock_t agbno, + xfs_extlen_t aglen, + xfs_extlen_t *adjusted, + enum xfs_refc_adjust_op adj, + struct xfs_defer_ops *dfops, + struct xfs_owner_info *oinfo) +{ + struct xfs_refcount_irec ext, tmp; + int error; + int found_rec, found_tmp; + xfs_fsblock_t fsbno; + + /* Merging did all the work already. */ + if (aglen == 0) + return 0; + + error = xfs_refcountbt_lookup_ge(cur, agbno, &found_rec); + if (error) + goto out_error; + + while (aglen > 0 && xfs_refcount_still_have_space(cur)) { + error = xfs_refcountbt_get_rec(cur, &ext, &found_rec); + if (error) + goto out_error; + if (!found_rec) { + ext.rc_startblock = cur->bc_mp->m_sb.sb_agblocks; + ext.rc_blockcount = 0; + ext.rc_refcount = 0; + } + + /* + * Deal with a hole in the refcount tree; if a file maps to + * these blocks and there's no refcountbt recourd, pretend that + * there is one with refcount == 1. + */ + if (ext.rc_startblock != agbno) { + tmp.rc_startblock = agbno; + tmp.rc_blockcount = min(aglen, + ext.rc_startblock - agbno); + tmp.rc_refcount = 1 + adj; + trace_xfs_refcount_modify_extent(cur->bc_mp, + cur->bc_private.a.agno, &tmp); + + /* + * Either cover the hole (increment) or + * delete the range (decrement). + */ + if (tmp.rc_refcount) { + error = xfs_refcountbt_insert(cur, &tmp, + &found_tmp); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, + found_tmp == 1, out_error); + cur->bc_private.a.priv.refc.nr_ops++; + } else { + fsbno = XFS_AGB_TO_FSB(cur->bc_mp, + cur->bc_private.a.agno, + tmp.rc_startblock); + xfs_bmap_add_free(cur->bc_mp, dfops, fsbno, + tmp.rc_blockcount, oinfo); + } + + (*adjusted) += tmp.rc_blockcount; + agbno += tmp.rc_blockcount; + aglen -= tmp.rc_blockcount; + + error = xfs_refcountbt_lookup_ge(cur, agbno, + &found_rec); + if (error) + goto out_error; + } + + /* Stop if there's nothing left to modify */ + if (aglen == 0 || !xfs_refcount_still_have_space(cur)) + break; + + /* + * Adjust the reference count and either update the tree + * (incr) or free the blocks (decr). + */ + if (ext.rc_refcount == MAXREFCOUNT) + goto skip; + ext.rc_refcount += adj; + trace_xfs_refcount_modify_extent(cur->bc_mp, + cur->bc_private.a.agno, &ext); + if (ext.rc_refcount > 1) { + error = xfs_refcountbt_update(cur, &ext); + if (error) + goto out_error; + cur->bc_private.a.priv.refc.nr_ops++; + } else if (ext.rc_refcount == 1) { + error = xfs_refcountbt_delete(cur, &found_rec); + if (error) + goto out_error; + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, + found_rec == 1, out_error); + cur->bc_private.a.priv.refc.nr_ops++; + goto advloop; + } else { + fsbno = XFS_AGB_TO_FSB(cur->bc_mp, + cur->bc_private.a.agno, + ext.rc_startblock); + xfs_bmap_add_free(cur->bc_mp, dfops, fsbno, + ext.rc_blockcount, oinfo); + } + +skip: + error = xfs_btree_increment(cur, 0, &found_rec); + if (error) + goto out_error; + +advloop: + (*adjusted) += ext.rc_blockcount; + agbno += ext.rc_blockcount; + aglen -= ext.rc_blockcount; + } + + return error; +out_error: + trace_xfs_refcount_modify_extent_error(cur->bc_mp, + cur->bc_private.a.agno, error, _RET_IP_); + return error; +} + +/* Adjust the reference count of a range of AG blocks. */ +STATIC int +xfs_refcount_adjust( + struct xfs_btree_cur *cur, + xfs_agblock_t agbno, + xfs_extlen_t aglen, + xfs_extlen_t *adjusted, + enum xfs_refc_adjust_op adj, + struct xfs_defer_ops *dfops, + struct xfs_owner_info *oinfo) +{ + xfs_extlen_t orig_aglen; + bool shape_changed; + int shape_changes = 0; + int error; + + *adjusted = 0; + switch (adj) { + case XFS_REFCOUNT_ADJUST_INCREASE: + trace_xfs_refcount_increase(cur->bc_mp, cur->bc_private.a.agno, + agbno, aglen); + break; + case XFS_REFCOUNT_ADJUST_DECREASE: + trace_xfs_refcount_decrease(cur->bc_mp, cur->bc_private.a.agno, + agbno, aglen); + break; + default: + ASSERT(0); + } + + /* + * Ensure that no rcextents cross the boundary of the adjustment range. + */ + error = xfs_refcount_split_extent(cur, agbno, &shape_changed); + if (error) + goto out_error; + if (shape_changed) + shape_changes++; + + error = xfs_refcount_split_extent(cur, agbno + aglen, &shape_changed); + if (error) + goto out_error; + if (shape_changed) + shape_changes++; + + /* + * Try to merge with the left or right extents of the range. + */ + orig_aglen = aglen; + error = xfs_refcount_merge_extents(cur, &agbno, &aglen, adj, + &shape_changed); + if (error) + goto out_error; + if (shape_changed) + shape_changes++; + (*adjusted) += orig_aglen - aglen; + if (shape_changes) + cur->bc_private.a.priv.refc.shape_changes++; + + /* Now that we've taken care of the ends, adjust the middle extents */ + error = xfs_refcount_adjust_extents(cur, agbno, aglen, adjusted, adj, + dfops, oinfo); + if (error) + goto out_error; + + return 0; + +out_error: + trace_xfs_refcount_adjust_error(cur->bc_mp, cur->bc_private.a.agno, + error, _RET_IP_); + return error; +} diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h index 6bc614c..ffeffb5 100644 --- a/fs/xfs/xfs_error.h +++ b/fs/xfs/xfs_error.h @@ -92,7 +92,8 @@ extern void xfs_verifier_error(struct xfs_buf *bp); #define XFS_ERRTAG_BMAPIFORMAT 21 #define XFS_ERRTAG_FREE_EXTENT 22 #define XFS_ERRTAG_RMAP_FINISH_ONE 23 -#define XFS_ERRTAG_MAX 24 +#define XFS_ERRTAG_REFCOUNT_CONTINUE_UPDATE 24 +#define XFS_ERRTAG_MAX 25 /* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc. @@ -121,6 +122,7 @@ extern void xfs_verifier_error(struct xfs_buf *bp); #define XFS_RANDOM_BMAPIFORMAT XFS_RANDOM_DEFAULT #define XFS_RANDOM_FREE_EXTENT 1 #define XFS_RANDOM_RMAP_FINISH_ONE 1 +#define XFS_RANDOM_REFCOUNT_CONTINUE_UPDATE 1 #ifdef DEBUG extern int xfs_error_test_active; _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs
next prev parent reply other threads:[~2016-06-17 1:24 UTC|newest] Thread overview: 472+ messages / expand[flat|nested] mbox.gz Atom feed top 2016-06-17 1:17 [PATCH v6 000/119] xfs: add reverse mapping, reflink, dedupe, and online scrub support Darrick J. Wong 2016-06-17 1:17 ` Darrick J. Wong 2016-06-17 1:17 ` [PATCH 001/119] vfs: fix return type of ioctl_file_dedupe_range Darrick J. Wong 2016-06-17 1:17 ` Darrick J. Wong 2016-06-17 11:32 ` Christoph Hellwig 2016-06-17 11:32 ` Christoph Hellwig 2016-06-28 19:19 ` Darrick J. Wong 2016-06-28 19:19 ` Darrick J. Wong 2016-06-17 1:18 ` [PATCH 002/119] vfs: support FS_XFLAG_REFLINK and FS_XFLAG_COWEXTSIZE Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 11:41 ` Christoph Hellwig 2016-06-17 11:41 ` Christoph Hellwig 2016-06-17 12:16 ` Brian Foster 2016-06-17 12:16 ` Brian Foster 2016-06-17 15:06 ` Christoph Hellwig 2016-06-17 15:06 ` Christoph Hellwig 2016-06-17 16:54 ` Darrick J. Wong 2016-06-17 16:54 ` Darrick J. Wong 2016-06-17 17:38 ` Brian Foster 2016-06-17 17:38 ` Brian Foster 2016-06-17 1:18 ` [PATCH 003/119] xfs: check offsets of variable length structures Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 11:33 ` Christoph Hellwig 2016-06-17 11:33 ` Christoph Hellwig 2016-06-17 17:34 ` Brian Foster 2016-06-17 17:34 ` Brian Foster 2016-06-18 18:01 ` Darrick J. Wong 2016-06-18 18:01 ` Darrick J. Wong 2016-06-20 12:38 ` Brian Foster 2016-06-20 12:38 ` Brian Foster 2016-06-17 1:18 ` [PATCH 004/119] xfs: enable buffer deadlock postmortem diagnosis via ftrace Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 11:34 ` Christoph Hellwig 2016-06-17 11:34 ` Christoph Hellwig 2016-06-21 0:47 ` Dave Chinner 2016-06-21 0:47 ` Dave Chinner 2016-06-17 1:18 ` [PATCH 005/119] xfs: check for a valid error_tag in errortag_add Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 11:34 ` Christoph Hellwig 2016-06-17 11:34 ` Christoph Hellwig 2016-06-17 1:18 ` [PATCH 006/119] xfs: port differences from xfsprogs libxfs Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 15:06 ` Christoph Hellwig 2016-06-20 0:21 ` Dave Chinner 2016-06-20 0:21 ` Dave Chinner 2016-07-13 23:39 ` Darrick J. Wong 2016-07-13 23:39 ` Darrick J. Wong 2016-06-17 1:18 ` [PATCH 007/119] xfs: rearrange xfs_bmap_add_free parameters Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 11:39 ` Christoph Hellwig 2016-06-17 11:39 ` Christoph Hellwig 2016-06-17 1:18 ` [PATCH 008/119] xfs: separate freelist fixing into a separate helper Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 11:52 ` Christoph Hellwig 2016-06-17 11:52 ` Christoph Hellwig 2016-06-21 0:48 ` Dave Chinner 2016-06-21 0:48 ` Dave Chinner 2016-06-21 1:40 ` Dave Chinner 2016-06-21 1:40 ` Dave Chinner 2016-06-17 1:18 ` [PATCH 009/119] xfs: convert list of extents to free into a regular list Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-17 11:59 ` Christoph Hellwig 2016-06-17 11:59 ` Christoph Hellwig 2016-06-18 20:15 ` Darrick J. Wong 2016-06-18 20:15 ` Darrick J. Wong 2016-06-21 0:57 ` Dave Chinner 2016-06-21 0:57 ` Dave Chinner 2016-07-18 3:30 ` Eric Sandeen 2016-06-17 1:18 ` [PATCH 010/119] xfs: create a standard btree size calculator code Darrick J. Wong 2016-06-17 1:18 ` Darrick J. Wong 2016-06-20 14:31 ` Brian Foster 2016-06-20 14:31 ` Brian Foster 2016-06-20 19:34 ` Darrick J. Wong 2016-06-20 19:34 ` Darrick J. Wong 2016-06-17 1:19 ` [PATCH 011/119] xfs: refactor btree maxlevels computation Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-20 14:31 ` Brian Foster 2016-06-20 14:31 ` Brian Foster 2016-06-20 18:23 ` Darrick J. Wong 2016-06-20 18:23 ` Darrick J. Wong 2016-06-17 1:19 ` [PATCH 012/119] xfs: during btree split, save new block key & ptr for future insertion Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-21 13:00 ` Brian Foster 2016-06-21 13:00 ` Brian Foster 2016-06-27 22:30 ` Darrick J. Wong 2016-06-27 22:30 ` Darrick J. Wong 2016-06-28 12:31 ` Brian Foster 2016-06-28 12:31 ` Brian Foster 2016-06-17 1:19 ` [PATCH 013/119] xfs: support btrees with overlapping intervals for keys Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-22 15:17 ` Brian Foster 2016-06-22 15:17 ` Brian Foster 2016-06-28 3:26 ` Darrick J. Wong 2016-06-28 3:26 ` Darrick J. Wong 2016-06-28 12:32 ` Brian Foster 2016-06-28 12:32 ` Brian Foster 2016-06-28 17:36 ` Darrick J. Wong 2016-06-28 17:36 ` Darrick J. Wong 2016-07-06 4:59 ` Dave Chinner 2016-07-06 4:59 ` Dave Chinner 2016-07-06 8:09 ` Darrick J. Wong 2016-07-06 8:09 ` Darrick J. Wong 2016-06-17 1:19 ` [PATCH 014/119] xfs: introduce interval queries on btrees Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-22 15:18 ` Brian Foster 2016-06-22 15:18 ` Brian Foster 2016-06-27 21:07 ` Darrick J. Wong 2016-06-27 21:07 ` Darrick J. Wong 2016-06-28 12:32 ` Brian Foster 2016-06-28 12:32 ` Brian Foster 2016-06-28 16:29 ` Darrick J. Wong 2016-06-28 16:29 ` Darrick J. Wong 2016-06-17 1:19 ` [PATCH 015/119] xfs: refactor btree owner change into a separate visit-blocks function Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-23 17:19 ` Brian Foster 2016-06-23 17:19 ` Brian Foster 2016-06-17 1:19 ` [PATCH 016/119] xfs: move deferred operations into a separate file Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-27 13:14 ` Brian Foster 2016-06-27 13:14 ` Brian Foster 2016-06-27 19:14 ` Darrick J. Wong 2016-06-27 19:14 ` Darrick J. Wong 2016-06-28 12:32 ` Brian Foster 2016-06-28 12:32 ` Brian Foster 2016-06-28 18:51 ` Darrick J. Wong 2016-06-28 18:51 ` Darrick J. Wong 2016-06-17 1:19 ` [PATCH 017/119] xfs: add tracepoints for the deferred ops mechanism Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-27 13:15 ` Brian Foster 2016-06-27 13:15 ` Brian Foster 2016-06-17 1:19 ` [PATCH 018/119] xfs: enable the xfs_defer mechanism to process extents to free Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-27 13:15 ` Brian Foster 2016-06-27 13:15 ` Brian Foster 2016-06-27 21:41 ` Darrick J. Wong 2016-06-27 21:41 ` Darrick J. Wong 2016-06-27 22:00 ` Darrick J. Wong 2016-06-27 22:00 ` Darrick J. Wong 2016-06-28 12:32 ` Brian Foster 2016-06-28 12:32 ` Brian Foster 2016-06-28 16:33 ` Darrick J. Wong 2016-06-28 16:33 ` Darrick J. Wong 2016-06-17 1:19 ` [PATCH 019/119] xfs: rework xfs_bmap_free callers to use xfs_defer_ops Darrick J. Wong 2016-06-17 1:19 ` Darrick J. Wong 2016-06-17 1:20 ` [PATCH 020/119] xfs: change xfs_bmap_{finish, cancel, init, free} -> xfs_defer_* Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-30 0:11 ` Darrick J. Wong 2016-06-30 0:11 ` Darrick J. Wong 2016-06-17 1:20 ` [PATCH 021/119] xfs: rename flist/free_list to dfops Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-17 1:20 ` [PATCH 022/119] xfs: add tracepoints and error injection for deferred extent freeing Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-17 1:20 ` [PATCH 023/119] xfs: introduce rmap btree definitions Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-30 17:32 ` Brian Foster 2016-06-30 17:32 ` Brian Foster 2016-06-17 1:20 ` [PATCH 024/119] xfs: add rmap btree stats infrastructure Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-30 17:32 ` Brian Foster 2016-06-30 17:32 ` Brian Foster 2016-06-17 1:20 ` [PATCH 025/119] xfs: rmap btree add more reserved blocks Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-30 17:32 ` Brian Foster 2016-06-30 17:32 ` Brian Foster 2016-06-17 1:20 ` [PATCH 026/119] xfs: add owner field to extent allocation and freeing Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-07-06 4:01 ` Dave Chinner 2016-07-06 4:01 ` Dave Chinner 2016-07-06 6:44 ` Darrick J. Wong 2016-07-06 6:44 ` Darrick J. Wong 2016-07-07 15:12 ` Brian Foster 2016-07-07 15:12 ` Brian Foster 2016-07-07 19:09 ` Darrick J. Wong 2016-07-07 19:09 ` Darrick J. Wong 2016-07-07 22:55 ` Dave Chinner 2016-07-07 22:55 ` Dave Chinner 2016-07-08 11:37 ` Brian Foster 2016-07-08 11:37 ` Brian Foster 2016-06-17 1:20 ` [PATCH 027/119] xfs: introduce rmap extent operation stubs Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-17 1:20 ` [PATCH 028/119] xfs: define the on-disk rmap btree format Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-07-06 4:05 ` Dave Chinner 2016-07-06 4:05 ` Dave Chinner 2016-07-06 6:44 ` Darrick J. Wong 2016-07-06 6:44 ` Darrick J. Wong 2016-07-07 18:41 ` Brian Foster 2016-07-07 18:41 ` Brian Foster 2016-07-07 19:18 ` Darrick J. Wong 2016-07-07 19:18 ` Darrick J. Wong 2016-07-07 23:14 ` Dave Chinner 2016-07-07 23:14 ` Dave Chinner 2016-07-07 23:58 ` Darrick J. Wong 2016-07-07 23:58 ` Darrick J. Wong 2016-06-17 1:20 ` [PATCH 029/119] xfs: add rmap btree growfs support Darrick J. Wong 2016-06-17 1:20 ` Darrick J. Wong 2016-06-17 1:21 ` [PATCH 030/119] xfs: rmap btree transaction reservations Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-08 13:21 ` Brian Foster 2016-07-08 13:21 ` Brian Foster 2016-06-17 1:21 ` [PATCH 031/119] xfs: rmap btree requires more reserved free space Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-08 13:21 ` Brian Foster 2016-07-08 13:21 ` Brian Foster 2016-07-13 16:50 ` Darrick J. Wong 2016-07-13 16:50 ` Darrick J. Wong 2016-07-13 18:32 ` Brian Foster 2016-07-13 18:32 ` Brian Foster 2016-07-13 23:50 ` Dave Chinner 2016-07-13 23:50 ` Dave Chinner 2016-06-17 1:21 ` [PATCH 032/119] xfs: add rmap btree operations Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-08 18:33 ` Brian Foster 2016-07-08 18:33 ` Brian Foster 2016-07-08 23:53 ` Darrick J. Wong 2016-07-08 23:53 ` Darrick J. Wong 2016-06-17 1:21 ` [PATCH 033/119] xfs: support overlapping intervals in the rmap btree Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-08 18:33 ` Brian Foster 2016-07-08 18:33 ` Brian Foster 2016-07-09 0:14 ` Darrick J. Wong 2016-07-09 0:14 ` Darrick J. Wong 2016-07-09 13:25 ` Brian Foster 2016-07-09 13:25 ` Brian Foster 2016-06-17 1:21 ` [PATCH 034/119] xfs: teach rmapbt to support interval queries Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-08 18:34 ` Brian Foster 2016-07-08 18:34 ` Brian Foster 2016-07-09 0:16 ` Darrick J. Wong 2016-07-09 0:16 ` Darrick J. Wong 2016-07-09 13:25 ` Brian Foster 2016-07-09 13:25 ` Brian Foster 2016-06-17 1:21 ` [PATCH 035/119] xfs: add tracepoints for the rmap functions Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-08 18:34 ` Brian Foster 2016-07-08 18:34 ` Brian Foster 2016-06-17 1:21 ` [PATCH 036/119] xfs: add an extent to the rmap btree Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-11 18:49 ` Brian Foster 2016-07-11 18:49 ` Brian Foster 2016-07-11 23:01 ` Darrick J. Wong 2016-07-11 23:01 ` Darrick J. Wong 2016-06-17 1:21 ` [PATCH 037/119] xfs: remove an extent from " Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-07-11 18:49 ` Brian Foster 2016-07-11 18:49 ` Brian Foster 2016-06-17 1:21 ` [PATCH 038/119] xfs: convert unwritten status of reverse mappings Darrick J. Wong 2016-06-17 1:21 ` Darrick J. Wong 2016-06-30 0:15 ` Darrick J. Wong 2016-06-30 0:15 ` Darrick J. Wong 2016-07-13 18:27 ` Brian Foster 2016-07-13 18:27 ` Brian Foster 2016-07-13 20:43 ` Darrick J. Wong 2016-07-13 20:43 ` Darrick J. Wong 2016-06-17 1:22 ` [PATCH 039/119] xfs: add rmap btree insert and delete helpers Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-13 18:28 ` Brian Foster 2016-07-13 18:28 ` Brian Foster 2016-07-13 18:37 ` Darrick J. Wong 2016-07-13 18:37 ` Darrick J. Wong 2016-07-13 18:42 ` Brian Foster 2016-07-13 18:42 ` Brian Foster 2016-06-17 1:22 ` [PATCH 040/119] xfs: create helpers for mapping, unmapping, and converting file fork extents Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-13 18:28 ` Brian Foster 2016-07-13 18:28 ` Brian Foster 2016-07-13 18:47 ` Darrick J. Wong 2016-07-13 18:47 ` Darrick J. Wong 2016-07-13 23:54 ` Dave Chinner 2016-07-13 23:54 ` Dave Chinner 2016-07-13 23:55 ` Darrick J. Wong 2016-07-13 23:55 ` Darrick J. Wong 2016-06-17 1:22 ` [PATCH 041/119] xfs: create rmap update intent log items Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-15 18:33 ` Brian Foster 2016-07-15 18:33 ` Brian Foster 2016-07-16 7:10 ` Darrick J. Wong 2016-07-16 7:10 ` Darrick J. Wong 2016-06-17 1:22 ` [PATCH 042/119] xfs: log rmap intent items Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-15 18:33 ` Brian Foster 2016-07-15 18:33 ` Brian Foster 2016-07-16 7:34 ` Darrick J. Wong 2016-07-16 7:34 ` Darrick J. Wong 2016-07-18 12:55 ` Brian Foster 2016-07-18 12:55 ` Brian Foster 2016-07-19 17:10 ` Darrick J. Wong 2016-07-19 17:10 ` Darrick J. Wong 2016-06-17 1:22 ` [PATCH 043/119] xfs: enable the xfs_defer mechanism to process rmaps to update Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-15 18:33 ` Brian Foster 2016-07-15 18:33 ` Brian Foster 2016-06-17 1:22 ` [PATCH 044/119] xfs: propagate bmap updates to rmapbt Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-15 18:33 ` Brian Foster 2016-07-15 18:33 ` Brian Foster 2016-07-16 7:26 ` Darrick J. Wong 2016-07-16 7:26 ` Darrick J. Wong 2016-07-18 1:21 ` Dave Chinner 2016-07-18 1:21 ` Dave Chinner 2016-07-18 12:56 ` Brian Foster 2016-07-18 12:56 ` Brian Foster 2016-07-18 12:55 ` Brian Foster 2016-07-18 12:55 ` Brian Foster 2016-07-19 1:53 ` Darrick J. Wong 2016-07-19 1:53 ` Darrick J. Wong 2016-07-19 11:37 ` Brian Foster 2016-07-19 11:37 ` Brian Foster 2016-06-17 1:22 ` [PATCH 045/119] xfs: add rmap btree geometry feature flag Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-18 13:34 ` Brian Foster 2016-07-18 13:34 ` Brian Foster 2016-06-17 1:22 ` [PATCH 046/119] xfs: add rmap btree block detection to log recovery Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-18 13:34 ` Brian Foster 2016-07-18 13:34 ` Brian Foster 2016-06-17 1:22 ` [PATCH 047/119] xfs: disable XFS_IOC_SWAPEXT when rmap btree is enabled Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-18 13:34 ` Brian Foster 2016-07-18 13:34 ` Brian Foster 2016-07-18 16:18 ` Darrick J. Wong 2016-07-18 16:18 ` Darrick J. Wong 2016-06-17 1:22 ` [PATCH 048/119] xfs: don't update rmapbt when fixing agfl Darrick J. Wong 2016-06-17 1:22 ` Darrick J. Wong 2016-07-18 13:34 ` Brian Foster 2016-07-18 13:34 ` Brian Foster 2016-07-18 15:53 ` Darrick J. Wong 2016-07-18 15:53 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 049/119] xfs: enable the rmap btree functionality Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-07-18 13:34 ` Brian Foster 2016-07-18 13:34 ` Brian Foster 2016-06-17 1:23 ` [PATCH 050/119] xfs: count the blocks in a btree Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 051/119] xfs: introduce tracepoints for AG reservation code Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 052/119] xfs: set up per-AG free space reservations Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 053/119] xfs: define tracepoints for refcount btree activities Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 054/119] xfs: introduce refcount btree definitions Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 055/119] xfs: add refcount btree stats infrastructure Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 056/119] xfs: refcount btree add more reserved blocks Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:23 ` [PATCH 057/119] xfs: define the on-disk refcount btree format Darrick J. Wong 2016-06-17 1:23 ` Darrick J. Wong 2016-06-17 1:24 ` [PATCH 058/119] xfs: add refcount btree support to growfs Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:24 ` [PATCH 059/119] xfs: account for the refcount btree in the alloc/free log reservation Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:24 ` [PATCH 060/119] xfs: add refcount btree operations Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:24 ` [PATCH 061/119] xfs: create refcount update intent log items Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:24 ` [PATCH 062/119] xfs: log refcount intent items Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong [this message] 2016-06-17 1:24 ` [PATCH 063/119] xfs: adjust refcount of an extent of blocks in refcount btree Darrick J. Wong 2016-06-17 1:24 ` [PATCH 064/119] xfs: connect refcount adjust functions to upper layers Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:24 ` [PATCH 065/119] xfs: adjust refcount when unmapping file blocks Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:24 ` [PATCH 066/119] xfs: add refcount btree block detection to log recovery Darrick J. Wong 2016-06-17 1:24 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 067/119] xfs: refcount btree requires more reserved space Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 068/119] xfs: introduce reflink utility functions Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 069/119] xfs: create bmbt update intent log items Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 070/119] xfs: log bmap intent items Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 071/119] xfs: map an inode's offset to an exact physical block Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 072/119] xfs: implement deferred bmbt map/unmap operations Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 073/119] xfs: return work remaining at the end of a bunmapi operation Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 074/119] xfs: define tracepoints for reflink activities Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 075/119] xfs: add reflink feature flag to geometry Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:25 ` [PATCH 076/119] xfs: don't allow reflinked dir/dev/fifo/socket/pipe files Darrick J. Wong 2016-06-17 1:25 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 077/119] xfs: introduce the CoW fork Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 078/119] xfs: support bmapping delalloc extents in " Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 079/119] xfs: create delalloc extents in " Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 080/119] xfs: support allocating delayed " Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 081/119] xfs: allocate " Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 082/119] xfs: support removing extents from " Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 083/119] xfs: move mappings from cow fork to data fork after copy-write Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 084/119] xfs: implement CoW for directio writes Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:26 ` [PATCH 085/119] xfs: copy-on-write reflinked blocks when zeroing ranges of blocks Darrick J. Wong 2016-06-17 1:26 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 086/119] xfs: cancel CoW reservations and clear inode reflink flag when freeing blocks Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 087/119] xfs: cancel pending CoW reservations when destroying inodes Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 088/119] xfs: store in-progress CoW allocations in the refcount btree Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 089/119] xfs: reflink extents from one file to another Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 090/119] xfs: add clone file and clone range vfs functions Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 091/119] xfs: add dedupe range vfs function Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 092/119] xfs: teach get_bmapx and fiemap about shared extents and the CoW fork Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 093/119] xfs: swap inode reflink flags when swapping inode extents Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:27 ` [PATCH 094/119] xfs: unshare a range of blocks via fallocate Darrick J. Wong 2016-06-17 1:27 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 095/119] xfs: CoW shared EOF block when truncating file Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 096/119] xfs: support FS_XFLAG_REFLINK on reflink filesystems Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 097/119] xfs: create a separate cow extent size hint for the allocator Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 098/119] xfs: preallocate blocks for worst-case btree expansion Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 099/119] xfs: don't allow reflink when the AG is low on space Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 100/119] xfs: try other AGs to allocate a BMBT block Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 101/119] xfs: promote buffered writes to CoW when cowextsz is set Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 102/119] xfs: garbage collect old cowextsz reservations Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:28 ` [PATCH 103/119] xfs: provide switch to force filesystem to copy-on-write all the time Darrick J. Wong 2016-06-17 1:28 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 104/119] xfs: increase log reservations for reflink Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 105/119] xfs: use interval query for rmap alloc operations on shared files Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 106/119] xfs: convert unwritten status of reverse mappings for " Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 107/119] xfs: set a default CoW extent size of 32 blocks Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 108/119] xfs: don't allow realtime and reflinked files to mix Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 109/119] xfs: don't mix reflink and DAX mode for now Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 110/119] xfs: fail ->bmap for reflink inodes Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 111/119] xfs: recognize the reflink feature bit Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:29 ` [PATCH 112/119] xfs: introduce the XFS_IOC_GETFSMAPX ioctl Darrick J. Wong 2016-06-17 1:29 ` Darrick J. Wong 2016-06-17 1:30 ` [PATCH 113/119] xfs: scrub btree records and pointers while querying Darrick J. Wong 2016-06-17 1:30 ` Darrick J. Wong 2016-06-17 1:30 ` [PATCH 114/119] xfs: create sysfs hooks to scrub various files Darrick J. Wong 2016-06-17 1:30 ` Darrick J. Wong 2016-06-17 1:30 ` [PATCH 115/119] xfs: support scrubbing free space btrees Darrick J. Wong 2016-06-17 1:30 ` Darrick J. Wong 2016-06-17 1:30 ` [PATCH 116/119] xfs: support scrubbing inode btrees Darrick J. Wong 2016-06-17 1:30 ` Darrick J. Wong 2016-06-17 1:30 ` [PATCH 117/119] xfs: support scrubbing rmap btree Darrick J. Wong 2016-06-17 1:30 ` Darrick J. Wong 2016-06-17 1:30 ` [PATCH 118/119] xfs: support scrubbing refcount btree Darrick J. Wong 2016-06-17 1:30 ` Darrick J. Wong 2016-06-17 1:30 ` [PATCH 119/119] xfs: add btree scrub tracepoints Darrick J. Wong 2016-06-17 1:30 ` Darrick J. Wong
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=146612667589.12839.17197885347586278821.stgit@birch.djwong.org \ --to=darrick.wong@oracle.com \ --cc=david@fromorbit.com \ --cc=linux-fsdevel@vger.kernel.org \ --cc=vishal.l.verma@intel.com \ --cc=xfs@oss.sgi.com \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.