xfs: freespace defrag for online shrink
Subsystems (3)
PATCH 4/4 xfs: freespace defrag for online shrink
Hi all,
This fourth patch deluge has two faces -- one way of looking at it is that it is random odds and ends at the tail of my development tree. A second interpretation is that it is necessary pieces for defragmenting free space, which is a precursor for online shrink of XFS filesystems.
The kernel side isn't that exciting -- we export refcounting information for space extents, and add a new fallocate mode for mapping exact portions of free filesystem space into a file.
Userspace is where things get interesting! The free space defragmenter is an iterative algorithm that assigns free space to a dummy file, and then uses the GETFSMAP and GETFSREFCOUNTS information to target file space extents in order of decreasing share counts. Once an extent has been targeted, it uses reflinking to freeze the space, copies it elsewhere, and uses FIDEDUPERANGE to remap existing file data until the dummy file is the sole owner of the targetted space. If metadata are involved, the defrag utility invokes online repair to rebuild the metadata somewhere else.
When the defragmenter finishes, all the free space has been isolated to the dummy file, which can be unlinked and closed if defragmentation was the goal; or it could be passed to a shrinkfs operation.
NOTE: There's also an experimental vectorization interface for scrub. Given how long it's likely to take to get to this fourth deluge, it might make more sense to integrate with io_uring when that day comes.
As a warning, the patches will likely take several days to trickle in.
--D
cover xfs: improve post-close eofblocks gc behavior
Hi all,
Here's a few patches mostly from Dave to make XFS more aggressive about keeping post-eof speculative preallocations when closing files.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=reduce-eofblocks-gc-on-close
--- fs/xfs/xfs_bmap_util.c | 9 ++++++--- fs/xfs/xfs_file.c | 14 ++++++++++++-- fs/xfs/xfs_inode.c | 13 ++++++------- fs/xfs/xfs_inode.h | 2 +- 4 files changed, 25 insertions(+), 13 deletions(-)
PATCH 1/3 xfs: only free posteof blocks on first close
From: Darrick J. Wong <[email protected]>
Certain workloads fragment files on XFS very badly, such as a software package that creates a number of threads, each of which repeatedly run the sequence: open a file, perform a synchronous write, and close the file, which defeats the speculative preallocation mechanism. We work around this problem by only deleting posteof blocks the /first/ time a file is closed to preserve the behavior that unpacking a tarball lays out files one after the other with no gaps.
--- fs/xfs/xfs_inode.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
fs/xfs/xfs_inode.c +1 -3
@@ -1381,9 +1381,7 @@ xfs_release(if (error) goto out_unlock; -/* delalloc blocks after truncation means it really is dirty */ -if (ip->i_delayed_blks) -xfs_iflags_set (ip,XFS_IDIRTY_RELEASE ); +xfs_iflags_set (ip,XFS_IDIRTY_RELEASE ); } out_unlock:
PATCH 2/3 xfs: don't free EOF blocks on read close
In reply to Darrick J. WongFrom: Dave Chinner <[email protected]>
When we have a workload that does open/read/close in parallel with other allocation, the file becomes rapidly fragmented. This is due to close() calling xfs_release() and removing the speculative preallocation beyond EOF.
The existing open/*/close heuristic in xfs_release() does not catch this as a sync writer does not leave delayed allocation blocks allocated on the inode for later writeback that can be detected in xfs_release() and hence XFS_IDIRTY_RELEASE never gets set.
In xfs_file_release(), we know more about the released file context, and so we need to communicate some of the details to xfs_release() so it can do the right thing here and skip EOF block truncation. This defers the EOF block cleanup for synchronous write contexts to the background EOF block cleaner which will clean up within a few minutes.
Before:
Test 1: sync write fragmentation counts
/mnt/scratch/file.0: 919/mnt/scratch/file.1: 916/mnt/scratch/file.2: 919/mnt/scratch/file.3: 920/mnt/scratch/file.4: 920/mnt/scratch/file.5: 921/mnt/scratch/file.6: 916/mnt/scratch/file.7: 918
After:
Test 1: sync write fragmentation counts
/mnt/scratch/file.0: 24/mnt/scratch/file.1: 24/mnt/scratch/file.2: 11/mnt/scratch/file.3: 24/mnt/scratch/file.4: 3/mnt/scratch/file.5: 24/mnt/scratch/file.6: 24/mnt/scratch/file.7: 23
--- fs/xfs/xfs_file.c | 14 ++++++++++++-- fs/xfs/xfs_inode.c | 9 +++++---- fs/xfs/xfs_inode.h | 2 +- 3 files changed, 18 insertions(+), 7 deletions(-)
fs/xfs/xfs_file.c +12 -2
@@ -1381,12 +1381,22 @@ xfs_dir_open(return error; } +/* +* When we release the file, we don't want it to trim EOF blocks if it is a +* readonly context. This avoids open/read/close workloads from removing +* EOF blocks that other writers depend upon to reduce fragmentation. +*/ STATIC intxfs_file_release (struct inode *inode, -struct file *filp) +struct file *file) { -return xfs_release (XFS_I (inode)); +bool free_eof_blocks = true; + +if ((file->f_mode & (FMODE_WRITE |FMODE_READ )) ==FMODE_READ ) + free_eof_blocks = false; + +return xfs_release (XFS_I (inode), free_eof_blocks); }STATIC int
fs/xfs/xfs_inode.c +5 -4
@@ -1311,10 +1311,11 @@ xfs_itruncate_extents_flags(int xfs_release ( -xfs_inode_t *ip) +struct xfs_inode *ip, +bool want_free_eofblocks) { -xfs_mount_t *mp = ip->i_mount; -int error =0 ; +struct xfs_mount *mp = ip->i_mount; +int error =0 ;if (!S_ISREG (VFS_I (ip)->i_mode) || (VFS_I (ip)->i_mode ==0 ))return 0 ;
@@ -1356,7 +1357,7 @@ xfs_release(* another chance to drop them once the last reference to the inode is * dropped, so we'll never leak blocks permanently. */ -if (!xfs_ilock_nowait (ip,XFS_IOLOCK_EXCL )) +if (!want_free_eofblocks || !xfs_ilock_nowait (ip,XFS_IOLOCK_EXCL ))return 0 ;if (xfs_can_free_eofblocks (ip, false)) {
fs/xfs/xfs_inode.h +1 -1
@@ -493,7 +493,7 @@ enum layout_break_reason {#define XFS_INHERIT_GID (pip) \ (xfs_has_grpid((pip)->i_mount) || (VFS_I(pip)->i_mode & S_ISGID)) -int xfs_release (struct xfs_inode *ip); +int xfs_release (struct xfs_inode *ip,bool can_free_eofblocks);void xfs_inactive (struct xfs_inode *ip);int xfs_lookup (struct xfs_inode *dp,const struct xfs_name *name,struct xfs_inode **ipp,struct xfs_name *ci_name);
PATCH 3/3 xfs: Don't free EOF blocks on close when extent size hints are set
In reply to Darrick J. WongFrom: Dave Chinner <[email protected]>
When we have a workload that does open/write/close on files with extent size hints set in parallel with other allocation, the file becomes rapidly fragmented. This is due to close() calling xfs_release() and removing the preallocated extent beyond EOF. This occurs for both buffered and direct writes that append to files with extent size hints.
The existing open/write/close hueristic in xfs_release() does not catch this as writes to files using extent size hints do not use delayed allocation and hence do not leave delayed allocation blocks allocated on the inode that can be detected in xfs_release(). Hence XFS_IDIRTY_RELEASE never gets set.
In xfs_file_release(), we can tell whether the inode has extent size hints set and skip EOF block truncation. We add this check to xfs_can_free_eofblocks() so that we treat the post-EOF preallocated extent like intentional preallocation and so are persistent unless directly removed by userspace.
Before:
Test 2: Extent size hint fragmentation counts
/mnt/scratch/file.0: 1002/mnt/scratch/file.1: 1002/mnt/scratch/file.2: 1002/mnt/scratch/file.3: 1002/mnt/scratch/file.4: 1002/mnt/scratch/file.5: 1002/mnt/scratch/file.6: 1002/mnt/scratch/file.7: 1002
After:
Test 2: Extent size hint fragmentation counts
/mnt/scratch/file.0: 4/mnt/scratch/file.1: 4/mnt/scratch/file.2: 4/mnt/scratch/file.3: 4/mnt/scratch/file.4: 4/mnt/scratch/file.5: 4/mnt/scratch/file.6: 4/mnt/scratch/file.7: 4
--- fs/xfs/xfs_bmap_util.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
fs/xfs/xfs_bmap_util.c +6 -3
@@ -710,12 +710,15 @@ xfs_can_free_eofblocks(return false;/* -* Do not free real preallocated or append-only files unless the file -* has delalloc blocks and we are forced to remove them. +* Do not free extent size hints, real preallocated or append-only files +* unless the file has delalloc blocks and we are forced to remove +* them. */ -if (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND )) +if (xfs_get_extsz_hint (ip) || + (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND ))) {if (!force || ip->i_delayed_blks ==0 )return false; + }/* * Do not try to free post-EOF blocks if EOF is beyond the end of the
cover xfs: vectorize scrub kernel calls
In reply to Darrick J. WongHi all,
Create a vectorized version of the metadata scrub and repair ioctl, and adapt xfs_scrub to use that. This is an experiment to measure overhead and to try refactoring xfs_scrub.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=vectorized-scrub
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=vectorized-scrub
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=vectorized-scrub
--- fs/xfs/libxfs/xfs_defer.c | 14 +++ fs/xfs/libxfs/xfs_fs.h | 37 +++++++++ fs/xfs/scrub/btree.c | 88 +++++++++++++++++++++ fs/xfs/scrub/common.c | 104 +++++++++++++++++++++++++ fs/xfs/scrub/common.h | 1 fs/xfs/scrub/dabtree.c | 24 ++++++ fs/xfs/scrub/inode.c | 4 + fs/xfs/scrub/scrub.c | 185 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/trace.c | 22 +++++ fs/xfs/scrub/trace.h | 80 +++++++++++++++++++ fs/xfs/scrub/xfs_scrub.h | 2 fs/xfs/xfs_ioctl.c | 47 +++++++++++ fs/xfs/xfs_trace.h | 19 +++++ fs/xfs/xfs_trans.c | 3 + fs/xfs/xfs_trans.h | 7 ++ 15 files changed, 636 insertions(+), 1 deletion(-)
PATCH 1/3 xfs: track deferred ops statistics
From: Darrick J. Wong <[email protected]>
Track some basic statistics on how hard we're pushing the defer ops.
--- fs/xfs/libxfs/xfs_defer.c | 14 ++++++++++++++ fs/xfs/xfs_trace.h | 19 +++++++++++++++++++ fs/xfs/xfs_trans.c | 3 +++ fs/xfs/xfs_trans.h | 7 +++++++ 4 files changed, 43 insertions(+)
fs/xfs/libxfs/xfs_defer.c +14 -0
@@ -509,6 +509,8 @@ xfs_defer_finish_one(/* Done with the dfp, free it. */ list_del (&dfp->dfp_list);kmem_cache_free (xfs_defer_pending_cache, dfp); + tp->t_dfops_nr--; + tp->t_dfops_finished++; out:if (ops->finish_cleanup) ops->finish_cleanup (tp, state, error);
@@ -550,6 +552,9 @@ xfs_defer_finish_noroll(list_splice_init (&(*tp)->t_dfops, &dop_pending); + (*tp)->t_dfops_nr_max =max ((*tp)->t_dfops_nr, + (*tp)->t_dfops_nr_max); +if (has_intents <0 ) { error = has_intents; goto out_shutdown;
@@ -580,6 +585,7 @@ xfs_defer_finish_noroll(xfs_force_shutdown ((*tp)->t_mountp,SHUTDOWN_CORRUPT_INCORE );trace_xfs_defer_finish_error (*tp, error);xfs_defer_cancel_list ((*tp)->t_mountp, &dop_pending); + (*tp)->t_dfops_nr =0 ;xfs_defer_cancel (*tp);return error; }
@@ -620,6 +626,7 @@ xfs_defer_cancel(trace_xfs_defer_cancel (tp, _RET_IP_);xfs_defer_cancel_list (mp, &tp->t_dfops); + tp->t_dfops_nr =0 ; }/* Add an item for later deferred processing. */
@@ -656,6 +663,7 @@ xfs_defer_add( dfp->dfp_count =0 ;INIT_LIST_HEAD (&dfp->dfp_work);list_add_tail (&dfp->dfp_list, &tp->t_dfops); + tp->t_dfops_nr++; }list_add_tail (li, &dfp->dfp_work);
@@ -674,6 +682,12 @@ xfs_defer_move( struct xfs_trans *stp) {list_splice_init (&stp->t_dfops, &dtp->t_dfops); + dtp->t_dfops_nr += stp->t_dfops_nr; + dtp->t_dfops_nr_max = stp->t_dfops_nr_max; + dtp->t_dfops_finished = stp->t_dfops_finished; + stp->t_dfops_nr =0 ; + stp->t_dfops_nr_max =0 ; + stp->t_dfops_finished =0 ;/* * Low free space mode was historically controlled by a dfops field.
fs/xfs/xfs_trace.h +19 -0
@@ -2681,6 +2681,25 @@ TRACE_EVENT(xfs_btree_free_block,/* deferred ops */ struct xfs_defer_pending ; +TRACE_EVENT (xfs_defer_stats, + TP_PROTO(struct xfs_trans *tp), +TP_ARGS (tp), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(unsigned int, max) + __field(unsigned int, finished) + ), +TP_fast_assign ( + __entry->dev = tp->t_mountp->m_super->s_dev; + __entry->max = tp->t_dfops_nr_max; + __entry->finished = tp->t_dfops_finished; + ), +TP_printk ("dev %d:%d max %u finished %u" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->max, + __entry->finished) +) + DECLARE_EVENT_CLASS(xfs_defer_class, TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), TP_ARGS(tp, caller_ip),
fs/xfs/xfs_trans.c +3 -0
@@ -70,6 +70,9 @@ xfs_trans_free(xfs_extent_busy_sort (&tp->t_busy);xfs_extent_busy_clear (tp->t_mountp, &tp->t_busy, false); +if (tp->t_dfops_finished >0 ) +trace_xfs_defer_stats (tp); +trace_xfs_trans_free (tp, _RET_IP_);xfs_trans_clear_context (tp);if (!(tp->t_flags &XFS_TRANS_NO_WRITECOUNT ))
fs/xfs/xfs_trans.h +7 -0
@@ -155,6 +155,13 @@ typedef struct xfs_trans {struct list_head t_busy;/* list of busy extents */ struct list_head t_dfops;/* deferred operations */ unsigned long t_pflags;/* saved process flags state */ + +/* Count of deferred ops attached to transaction. */ +unsigned int t_dfops_nr; +/* Maximum t_dfops_nr seen in a loop. */ +unsigned int t_dfops_nr_max; +/* Number of dfops finished. */ +unsigned int t_dfops_finished; } xfs_trans_t;/*
PATCH 2/3 xfs: whine to dmesg when we encounter errors
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Forward everything scrub whines about to dmesg.
--- fs/xfs/scrub/btree.c | 88 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.c | 104 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 1 fs/xfs/scrub/dabtree.c | 24 +++++++++++ fs/xfs/scrub/inode.c | 4 ++ fs/xfs/scrub/scrub.c | 37 +++++++++++++++++ fs/xfs/scrub/trace.c | 22 ++++++++++ fs/xfs/scrub/trace.h | 2 + 8 files changed, 282 insertions(+)
fs/xfs/scrub/btree.c +88 -0
@@ -11,6 +11,8 @@#include "xfs_mount.h" #include "xfs_inode.h" #include "xfs_btree.h" +#include "xfs_log_format.h" +#include "xfs_ag.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/btree.h"
@@ -18,6 +20,62 @@/* btree scrubbing */ +/* Figure out which block the btree cursor was pointing to. */ +static inline xfs_fsblock_t +xchk_btree_cur_fsbno ( +struct xfs_btree_cur *cur, +int level) +{ +if (level < cur->bc_nlevels && cur->bc_levels[level].bp) +return XFS_DADDR_TO_FSB (cur->bc_mp, +xfs_buf_daddr (cur->bc_levels[level].bp)); +else if (level == cur->bc_nlevels -1 && + (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE )) +return XFS_INO_TO_FSB (cur->bc_mp, cur->bc_ino.ip->i_ino); +else if (!(cur->bc_flags &XFS_BTREE_LONG_PTRS )) +return XFS_AGB_TO_FSB (cur->bc_mp, cur->bc_ag.pag->pag_agno,0 ); +return NULLFSBLOCK ; +} + +static inline void +process_error_whine ( +struct xfs_scrub *sc, +struct xfs_btree_cur *cur, +int level, +int *error, +__u32 errflag, +void *ret_ip) +{ +xfs_fsblock_t fsbno =xchk_btree_cur_fsbno (cur, level); + +if (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ) { +xchk_whine (sc->mp,"ino 0x%llx fork %d type %s btnum %d level %d ptr %d agno 0x%x agbno 0x%x error %d errflag 0x%x ret_ip %pS" , + cur->bc_ino.ip->i_ino, + cur->bc_ino.whichfork, +xchk_type_string (sc->sm->sm_type), + cur->bc_btnum, + level, + cur->bc_levels[level].ptr, +XFS_FSB_TO_AGNO (cur->bc_mp, fsbno), +XFS_FSB_TO_AGBNO (cur->bc_mp, fsbno), + *error, + errflag, + ret_ip); +return ; + } + +xchk_whine (sc->mp,"type %s btnum %d level %d ptr %d agno 0x%x agbno 0x%x error %d errflag 0x%x ret_ip %pS" , +xchk_type_string (sc->sm->sm_type), + cur->bc_btnum, + level, + cur->bc_levels[level].ptr, +XFS_FSB_TO_AGNO (cur->bc_mp, fsbno), +XFS_FSB_TO_AGBNO (cur->bc_mp, fsbno), + *error, + errflag, + ret_ip); +} +/* * Check for btree operation errors. See the section about handling * operational errors in common.c.
@@ -44,9 +102,13 @@ __xchk_btree_process_error(case -EFSCORRUPTED :/* Note the badness but don't abort. */ sc->sm->sm_flags |= errflag; +process_error_whine (sc, cur, level, error, errflag, ret_ip); *error =0 ; fallthrough;default : +if (*error) +process_error_whine (sc, cur, level, error, errflag, + ret_ip);if (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE )trace_xchk_ifork_btree_op_error (sc, cur, level, *error, ret_ip);
@@ -92,11 +154,37 @@ __xchk_btree_set_corrupt( sc->sm->sm_flags |= errflag;if (cur->bc_flags &XFS_BTREE_ROOT_IN_INODE ) + { +xfs_fsblock_t fsbno =xchk_btree_cur_fsbno (cur, level); +xchk_whine (sc->mp,"ino 0x%llx fork %d type %s btnum %d level %d ptr %d agno 0x%x agbno 0x%x errflag 0x%x ret_ip %pS" , + cur->bc_ino.ip->i_ino, + cur->bc_ino.whichfork, +xchk_type_string (sc->sm->sm_type), + cur->bc_btnum, + level, + cur->bc_levels[level].ptr, +XFS_FSB_TO_AGNO (cur->bc_mp, fsbno), +XFS_FSB_TO_AGBNO (cur->bc_mp, fsbno), + errflag, + ret_ip);trace_xchk_ifork_btree_error (sc, cur, level, ret_ip); + }else + { +xfs_fsblock_t fsbno =xchk_btree_cur_fsbno (cur, level); +xchk_whine (sc->mp,"type %s btnum %d level %d ptr %d agno 0x%x agbno 0x%x errflag 0x%x ret_ip %pS" , +xchk_type_string (sc->sm->sm_type), + cur->bc_btnum, + level, + cur->bc_levels[level].ptr, +XFS_FSB_TO_AGNO (cur->bc_mp, fsbno), +XFS_FSB_TO_AGBNO (cur->bc_mp, fsbno), + errflag, + ret_ip);trace_xchk_btree_error (sc, cur, level, ret_ip); + } }void
fs/xfs/scrub/common.c +104 -0
203 lines not on this page · raw message
fs/xfs/scrub/common.h +1 -0
@@ -210,6 +210,7 @@ bool xchk_ilock_nowait(struct xfs_scrub *sc, unsigned int ilock_flags);void xchk_iunlock (struct xfs_scrub *sc,unsigned int ilock_flags);void xchk_buffer_recheck (struct xfs_scrub *sc,struct xfs_buf *bp); +void xchk_whine (const struct xfs_mount *mp,const char *fmt, ...);int xchk_iget (struct xfs_scrub *sc,xfs_ino_t inum,struct xfs_inode **ipp); int xchk_iget_agi(struct xfs_scrub *sc, xfs_ino_t inum,
fs/xfs/scrub/dabtree.c +24 -0
@@ -47,9 +47,26 @@ xchk_da_process_error(case -EFSCORRUPTED :/* Note the badness but don't abort. */ sc->sm->sm_flags |=XFS_SCRUB_OFLAG_CORRUPT ; +xchk_whine (sc->mp,"ino 0x%llx fork %d type %s dablk 0x%llx error %d ret_ip %pS" , + sc->ip->i_ino, + ds->dargs.whichfork, +xchk_type_string (sc->sm->sm_type), +xfs_dir2_da_to_db (ds->dargs.geo, + ds->state->path.blk[level].blkno), + *error, + __return_address); *error =0 ; fallthrough;default : +if (*error) +xchk_whine (sc->mp,"ino 0x%llx fork %d type %s dablk 0x%llx error %d ret_ip %pS" , + sc->ip->i_ino, + ds->dargs.whichfork, +xchk_type_string (sc->sm->sm_type), +xfs_dir2_da_to_db (ds->dargs.geo, + ds->state->path.blk[level].blkno), + *error, + __return_address); trace_xchk_file_op_error(sc, ds->dargs.whichfork, xfs_dir2_da_to_db(ds->dargs.geo, ds->state->path.blk[level].blkno),
@@ -72,6 +89,13 @@ xchk_da_set_corrupt( sc->sm->sm_flags |=XFS_SCRUB_OFLAG_CORRUPT ; +xchk_whine (sc->mp,"ino 0x%llx fork %d type %s dablk 0x%llx ret_ip %pS" , + sc->ip->i_ino, + ds->dargs.whichfork, +xchk_type_string (sc->sm->sm_type), +xfs_dir2_da_to_db (ds->dargs.geo, + ds->state->path.blk[level].blkno), + __return_address); trace_xchk_fblock_error(sc, ds->dargs.whichfork, xfs_dir2_da_to_db(ds->dargs.geo, ds->state->path.blk[level].blkno),
fs/xfs/scrub/inode.c +4 -0
@@ -187,6 +187,10 @@ xchk_setup_inode( out_cancel:xchk_trans_cancel (sc); out_error: +xchk_whine (mp,"type %s agno 0x%x agbno 0x%x error %d ret_ip %pS" , +xchk_type_string (sc->sm->sm_type), agno, +XFS_INO_TO_AGBNO (mp, sc->sm->sm_ino), error, + __return_address);trace_xchk_op_error (sc, agno,XFS_INO_TO_AGBNO (mp, sc->sm->sm_ino), error, __return_address);return error;
fs/xfs/scrub/scrub.c +37 -0
@@ -551,6 +551,42 @@ static inline void xchk_postmortem(struct xfs_scrub *sc) }#endif /* CONFIG_XFS_ONLINE_REPAIR */ +static inline void +repair_outcomes (struct xfs_scrub *sc,int error) +{ +struct xfs_scrub_metadata *sm = sc->sm; +const char *wut =NULL ; + +if (sc->flags &XREP_ALREADY_FIXED ) { + wut ="*** REPAIR SUCCESS" ; + error =0 ; + }else if (error == -EBUSY ) { + wut ="??? FILESYSTEM BUSY" ; + }else if (error == -EAGAIN ) { + wut ="??? REPAIR DEFERRED" ; + }else if (error == -ECANCELED ) { + wut ="??? REPAIR CANCELLED" ; + }else if (error == -EINTR ) { + wut ="??? REPAIR INTERRUPTED" ; + }else if (error != -EOPNOTSUPP && error != -ENOENT ) { + wut ="!!! REPAIR FAILED" ; +xfs_info (sc->mp, +"%s ino 0x%llx type %s agno 0x%x inum 0x%llx gen 0x%x flags 0x%x error %d" , + wut,XFS_I (file_inode (sc->file))->i_ino, +xchk_type_string (sm->sm_type), sm->sm_agno, + sm->sm_ino, sm->sm_gen, sm->sm_flags, error); +return ; + }else { +return ; + } + +xfs_info_ratelimited (sc->mp, +"%s ino 0x%llx type %s agno 0x%x inum 0x%llx gen 0x%x flags 0x%x error %d" , + wut,XFS_I (file_inode (sc->file))->i_ino, +xchk_type_string (sm->sm_type), sm->sm_agno, sm->sm_ino, + sm->sm_gen, sm->sm_flags, error); +} +/* Dispatch metadata scrubbing. */ int xfs_scrub_metadata(
@@ -643,6 +679,7 @@ xfs_scrub_metadata(* already tried to fix it, then attempt a repair. */ error =xrep_attempt (sc); +repair_outcomes (sc, error);if (error == -EAGAIN ) {/* * Either the repair function succeeded or it couldn't
fs/xfs/scrub/trace.c +22 -0
@@ -62,3 +62,25 @@ xfbtree_ino(*/ #define CREATE_TRACE_POINTS #include "scrub/trace.h" + +/* xchk_whine stuff */ +struct xchk_tstr { +unsigned int type; +const char *tag; +}; + +static const struct xchk_tstr xchk_tstr_tags[] = {XFS_SCRUB_TYPE_STRINGS }; + +const char * +xchk_type_string ( +unsigned int type) +{ +unsigned int i; + +for (i =0 ; i <ARRAY_SIZE (xchk_tstr_tags); i++) { +if (xchk_tstr_tags[i].type == type) +return xchk_tstr_tags[i].tag; + } + +return "???" ; +}
fs/xfs/scrub/trace.h +2 -0
@@ -115,6 +115,8 @@ TRACE_DEFINE_ENUM(XFS_SCRUB_TYPE_RTREFCBT); { XFS_SCRUB_TYPE_RTRMAPBT, "rtrmapbt" }, \ { XFS_SCRUB_TYPE_RTREFCBT, "rtrefcountbt" } +const char *xchk_type_string (unsigned int type); +#define XFS_SCRUB_FLAG_STRINGS \ { XFS_SCRUB_IFLAG_REPAIR, "repair" }, \ { XFS_SCRUB_OFLAG_CORRUPT, "corrupt" }, \
PATCH 3/3 xfs: introduce vectored scrub mode
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Introduce a variant on XFS_SCRUB_METADATA that allows for vectored mode.
--- fs/xfs/libxfs/xfs_fs.h | 37 ++++++++++++ fs/xfs/scrub/scrub.c | 148 ++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/trace.h | 78 ++++++++++++++++++++++++ fs/xfs/scrub/xfs_scrub.h | 2 + fs/xfs/xfs_ioctl.c | 47 +++++++++++++++ 5 files changed, 311 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_fs.h +37 -0
@@ -751,6 +751,15 @@ struct xfs_scrub_metadata {/* Number of scrub subcommands. */ #define XFS_SCRUB_TYPE_NR 32 +/* +* This special type code only applies to the vectored scrub implementation. +* +* If any of the previous scrub vectors recorded runtime errors or have +* sv_flags bits set that match the OFLAG bits in the barrier vector's +* sv_flags, set the barrier's sv_ret to -ECANCELED and return to userspace. +*/ +#define XFS_SCRUB_TYPE_BARRIER (-1U) +/* i: Repair this metadata. */ #define XFS_SCRUB_IFLAG_REPAIR (1u << 0)
@@ -795,6 +804,33 @@ struct xfs_scrub_metadata { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED)#define XFS_SCRUB_FLAGS_ALL (XFS_SCRUB_FLAGS_IN | XFS_SCRUB_FLAGS_OUT) +struct xfs_scrub_vec { +__u32 sv_type;/* XFS_SCRUB_TYPE_* */ +__u32 sv_flags;/* XFS_SCRUB_FLAGS_* */ +__s32 sv_ret;/* 0 or a negative error code */ +__u32 sv_reserved;/* must be zero */ +}; + +/* Vectored metadata scrub control structure. */ +struct xfs_scrub_vec_head { +__u64 svh_ino;/* inode number. */ +__u32 svh_gen;/* inode generation. */ +__u32 svh_agno;/* ag number. */ +__u32 svh_flags;/* XFS_SCRUB_VEC_FLAGS_* */ +__u16 svh_rest_us;/* wait this much time between vector items */ +__u16 svh_nr;/* number of svh_vecs */ + +struct xfs_scrub_vec svh_vecs[0 ]; +}; + +#define XFS_SCRUB_VEC_FLAGS_ALL (0) + +static inline size_t sizeof_xfs_scrub_vec (unsigned int nr) +{ +return sizeof (struct xfs_scrub_vec_head ) + + nr *sizeof (struct xfs_scrub_vec ); +} +/* * ioctl limits */
@@ -839,6 +875,7 @@ struct xfs_scrub_metadata {#define XFS_IOC_FREE_EOFBLOCKS _IOR ('X', 58, struct xfs_fs_eofblocks)/* XFS_IOC_GETFSMAP ------ hoisted 59 */ #define XFS_IOC_SCRUB_METADATA _IOWR('X', 60, struct xfs_scrub_metadata) +#define XFS_IOC_SCRUBV_METADATA _IOWR('X', 60, struct xfs_scrub_vec_head)#define XFS_IOC_AG_GEOMETRY _IOWR('X', 61, struct xfs_ag_geometry)#define XFS_IOC_RTGROUP_GEOMETRY _IOWR('X', 62, struct xfs_rtgroup_geometry)
fs/xfs/scrub/scrub.c +148 -0
157 lines not on this page · raw message
fs/xfs/scrub/trace.h +77 -1
96 lines not on this page · raw message
fs/xfs/scrub/xfs_scrub.h +2 -0
@@ -8,8 +8,10 @@#ifndef CONFIG_XFS_ONLINE_SCRUB # define xfs_scrub_metadata (file, sm) (-ENOTTY) +# define xfs_scrubv_metadata (file, vhead) (-ENOTTY)#else int xfs_scrub_metadata (struct file *file,struct xfs_scrub_metadata *sm); +int xfs_scrubv_metadata (struct file *file,struct xfs_scrub_vec_head *vhead);#endif /* CONFIG_XFS_ONLINE_SCRUB */ #endif /* __XFS_SCRUB_H__ */
fs/xfs/xfs_ioctl.c +47 -0
59 lines not on this page · raw message
cover xfs: report refcount information to userspace
In reply to Darrick J. WongHi all,
Create a new ioctl to report the number of owners of each disk block so that reflink-aware defraggers can make better decisions about which extents to target.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=report-refcounts
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=report-refcounts
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=report-refcounts
--- fs/xfs/Makefile | 1 fs/xfs/xfs_fsrefs.c | 935 ++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_fsrefs.h | 34 + fs/xfs/xfs_ioctl.c | 135 +++++ fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 74 +++ include/uapi/linux/fsrefcounts.h | 96 ++++ 7 files changed, 1276 insertions(+) create mode 100644 fs/xfs/xfs_fsrefs.c create mode 100644 fs/xfs/xfs_fsrefs.h create mode 100644 include/uapi/linux/fsrefcounts.h
PATCH 1/1 xfs: export reference count information to userspace
From: Darrick J. Wong <[email protected]>
Export refcount info to userspace so we can prototype a sharing-aware defrag/fs rearranging tool.
--- fs/xfs/Makefile | 1 fs/xfs/xfs_fsrefs.c | 935 ++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_fsrefs.h | 34 + fs/xfs/xfs_ioctl.c | 135 +++++ fs/xfs/xfs_trace.c | 1 fs/xfs/xfs_trace.h | 74 +++ include/uapi/linux/fsrefcounts.h | 96 ++++ 7 files changed, 1276 insertions(+) create mode 100644 fs/xfs/xfs_fsrefs.c create mode 100644 fs/xfs/xfs_fsrefs.h create mode 100644 include/uapi/linux/fsrefcounts.h
fs/xfs/Makefile +1 -0
@@ -78,6 +78,7 @@ xfs-y += xfs_aops.o \ xfs_filestream.o \ xfs_fsmap.o \ xfs_fsops.o \ + xfs_fsrefs.o \ xfs_globals.o \ xfs_health.o \ xfs_icache.o \
fs/xfs/xfs_fsrefs.c new file +935 -0
935 lines not on this page · raw message
fs/xfs/xfs_fsrefs.h new file +34 -0
@@ -0,0 +1,34 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2022 Oracle. All Rights Reserved. +* Author: Darrick J. Wong <[email protected]> +*/ +#ifndef __XFS_FSREFS_H__ +#define __XFS_FSREFS_H__ + +struct fsrefs ; + +/* internal fsrefs representation */ +struct xfs_fsrefs { +dev_t fcr_device;/* device id */ +uint32_t fcr_flags;/* mapping flags */ +uint64_t fcr_physical;/* device offset of segment */ +uint64_t fcr_owners;/* number of owners */ +xfs_filblks_t fcr_length;/* length of segment, blocks */ +}; + +struct xfs_fsrefs_head { +uint32_t fch_iflags;/* control flags */ +uint32_t fch_oflags;/* output flags */ +unsigned int fch_count;/* # of entries in array incl. input */ +unsigned int fch_entries;/* # of entries filled in (output). */ + +struct xfs_fsrefs fch_keys[2 ];/* low and high keys */ +}; + +void xfs_fsrefs_to_internal (struct xfs_fsrefs *dest,struct fsrefs *src); + +int xfs_getfsrefs (struct xfs_mount *mp,struct xfs_fsrefs_head *head, +struct fsrefs *out_recs); + +#endif /* __XFS_FSREFS_H__ */
fs/xfs/xfs_ioctl.c +135 -0
153 lines not on this page · raw message
fs/xfs/xfs_trace.c +1 -0
@@ -45,6 +45,7 @@#include "xfs_rtgroup.h" #include "xfs_rmap.h" #include "xfs_refcount.h" +#include "xfs_fsrefs.h" static inline void xfs_rmapbt_crack_agno_opdev(
fs/xfs/xfs_trace.h +74 -0
86 lines not on this page · raw message
include/uapi/linux/fsrefcounts.h new file +96 -0
96 lines not on this page · raw message
cover xfs: defragment free space
In reply to Darrick J. WongHi all,
These patches contain experimental code to enable userspace to defragment the free space in a filesystem. Two purposes are imagined for this
functionality: clearing space at the end of a filesystem before shrinking it, and clearing free space in anticipation of making a large allocation.
The first patch adds a new fallocate mode that allows userspace to allocate free space from the filesystem into a file. The goal here is to allow the filesystem shrink process to prevent allocation from a certain part of the filesystem while a free space defragmenter evacuates all the files from the doomed part of the filesystem.
The second patch amends the online repair system to allow the sysadmin to forcibly rebuild metadata structures, even if they're not corrupt. Without adding an ioctl to move metadata btree blocks, this is the only way to dislodge metadata.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=defrag-freespace
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=defrag-freespace
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=defrag-freespace
--- fs/open.c | 5 + fs/xfs/libxfs/xfs_alloc.c | 88 ++++++++++++ fs/xfs/libxfs/xfs_alloc.h | 4 + fs/xfs/libxfs/xfs_bmap.c | 150 ++++++++++++++++++++ fs/xfs/libxfs/xfs_bmap.h | 3 fs/xfs/xfs_bmap_util.c | 315 ++++++++++++++++++++++++++++++++++++++++++- fs/xfs/xfs_bmap_util.h | 7 + fs/xfs/xfs_file.c | 39 +++++ fs/xfs/xfs_rtalloc.c | 49 +++++++ fs/xfs/xfs_rtalloc.h | 12 ++ fs/xfs/xfs_trace.h | 72 +++++++++- include/linux/falloc.h | 3 include/uapi/linux/falloc.h | 8 + 13 files changed, 742 insertions(+), 13 deletions(-)
PATCH 1/2 xfs: capture the offset and length in fallocate tracepoints
From: Darrick J. Wong <[email protected]>
Change the class of the fallocate tracepoints to capture the offset and length of the requested operation.
--- fs/xfs/xfs_bmap_util.c | 8 ++++---- fs/xfs/xfs_file.c | 2 +- fs/xfs/xfs_trace.h | 10 +++++----- 3 files changed, 10 insertions(+), 10 deletions(-)
fs/xfs/xfs_bmap_util.c +4 -4
@@ -828,7 +828,7 @@ xfs_alloc_file_space(xfs_bmbt_irec_t imaps[1 ], *imapp;int error; -trace_xfs_alloc_file_space (ip); +trace_xfs_alloc_file_space (ip, offset, len);if (xfs_is_shutdown (mp))return -EIO ;
@@ -1012,7 +1012,7 @@ xfs_free_file_space(xfs_fileoff_t endoffset_fsb;int done =0 , error; -trace_xfs_free_file_space (ip); +trace_xfs_free_file_space (ip, offset, len); error =xfs_qm_dqattach (ip);if (error)
@@ -1150,7 +1150,7 @@ xfs_collapse_file_space(ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL ));ASSERT (xfs_isilocked (ip,XFS_MMAPLOCK_EXCL )); -trace_xfs_collapse_file_space (ip); +trace_xfs_collapse_file_space (ip, offset, len); error =xfs_free_file_space (ip, offset, len);if (error)
@@ -1220,7 +1220,7 @@ xfs_insert_file_space(ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL ));ASSERT (xfs_isilocked (ip,XFS_MMAPLOCK_EXCL )); -trace_xfs_insert_file_space (ip); +trace_xfs_insert_file_space (ip, offset, len); error =xfs_bmap_can_insert_extents (ip, stop_fsb, shift_fsb);if (error)
fs/xfs/xfs_file.c +1 -1
@@ -1096,7 +1096,7 @@ xfs_file_fallocate(*/ unsigned int blksize =i_blocksize (inode); -trace_xfs_zero_file_space (ip); +trace_xfs_zero_file_space (ip, offset, len);/* Unshare around the region to zero, if needed. */ if (xfs_inode_needs_cow_around (ip)) {
fs/xfs/xfs_trace.h +5 -5
@@ -817,11 +817,6 @@ DEFINE_INODE_EVENT(xfs_getattr);DEFINE_INODE_EVENT (xfs_setattr);DEFINE_INODE_EVENT (xfs_readlink);DEFINE_INODE_EVENT (xfs_inactive_symlink); -DEFINE_INODE_EVENT (xfs_alloc_file_space); -DEFINE_INODE_EVENT (xfs_free_file_space); -DEFINE_INODE_EVENT (xfs_zero_file_space); -DEFINE_INODE_EVENT (xfs_collapse_file_space); -DEFINE_INODE_EVENT (xfs_insert_file_space);DEFINE_INODE_EVENT (xfs_readdir);#ifdef CONFIG_XFS_POSIX_ACL DEFINE_INODE_EVENT (xfs_get_acl);
@@ -1610,6 +1605,11 @@ DEFINE_SIMPLE_IO_EVENT(xfs_zero_eof);DEFINE_SIMPLE_IO_EVENT (xfs_end_io_direct_write);DEFINE_SIMPLE_IO_EVENT (xfs_end_io_direct_write_unwritten);DEFINE_SIMPLE_IO_EVENT (xfs_end_io_direct_write_append); +DEFINE_SIMPLE_IO_EVENT (xfs_alloc_file_space); +DEFINE_SIMPLE_IO_EVENT (xfs_free_file_space); +DEFINE_SIMPLE_IO_EVENT (xfs_zero_file_space); +DEFINE_SIMPLE_IO_EVENT (xfs_collapse_file_space); +DEFINE_SIMPLE_IO_EVENT (xfs_insert_file_space); DECLARE_EVENT_CLASS(xfs_itrunc_class, TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size),
PATCH 2/2 xfs: fallocate free space into a file
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a new fallocate mode to map free physical space into a file, at the same file offset as if the file were a sparse image of the physical device backing the filesystem. The intent here is to use this to prototype a free space defragmentation tool.
--- fs/open.c | 5 + fs/xfs/libxfs/xfs_alloc.c | 88 ++++++++++++ fs/xfs/libxfs/xfs_alloc.h | 4 + fs/xfs/libxfs/xfs_bmap.c | 150 +++++++++++++++++++++ fs/xfs/libxfs/xfs_bmap.h | 3 fs/xfs/xfs_bmap_util.c | 307 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_bmap_util.h | 7 + fs/xfs/xfs_file.c | 37 +++++ fs/xfs/xfs_rtalloc.c | 49 +++++++ fs/xfs/xfs_rtalloc.h | 12 ++ fs/xfs/xfs_trace.h | 62 +++++++++ include/linux/falloc.h | 3 include/uapi/linux/falloc.h | 8 + 13 files changed, 732 insertions(+), 3 deletions(-)
fs/open.c +5 -0
@@ -277,6 +277,11 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len) (mode & ~(FALLOC_FL_UNSHARE_RANGE | FALLOC_FL_KEEP_SIZE)))return -EINVAL ; +/* Mapping free space should only be used by itself. */ +if ((mode &FALLOC_FL_MAP_FREE_SPACE ) && + (mode & ~FALLOC_FL_MAP_FREE_SPACE )) +return -EINVAL ; +if (!(file->f_mode &FMODE_WRITE ))return -EBADF ;
fs/xfs/libxfs/xfs_alloc.c +88 -0
91 lines not on this page · raw message
fs/xfs/libxfs/xfs_alloc.h +4 -0
@@ -268,4 +268,8 @@ extern struct kmem_cache *xfs_extfree_item_cache;int __init xfs_extfree_intent_init_cache (void );void xfs_extfree_intent_destroy_cache (void ); +int xfs_alloc_find_freesp (struct xfs_trans *tp,struct xfs_perag *pag, +xfs_agblock_t *agbno,xfs_agblock_t end_agbno, +xfs_extlen_t *len); +#endif /* __XFS_ALLOC_H__ */
fs/xfs/libxfs/xfs_bmap.c +150 -0
159 lines not on this page · raw message
fs/xfs/libxfs/xfs_bmap.h +3 -0
@@ -193,6 +193,9 @@ int xfs_bmapi_read(struct xfs_inode *ip, xfs_fileoff_t bno,int xfs_bmapi_write (struct xfs_trans *tp,struct xfs_inode *ip,xfs_fileoff_t bno,xfs_filblks_t len,uint32_t flags,xfs_extlen_t total,struct xfs_bmbt_irec *mval,int *nmap); +int xfs_bmapi_freesp (struct xfs_trans *tp,struct xfs_inode *ip, +xfs_fsblock_t fsbno,xfs_extlen_t len, +struct xfs_bmbt_irec *mval);int __xfs_bunmapi (struct xfs_trans *tp,struct xfs_inode *ip,xfs_fileoff_t bno,xfs_filblks_t *rlen,uint32_t flags,xfs_extnum_t nexts);
fs/xfs/xfs_bmap_util.c +307 -0
316 lines not on this page · raw message
fs/xfs/xfs_bmap_util.h +7 -0
@@ -76,4 +76,11 @@ int xfs_bmap_count_blocks(struct xfs_trans *tp, struct xfs_inode *ip,int xfs_flush_unmap_range (struct xfs_inode *ip,xfs_off_t offset,xfs_off_t len); +int xfs_map_free_space (struct xfs_inode *ip,xfs_off_t off,xfs_off_t len); +#ifdef CONFIG_XFS_RT +int xfs_map_free_rt_space (struct xfs_inode *ip,xfs_off_t off,xfs_off_t len); +#else +# define xfs_map_free_rt_space (ip, off, len) (-EOPNOTSUPP) +#endif +#endif /* __XFS_BMAP_UTIL_H__ */
fs/xfs/xfs_file.c +36 -1
@@ -960,7 +960,8 @@ static inline bool xfs_file_sync_writes(struct file *filp)#define XFS_FALLOC_FL_SUPPORTED \ (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | \ FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE | \ - FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE) + FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE | \ + FALLOC_FL_MAP_FREE_SPACE)STATIC long xfs_file_fallocate(
@@ -1075,6 +1076,40 @@ xfs_file_fallocate( goto out_unlock; } do_file_insert = true; + }else if (mode &FALLOC_FL_MAP_FREE_SPACE ) { +struct xfs_mount *mp = ip->i_mount; +xfs_off_t device_size; + +if (!capable (CAP_SYS_ADMIN )) { + error = -EPERM ; + goto out_unlock; + } + +if (XFS_IS_REALTIME_INODE (ip)) + device_size =XFS_FSB_TO_B (mp, mp->m_sb.sb_rblocks); +else + device_size =XFS_FSB_TO_B (mp, mp->m_sb.sb_dblocks); + +/* +* Bail out now if we aren't allowed to make the file size the +* same length as the device. +*/ +if (device_size >i_size_read (inode)) { + new_size = device_size; + error =inode_newsize_ok (inode, new_size); +if (error) + goto out_unlock; + } + +if (XFS_IS_REALTIME_INODE (ip)) + error =xfs_map_free_rt_space (ip, offset, len); +else + error =xfs_map_free_space (ip, offset, len); +if (error) { +if (error == -ECANCELED ) + error =0 ; + goto out_unlock; + } }else {if (!(mode &FALLOC_FL_KEEP_SIZE ) && offset + len >i_size_read (inode)) {
fs/xfs/xfs_rtalloc.c +49 -0
52 lines not on this page · raw message
fs/xfs/xfs_rtalloc.h +11 -1
@@ -89,8 +89,17 @@ int xfs_growfs_check_rtgeom(const struct xfs_mount *mp, xfs_rfsblock_t dblocks, xfs_rfsblock_t rblocks, xfs_agblock_t rextsize, xfs_rtblock_t rextents, xfs_extlen_t rbmblocks, uint8_t rextslog); + +int xfs_rtalloc_find_freesp (struct xfs_trans *tp,xfs_rtxnum_t *rtx, +xfs_rtxnum_t end_rtx,xfs_rtxlen_t *len_rtx);#else -# define xfs_rtallocate_extent (t,b,min,max,l,f,p,rb) (-ENOSYS) +static inline int +xfs_rtallocate_extent (struct xfs_trans *tp,xfs_rtxnum_t start, +xfs_rtxlen_t minlen,xfs_rtxlen_t maxlen,xfs_rtxlen_t *len, +int wasdel,xfs_rtxlen_t prod,xfs_rtxnum_t *rtblock) +{ +return -ENOSYS ; +}# define xfs_rtpick_extent (m,t,l,rb) (-ENOSYS)# define xfs_growfs_rt (mp,in) (-ENOSYS)# define xfs_rtalloc_reinit_frextents (m) (0)
@@ -113,6 +122,7 @@ xfs_rtmount_init(# define xfs_rt_resv_init (mp) (0)# define xfs_rtmount_dqattach (mp) (0)# define xfs_growfs_check_rtgeom (mp, d, r, rs, rx, rb, rl) (0) +# define xfs_rtalloc_find_freesp (tp, rtx, end_rtx, len_rtx) (-ENOSYS)#endif /* CONFIG_XFS_RT */ #endif /* __XFS_RTALLOC_H__ */
fs/xfs/xfs_trace.h +62 -0
98 lines not on this page · raw message
include/linux/falloc.h +2 -1
@@ -30,7 +30,8 @@ struct space_resv { FALLOC_FL_COLLAPSE_RANGE | \ FALLOC_FL_ZERO_RANGE | \ FALLOC_FL_INSERT_RANGE | \ - FALLOC_FL_UNSHARE_RANGE) + FALLOC_FL_UNSHARE_RANGE | \ + FALLOC_FL_MAP_FREE_SPACE)/* on ia32 l_start is on a 32-bit boundary */ #if defined(CONFIG_X86_64 )
include/uapi/linux/falloc.h +8 -0
@@ -2,6 +2,14 @@#ifndef _UAPI_FALLOC_H_#define _UAPI_FALLOC_H_ +/* +* FALLOC_FL_MAP_FREE_SPACE maps all the free physical space in the +* filesystem into the file at the same offsets. This flag requires +* CAP_SYS_ADMIN, and cannot be used with any other flags. It probably +* only works on filesystems that are backed by physical media. +*/ +#define FALLOC_FL_MAP_FREE_SPACE (1U << 30) +#define FALLOC_FL_KEEP_SIZE 0x01/* default is extend size */ #define FALLOC_FL_PUNCH_HOLE 0x02/* de-allocates range */ #define FALLOC_FL_NO_HIDE_STALE 0x04/* reserved codepoint */
cover xfs_scrub: vectorize kernel calls
In reply to Darrick J. WongHi all,
Create a vectorized version of the metadata scrub and repair ioctl, and adapt xfs_scrub to use that. This is an experiment to measure overhead and to try refactoring xfs_scrub.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=vectorized-scrub
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=vectorized-scrub
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=vectorized-scrub
--- include/xfs_trans.h | 4 io/scrub.c | 485 +++++++++++++++++++++++++++++++++++++++++-------- libfrog/fsgeom.h | 6 + libfrog/scrub.c | 124 +++++++++++++ libfrog/scrub.h | 1 libxfs/xfs_defer.c | 14 + libxfs/xfs_fs.h | 37 ++++ man/man8/xfs_io.8 | 47 +++++ scrub/phase1.c | 2 scrub/phase2.c | 106 +++++++++-- scrub/phase3.c | 84 +++++++- scrub/repair.c | 347 ++++++++++++++++++++++------------- scrub/scrub.c | 353 ++++++++++++++++++++++++++---------- scrub/scrub.h | 19 ++ scrub/scrub_private.h | 62 ++++-- 15 files changed, 1344 insertions(+), 347 deletions(-)
PATCH 1/11 xfs: track deferred ops statistics
From: Darrick J. Wong <[email protected]>
Track some basic statistics on how hard we're pushing the defer ops.
--- include/xfs_trans.h | 4 ++++ libxfs/xfs_defer.c | 14 ++++++++++++++ 2 files changed, 18 insertions(+)
include/xfs_trans.h +4 -0
@@ -75,6 +75,10 @@ typedef struct xfs_trans {long t_frextents_delta;/* superblock freextents chg*/ struct list_head t_items;/* log item descriptors */ struct list_head t_dfops;/* deferred operations */ + +unsigned int t_dfops_nr; +unsigned int t_dfops_nr_max; +unsigned int t_dfops_finished; } xfs_trans_t;void xfs_trans_init (struct xfs_mount *);
libxfs/xfs_defer.c +14 -0
@@ -504,6 +504,8 @@ xfs_defer_finish_one(/* Done with the dfp, free it. */ list_del (&dfp->dfp_list);kmem_cache_free (xfs_defer_pending_cache, dfp); + tp->t_dfops_nr--; + tp->t_dfops_finished++; out:if (ops->finish_cleanup) ops->finish_cleanup (tp, state, error);
@@ -545,6 +547,9 @@ xfs_defer_finish_noroll(list_splice_init (&(*tp)->t_dfops, &dop_pending); + (*tp)->t_dfops_nr_max =max ((*tp)->t_dfops_nr, + (*tp)->t_dfops_nr_max); +if (has_intents <0 ) { error = has_intents; goto out_shutdown;
@@ -575,6 +580,7 @@ xfs_defer_finish_noroll(xfs_force_shutdown ((*tp)->t_mountp,SHUTDOWN_CORRUPT_INCORE );trace_xfs_defer_finish_error (*tp, error);xfs_defer_cancel_list ((*tp)->t_mountp, &dop_pending); + (*tp)->t_dfops_nr =0 ;xfs_defer_cancel (*tp);return error; }
@@ -615,6 +621,7 @@ xfs_defer_cancel(trace_xfs_defer_cancel (tp, _RET_IP_);xfs_defer_cancel_list (mp, &tp->t_dfops); + tp->t_dfops_nr =0 ; }/* Add an item for later deferred processing. */
@@ -651,6 +658,7 @@ xfs_defer_add( dfp->dfp_count =0 ;INIT_LIST_HEAD (&dfp->dfp_work);list_add_tail (&dfp->dfp_list, &tp->t_dfops); + tp->t_dfops_nr++; }list_add_tail (li, &dfp->dfp_work);
@@ -669,6 +677,12 @@ xfs_defer_move( struct xfs_trans *stp) {list_splice_init (&stp->t_dfops, &dtp->t_dfops); + dtp->t_dfops_nr += stp->t_dfops_nr; + dtp->t_dfops_nr_max = stp->t_dfops_nr_max; + dtp->t_dfops_finished = stp->t_dfops_finished; + stp->t_dfops_nr =0 ; + stp->t_dfops_nr_max =0 ; + stp->t_dfops_finished =0 ;/* * Low free space mode was historically controlled by a dfops field.
PATCH 2/11 xfs: introduce vectored scrub mode
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Introduce a variant on XFS_SCRUB_METADATA that allows for vectored mode.
--- libxfs/xfs_fs.h | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)
libxfs/xfs_fs.h +37 -0
@@ -751,6 +751,15 @@ struct xfs_scrub_metadata {/* Number of scrub subcommands. */ #define XFS_SCRUB_TYPE_NR 32 +/* +* This special type code only applies to the vectored scrub implementation. +* +* If any of the previous scrub vectors recorded runtime errors or have +* sv_flags bits set that match the OFLAG bits in the barrier vector's +* sv_flags, set the barrier's sv_ret to -ECANCELED and return to userspace. +*/ +#define XFS_SCRUB_TYPE_BARRIER (-1U) +/* i: Repair this metadata. */ #define XFS_SCRUB_IFLAG_REPAIR (1u << 0)
@@ -795,6 +804,33 @@ struct xfs_scrub_metadata { XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED)#define XFS_SCRUB_FLAGS_ALL (XFS_SCRUB_FLAGS_IN | XFS_SCRUB_FLAGS_OUT) +struct xfs_scrub_vec { +__u32 sv_type;/* XFS_SCRUB_TYPE_* */ +__u32 sv_flags;/* XFS_SCRUB_FLAGS_* */ +__s32 sv_ret;/* 0 or a negative error code */ +__u32 sv_reserved;/* must be zero */ +}; + +/* Vectored metadata scrub control structure. */ +struct xfs_scrub_vec_head { +__u64 svh_ino;/* inode number. */ +__u32 svh_gen;/* inode generation. */ +__u32 svh_agno;/* ag number. */ +__u32 svh_flags;/* XFS_SCRUB_VEC_FLAGS_* */ +__u16 svh_rest_us;/* wait this much time between vector items */ +__u16 svh_nr;/* number of svh_vecs */ + +struct xfs_scrub_vec svh_vecs[0 ]; +}; + +#define XFS_SCRUB_VEC_FLAGS_ALL (0) + +static inline size_t sizeof_xfs_scrub_vec (unsigned int nr) +{ +return sizeof (struct xfs_scrub_vec_head ) + + nr *sizeof (struct xfs_scrub_vec ); +} +/* * ioctl limits */
@@ -839,6 +875,7 @@ struct xfs_scrub_metadata {#define XFS_IOC_FREE_EOFBLOCKS _IOR ('X', 58, struct xfs_fs_eofblocks)/* XFS_IOC_GETFSMAP ------ hoisted 59 */ #define XFS_IOC_SCRUB_METADATA _IOWR('X', 60, struct xfs_scrub_metadata) +#define XFS_IOC_SCRUBV_METADATA _IOWR('X', 60, struct xfs_scrub_vec_head)#define XFS_IOC_AG_GEOMETRY _IOWR('X', 61, struct xfs_ag_geometry)#define XFS_IOC_RTGROUP_GEOMETRY _IOWR('X', 62, struct xfs_rtgroup_geometry)
PATCH 3/11 libfrog: support vectored scrub
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Enhance libfrog to support performing vectored metadata scrub.
--- libfrog/fsgeom.h | 6 +++ libfrog/scrub.c | 124 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ libfrog/scrub.h | 1 3 files changed, 131 insertions(+)
libfrog/fsgeom.h +6 -0
@@ -58,6 +58,12 @@ struct xfs_fd {/* Only use FIEXCHANGE_RANGE for file data exchanges. */ #define XFROG_FLAG_FORCE_FIEXCHANGE (1 << 3) +/* Only use the older one-at-a-time scrub ioctl. */ +#define XFROG_FLAG_SCRUB_FORCE_SINGLE (1 << 4) + +/* Only use the vectored scrub ioctl. */ +#define XFROG_FLAG_SCRUB_FORCE_VECTOR (1 << 5) +/* Static initializers */ #define XFS_FD_INIT (_fd) { .fd = (_fd), }#define XFS_FD_INIT_EMPTY XFS_FD_INIT(-1)
libfrog/scrub.c +124 -0
127 lines not on this page · raw message
libfrog/scrub.h +1 -0
@@ -28,5 +28,6 @@ struct xfrog_scrub_descr {extern const struct xfrog_scrub_descr xfrog_scrubbers[XFS_SCRUB_TYPE_NR ];int xfrog_scrub_metadata (struct xfs_fd *xfd,struct xfs_scrub_metadata *meta); +int xfrog_scrubv_metadata (struct xfs_fd *xfd,struct xfs_scrub_vec_head *vhead);#endif /* __LIBFROG_SCRUB_H__ */
PATCH 4/11 xfs_io: support vectored scrub
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new scrubv command to xfs_io to support the vectored scrub ioctl.
--- io/scrub.c | 485 ++++++++++++++++++++++++++++++++++++++++++++--------- man/man8/xfs_io.8 | 47 +++++ 2 files changed, 451 insertions(+), 81 deletions(-)
io/scrub.c +404 -81
@@ -12,10 +12,13 @@#include "libfrog/paths.h" #include "libfrog/fsgeom.h" #include "libfrog/scrub.h" +#include "libfrog/logging.h" #include "io.h" +#include "list.h" static struct cmdinfo scrub_cmd;static struct cmdinfo repair_cmd; +static const struct cmdinfo scrubv_cmd;static void scrub_help (void )
@@ -42,54 +45,61 @@ scrub_help(void) }static void -scrub_ioctl ( -int fd, -int type, -uint64_t control, -uint32_t control2, -uint32_t flags) +report_scrub_outcome ( +uint32_t flags) { -struct xfs_scrub_metadata meta; -const struct xfrog_scrub_descr *sc; -int error; - - sc = &xfrog_scrubbers[type]; -memset (&meta,0 ,sizeof (meta)); - meta.sm_type = type; -switch (sc->group) { -case XFROG_SCRUB_GROUP_AGHEADER : -case XFROG_SCRUB_GROUP_PERAG : -case XFROG_SCRUB_GROUP_RTGROUP : - meta.sm_agno = control; -break ; -case XFROG_SCRUB_GROUP_INODE : - meta.sm_ino = control; - meta.sm_gen = control2; -break ; -case XFROG_SCRUB_GROUP_NONE : -case XFROG_SCRUB_GROUP_METAFILES : -case XFROG_SCRUB_GROUP_SUMMARY : -case XFROG_SCRUB_GROUP_ISCAN : -/* no control parameters */ -break ; - } - meta.sm_flags = flags; - - error =ioctl (fd,XFS_IOC_SCRUB_METADATA , &meta); -if (error) -perror ("scrub" ); -if (meta.sm_flags &XFS_SCRUB_OFLAG_CORRUPT ) +if (flags &XFS_SCRUB_OFLAG_CORRUPT )printf (_ ("Corruption detected.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_PREEN ) +if (flags &XFS_SCRUB_OFLAG_PREEN )printf (_ ("Optimization possible.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_XFAIL ) +if (flags &XFS_SCRUB_OFLAG_XFAIL )printf (_ ("Cross-referencing failed.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_XCORRUPT ) +if (flags &XFS_SCRUB_OFLAG_XCORRUPT )printf (_ ("Corruption detected during cross-referencing.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_INCOMPLETE ) +if (flags &XFS_SCRUB_OFLAG_INCOMPLETE )printf (_ ("Scan was not complete.\n" )); } +static void +scrub_ioctl ( +int fd, +int type, +uint64_t control, +uint32_t control2, +uint32_t flags) +{ +struct xfs_scrub_metadata meta; +const struct xfrog_scrub_descr *sc; +int error; + + sc = &xfrog_scrubbers[type]; +memset (&meta,0 ,sizeof (meta)); + meta.sm_type = type; +switch (sc->group) { +case XFROG_SCRUB_GROUP_AGHEADER : +case XFROG_SCRUB_GROUP_PERAG : +case XFROG_SCRUB_GROUP_RTGROUP : + meta.sm_agno = control; +break ; +case XFROG_SCRUB_GROUP_INODE : + meta.sm_ino = control; + meta.sm_gen = control2; +break ; +case XFROG_SCRUB_GROUP_NONE : +case XFROG_SCRUB_GROUP_METAFILES : +case XFROG_SCRUB_GROUP_SUMMARY : +case XFROG_SCRUB_GROUP_ISCAN : +/* no control parameters */ +break ; + } + meta.sm_flags = flags; + + error =ioctl (fd,XFS_IOC_SCRUB_METADATA , &meta); +if (error) +perror ("scrub" ); +report_scrub_outcome (meta.sm_flags); +} + static int parse_args( int argc,
@@ -223,6 +233,7 @@ scrub_init(void) scrub_cmd.help = scrub_help;add_command (&scrub_cmd); +add_command (&scrubv_cmd); } static void
@@ -252,56 +263,63 @@ repair_help(void) }static void -repair_ioctl ( -int fd, -int type, -uint64_t control, -uint32_t control2, -uint32_t flags) +report_repair_outcome ( +uint32_t flags) { -struct xfs_scrub_metadata meta; -const struct xfrog_scrub_descr *sc; -int error; - - sc = &xfrog_scrubbers[type]; -memset (&meta,0 ,sizeof (meta)); - meta.sm_type = type; -switch (sc->group) { -case XFROG_SCRUB_GROUP_AGHEADER : -case XFROG_SCRUB_GROUP_PERAG : -case XFROG_SCRUB_GROUP_RTGROUP : - meta.sm_agno = control; -break ; -case XFROG_SCRUB_GROUP_INODE : - meta.sm_ino = control; - meta.sm_gen = control2; -break ; -case XFROG_SCRUB_GROUP_NONE : -case XFROG_SCRUB_GROUP_METAFILES : -case XFROG_SCRUB_GROUP_SUMMARY : -case XFROG_SCRUB_GROUP_ISCAN : -/* no control parameters */ -break ; - } - meta.sm_flags = flags |XFS_SCRUB_IFLAG_REPAIR ; - - error =ioctl (fd,XFS_IOC_SCRUB_METADATA , &meta); -if (error) -perror ("repair" ); -if (meta.sm_flags &XFS_SCRUB_OFLAG_CORRUPT ) +if (flags &XFS_SCRUB_OFLAG_CORRUPT )printf (_ ("Corruption remains.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_PREEN ) +if (flags &XFS_SCRUB_OFLAG_PREEN )printf (_ ("Optimization possible.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_XFAIL ) +if (flags &XFS_SCRUB_OFLAG_XFAIL )printf (_ ("Cross-referencing failed.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_XCORRUPT ) +if (flags &XFS_SCRUB_OFLAG_XCORRUPT )printf (_ ("Corruption still detected during cross-referencing.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_INCOMPLETE ) +if (flags &XFS_SCRUB_OFLAG_INCOMPLETE )printf (_ ("Repair was not complete.\n" )); -if (meta.sm_flags &XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED ) +if (flags &XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED )printf (_ ("Metadata did not need repair or optimization.\n" )); } +static void +repair_ioctl ( +int fd, +int type, +uint64_t control, +uint32_t control2, +uint32_t flags) +{ +struct xfs_scrub_metadata meta; +const struct xfrog_scrub_descr *sc; +int error; + + sc = &xfrog_scrubbers[type]; +memset (&meta,0 ,sizeof (meta)); + meta.sm_type = type; +switch (sc->group) { +case XFROG_SCRUB_GROUP_AGHEADER : +case XFROG_SCRUB_GROUP_PERAG : +case XFROG_SCRUB_GROUP_RTGROUP : + meta.sm_agno = control; +break ; +case XFROG_SCRUB_GROUP_INODE : + meta.sm_ino = control; + meta.sm_gen = control2; +break ; +case XFROG_SCRUB_GROUP_NONE : +case XFROG_SCRUB_GROUP_METAFILES : +case XFROG_SCRUB_GROUP_SUMMARY : +case XFROG_SCRUB_GROUP_ISCAN : +/* no control parameters */ +break ; + } + meta.sm_flags = flags |XFS_SCRUB_IFLAG_REPAIR ; + + error =ioctl (fd,XFS_IOC_SCRUB_METADATA , &meta); +if (error) +perror ("repair" ); +report_repair_outcome (meta.sm_flags); +} + static int repair_f( int argc,
@@ -327,3 +345,308 @@ repair_init(void)add_command (&repair_cmd); } + +static void +scrubv_help (void ) +{ +printf (_ ( +"\n" +" Scrubs pieces of XFS filesystem metadata. The first argument is the group\n" +" of metadata to examine. If the group is 'ag', the second parameter should\n" +" be the AG number. If the group is 'inode', the second and third parameters\n" +" should be the inode number and generation number to act upon; if these are\n" +" omitted, the scrub is performed on the open file. If the group is 'fs',\n" +" 'summary', or 'probe', there are no other parameters.\n" +"\n" +" Flags are -d for debug, and -r to allow repairs.\n" +" -b NN will insert a scrub barrier after every NN scrubs, and -m sets the\n" +" desired corruption mask in all barriers. -w pauses for some microseconds\n" +" after each scrub call.\n" +"\n" +" Example:\n" +" 'scrubv ag 3' - scrub all metadata in AG 3.\n" +" 'scrubv ag 3 -b 2 -m 0x4' - scrub all metadata in AG 3, and use barriers\n" +" every third scrub to exit early if there are optimizations.\n" +" 'scrubv fs' - scrub all non-AG non-file metadata.\n" +" 'scrubv inode' - scrub all metadata for the open file.\n" +" 'scrubv inode 128 13525' - scrub all metadata for inode 128 gen 13525.\n" +" 'scrubv probe' - check for presence of online scrub.\n" +" 'scrubv summary' - scrub all summary metadata.\n" )); +} + +/* Fill out the scrub vectors for a group of scrubber (ag, ino, fs, summary) */ +static void +scrubv_fill_group ( +struct xfs_scrub_vec_head *vhead, +int barrier_interval, +__u32 barrier_mask, +enum xfrog_scrub_group group) +{ +const struct xfrog_scrub_descr *d; +unsigned int i; + +for (i =0 , d = xfrog_scrubbers; i <XFS_SCRUB_TYPE_NR ; i++, d++) { +if (d->group != group) +continue ; + vhead->svh_vecs[vhead->svh_nr++].sv_type = i; + +if (barrier_interval && + vhead->svh_nr % (barrier_interval +1 ) ==0 ) { +struct xfs_scrub_vec *v; + + v = &vhead->svh_vecs[vhead->svh_nr++]; + v->sv_flags = barrier_mask; + v->sv_type =XFS_SCRUB_TYPE_BARRIER ; + } + } +} + +/* Declare a structure big enough to handle all scrub types + barriers */ +struct scrubv_head { +struct xfs_scrub_vec_head head; +struct xfs_scrub_vec __vecs[XFS_SCRUB_TYPE_NR *2 ]; +}; + + +static int +scrubv_f ( +int argc, +char **argv) +{ +struct scrubv_head bighead = { }; +struct xfs_fd xfd =XFS_FD_INIT (file->fd); +struct xfs_scrub_vec_head *vhead = &bighead.head; +struct xfs_scrub_vec *v; +char *p; +uint32_t flags =0 ; +__u32 barrier_mask =XFS_SCRUB_OFLAG_CORRUPT ; +enum xfrog_scrub_group group; +bool debug = false; +int version =-1 ; +int barrier_interval =0 ; +int rest_us =0 ; +int c; +int error; + +while ((c =getopt (argc, argv,"b:dm:rv:w:" )) !=EOF ) { +switch (c) { +case 'b' : + barrier_interval =atoi (optarg); +if (barrier_interval <0 ) { +printf ( +_ ("Negative barrier interval makes no sense.\n" )); +return 0 ; + } +break ; +case 'd' : + debug = true; +break ; +case 'm' : + barrier_mask =strtoul (optarg,NULL ,0 ); +break ; +case 'r' : + flags |=XFS_SCRUB_IFLAG_REPAIR ; +break ; +case 'v' : + version =atoi (optarg); +if (version !=0 && version !=1 ) { +printf (_ ("API version must be 0 or 1.\n" )); +return 0 ; + } +break ; +case 'w' : + rest_us =atoi (optarg); +if (rest_us <0 ) { +printf (_ ("Rest time must be positive.\n" )); +return 0 ; + } +break ; +default : +scrubv_help (); +return 0 ; + } + } +if (optind > argc -1 ) { +scrubv_help (); +return 0 ; + } + +if ((flags &XFS_SCRUB_IFLAG_REPAIR ) && !expert) { +printf (_ ("Repair flag requires expert mode.\n" )); +return 1 ; + } + + vhead->svh_rest_us = rest_us; +for (c =0 , v = vhead->svh_vecs; c < vhead->svh_nr; c++, v++) + v->sv_flags = flags; + +/* Extract group and domain information from cmdline. */ +if (!strcmp (argv[optind],"probe" )) + group =XFROG_SCRUB_GROUP_NONE ; +else if (!strcmp (argv[optind],"agheader" )) + group =XFROG_SCRUB_GROUP_AGHEADER ; +else if (!strcmp (argv[optind],"ag" )) + group =XFROG_SCRUB_GROUP_PERAG ; +else if (!strcmp (argv[optind],"metafiles" )) + group =XFROG_SCRUB_GROUP_METAFILES ; +else if (!strcmp (argv[optind],"inode" )) + group =XFROG_SCRUB_GROUP_INODE ; +else if (!strcmp (argv[optind],"iscan" )) + group =XFROG_SCRUB_GROUP_ISCAN ; +else if (!strcmp (argv[optind],"summary" )) + group =XFROG_SCRUB_GROUP_SUMMARY ; +else if (!strcmp (argv[optind],"rtgroup" )) + group =XFROG_SCRUB_GROUP_RTGROUP ; +else { +printf (_ ("Unknown group '%s'.\n" ), argv[optind]); +scrubv_help (); +return 0 ; + } + optind++; + +switch (group) { +case XFROG_SCRUB_GROUP_INODE : +if (optind == argc) { + vhead->svh_ino =0 ; + vhead->svh_gen =0 ; + }else if (optind == argc -2 ) { + vhead->svh_ino =strtoull (argv[optind], &p,0 ); +if (*p !='\0' ) { +fprintf (stderr, +_ ("Bad inode number '%s'.\n" ), + argv[optind]); +return 0 ; + } + vhead->svh_gen =strtoul (argv[optind +1 ], &p,0 ); +if (*p !='\0' ) { +fprintf (stderr, +_ ("Bad generation number '%s'.\n" ), + argv[optind +1 ]); +return 0 ; + } + }else { +fprintf (stderr, +_ ("Must specify inode number and generation.\n" )); +return 0 ; + } +break ; +case XFROG_SCRUB_GROUP_AGHEADER : +case XFROG_SCRUB_GROUP_PERAG : +if (optind != argc -1 ) { +fprintf (stderr, +_ ("Must specify one AG number.\n" )); +return 0 ; + } + vhead->svh_agno =strtoul (argv[optind], &p,0 ); +if (*p !='\0' ) { +fprintf (stderr, +_ ("Bad AG number '%s'.\n" ), argv[optind]); +return 0 ; + } +break ; +case XFROG_SCRUB_GROUP_METAFILES : +case XFROG_SCRUB_GROUP_SUMMARY : +case XFROG_SCRUB_GROUP_ISCAN : +case XFROG_SCRUB_GROUP_NONE : +if (optind != argc) { +fprintf (stderr, +_ ("No parameters allowed.\n" )); +return 0 ; + } +break ; +case XFROG_SCRUB_GROUP_RTGROUP : +if (optind != argc -1 ) { +fprintf (stderr, +_ ("Must specify one rtgroup number.\n" )); +return 0 ; + } + vhead->svh_agno =strtoul (argv[optind], &p,0 ); +if (*p !='\0' ) { +fprintf (stderr, +_ ("Bad rtgroup number '%s'.\n" ), argv[optind]); +return 0 ; + } +break ; +default : +ASSERT (0 ); +break ; + } +scrubv_fill_group (vhead, barrier_interval, barrier_mask, group); +assert (vhead->svh_nr <ARRAY_SIZE (bighead.__vecs)); + + error = -xfd_prepare_geometry (&xfd); +if (error) { +xfrog_perror (error,"xfd_prepare_geometry" ); + exitcode =1 ; +return 0 ; + } + +switch (version) { +case 0 : + xfd.flags |=XFROG_FLAG_SCRUB_FORCE_SINGLE ; +break ; +case 1 : + xfd.flags |=XFROG_FLAG_SCRUB_FORCE_VECTOR ; +break ; +default : +break ; + } + + error = -xfrog_scrubv_metadata (&xfd, vhead); +if (error) { +xfrog_perror (error,"xfrog_scrub_many" ); + exitcode =1 ; +return 0 ; + } + +/* Figure out what happened. */ +for (c =0 , v = vhead->svh_vecs; debug && c < vhead->svh_nr; c++, v++) { +const char *type; + +if (v->sv_type ==XFS_SCRUB_TYPE_BARRIER ) + type =_ ("barrier" ); +else + type =_ (xfrog_scrubbers[v->sv_type].descr); +printf (_ ("[%02u] %-25s: flags 0x%x ret %d\n" ), c, type, + v->sv_flags, v->sv_ret); + } + +/* Figure out what happened. */ +for (c =0 , v = vhead->svh_vecs; c < vhead->svh_nr; c++, v++) { +/* Report barrier failures. */ +if (v->sv_type ==XFS_SCRUB_TYPE_BARRIER ) { +if (v->sv_ret) { +printf (_ ("barrier: FAILED\n" )); +break ; + } +continue ; + } + +printf ("%s: " ,_ (xfrog_scrubbers[v->sv_type].descr)); +switch (v->sv_ret) { +case 0 : +break ; +default : +printf ("%s\n" ,strerror (-v->sv_ret)); +continue ; + } +if (!(v->sv_flags &XFS_SCRUB_FLAGS_OUT )) +printf (_ ("OK.\n" )); +else if (v->sv_flags &XFS_SCRUB_IFLAG_REPAIR ) +report_repair_outcome (v->sv_flags); +else +report_scrub_outcome (v->sv_flags); + } + +return 0 ; +} + +static const struct cmdinfo scrubv_cmd = { + .name ="scrubv" , + .cfunc = scrubv_f, + .argmin =1 , + .argmax =-1 , + .flags =CMD_NOMAP_OK , + .oneline =N_ ("vectored metadata scrub" ), + .help = scrubv_help, +};
man/man8/xfs_io.8 +47 -0
53 lines not on this page · raw message
PATCH 5/11 xfs_scrub: split the scrub epilogue code into a separate function
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move all the code that updates the internal state in response to a scrub ioctl() call completion into a separate function. This will help with vectorizing scrub calls later on.
--- scrub/scrub.c | 52 ++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 38 insertions(+), 14 deletions(-)
scrub/scrub.c +38 -14
@@ -22,6 +22,10 @@#include "descr.h" #include "scrub_private.h" +static int scrub_epilogue (struct scrub_ctx *ctx,struct descr *dsc, +struct scrub_item *sri,struct xfs_scrub_metadata *meta, +int error); +/* Online scrub and repair wrappers. */ /* Format a scrub description. */
@@ -121,12 +125,32 @@ xfs_check_metadata(dbg_printf ("check %s flags %xh\n" ,descr_render (&dsc), meta.sm_flags); error = -xfrog_scrub_metadata (xfdp, &meta); +return scrub_epilogue (ctx, &dsc, sri, &meta, error); +} + +/* +* Update all internal state after a scrub ioctl call. +* Returns 0 for success, or ECANCELED to abort the program. +*/ +static int +scrub_epilogue ( +struct scrub_ctx *ctx, +struct descr *dsc, +struct scrub_item *sri, +struct xfs_scrub_metadata *meta, +int error) +{ +unsigned int scrub_type = meta->sm_type; +enum xfrog_scrub_group group; + + group = xfrog_scrubbers[scrub_type].group; +switch (error) {case 0 :/* No operational errors encountered. */ if (!sri->sri_revalidate &&debug_tweak_on ("XFS_SCRUB_FORCE_REPAIR" )) - meta.sm_flags |=XFS_SCRUB_OFLAG_CORRUPT ; + meta->sm_flags |=XFS_SCRUB_OFLAG_CORRUPT ;break ;case ENOENT :/* Metadata not present, just skip it. */
@@ -134,13 +158,13 @@ xfs_check_metadata(return 0 ;case ESHUTDOWN :/* FS already crashed, give up. */ -str_error (ctx,descr_render (&dsc), +str_error (ctx,descr_render (dsc),_ ("Filesystem is shut down, aborting." ));return ECANCELED ;case EIO :case ENOMEM :/* Abort on I/O errors or insufficient memory. */ -str_liberror (ctx, error,descr_render (&dsc)); +str_liberror (ctx, error,descr_render (dsc));return ECANCELED ;case EDEADLOCK :case EBUSY :
@@ -156,7 +180,7 @@ _("Filesystem is shut down, aborting."));return 0 ;default :/* Operational error. Log it and move on. */ -str_liberror (ctx, error,descr_render (&dsc)); +str_liberror (ctx, error,descr_render (dsc));scrub_item_clean_state (sri, scrub_type);return 0 ; }
@@ -167,27 +191,27 @@ _("Filesystem is shut down, aborting."));* we'll try the scan again, just in case the fs was busy. * Only retry so many times. */ -if (want_retry (&meta) &&scrub_item_schedule_retry (sri, scrub_type)) +if (want_retry (meta) &&scrub_item_schedule_retry (sri, scrub_type))return 0 ;/* Complain about incomplete or suspicious metadata. */ -scrub_warn_incomplete_scrub (ctx, &dsc, &meta); +scrub_warn_incomplete_scrub (ctx, dsc, meta);/* * If we need repairs or there were discrepancies, schedule a * repair if desired, otherwise complain. */ -if (is_corrupt (&meta) ||xref_disagrees (&meta)) { +if (is_corrupt (meta) ||xref_disagrees (meta)) {if (ctx->mode !=SCRUB_MODE_REPAIR ) {/* Dry-run mode, so log an error and forget it. */ -str_corrupt (ctx,descr_render (&dsc), +str_corrupt (ctx,descr_render (dsc),_ ("Repairs are required." ));scrub_item_clean_state (sri, scrub_type);return 0 ; }/* Schedule repairs. */ -scrub_item_save_state (sri, scrub_type, meta.sm_flags); +scrub_item_save_state (sri, scrub_type, meta->sm_flags);return 0 ; }
@@ -195,12 +219,12 @@ _("Repairs are required."));* If we could optimize, schedule a repair if desired, * otherwise complain. */ -if (is_unoptimized (&meta)) { +if (is_unoptimized (meta)) {if (ctx->mode ==SCRUB_MODE_DRY_RUN ) {/* Dry-run mode, so log an error and forget it. */ if (group !=XFROG_SCRUB_GROUP_INODE ) {/* AG or FS metadata, always warn. */ -str_info (ctx,descr_render (&dsc), +str_info (ctx,descr_render (dsc),_ ("Optimization is possible." )); }else if (!ctx->preen_triggers[scrub_type]) {/* File metadata, only warn once per type. */
@@ -214,7 +238,7 @@ _("Optimization is possible.")); }/* Schedule optimizations. */ -scrub_item_save_state (sri, scrub_type, meta.sm_flags); +scrub_item_save_state (sri, scrub_type, meta->sm_flags);return 0 ; }
@@ -225,8 +249,8 @@ _("Optimization is possible."));* re-examine the object as repairs progress to see if the kernel will * deem it completely consistent at some point. */ -if (xref_failed (&meta) && ctx->mode ==SCRUB_MODE_REPAIR ) { -scrub_item_save_state (sri, scrub_type, meta.sm_flags); +if (xref_failed (meta) && ctx->mode ==SCRUB_MODE_REPAIR ) { +scrub_item_save_state (sri, scrub_type, meta->sm_flags);return 0 ; }
PATCH 6/11 xfs_scrub: split the repair epilogue code into a separate function
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Move all the code that updates the internal state in response to a repair ioctl() call completion into a separate function. This will help with vectorizing repair calls later on.
--- scrub/repair.c | 61 ++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 41 insertions(+), 20 deletions(-)
scrub/repair.c +41 -20
@@ -20,6 +20,11 @@#include "descr.h" #include "scrub_private.h" +static int repair_epilogue (struct scrub_ctx *ctx,struct descr *dsc, +struct scrub_item *sri,unsigned int repair_flags, +struct xfs_scrub_metadata *oldm, +struct xfs_scrub_metadata *meta,int error); +/* General repair routines. */ /*
@@ -142,6 +147,22 @@ xfs_repair_metadata( _("Attempting optimization.")); error = -xfrog_scrub_metadata (xfdp, &meta); +return repair_epilogue (ctx, &dsc, sri, repair_flags, &oldm, &meta, + error); +} + +static int +repair_epilogue ( +struct scrub_ctx *ctx, +struct descr *dsc, +struct scrub_item *sri, +unsigned int repair_flags, +struct xfs_scrub_metadata *oldm, +struct xfs_scrub_metadata *meta, +int error) +{ +unsigned int scrub_type = meta->sm_type; +switch (error) {case 0 :/* No operational errors encountered. */
@@ -150,12 +171,12 @@ xfs_repair_metadata(case EBUSY :/* Filesystem is busy, try again later. */ if (debug || verbose) -str_info (ctx,descr_render (&dsc), +str_info (ctx,descr_render (dsc),_ ("Filesystem is busy, deferring repair." ));return 0 ;case ESHUTDOWN :/* Filesystem is already shut down, abort. */ -str_error (ctx,descr_render (&dsc), +str_error (ctx,descr_render (dsc),_ ("Filesystem is shut down, aborting." ));return ECANCELED ;case ENOTTY :
@@ -174,7 +195,7 @@ _("Filesystem is shut down, aborting."));* If we forced repairs or this is a preen, don't * error out if the kernel doesn't know how to fix. */ -if (is_unoptimized (&oldm) || +if (is_unoptimized (oldm) ||debug_tweak_on ("XFS_SCRUB_FORCE_REPAIR" )) {scrub_item_clean_state (sri, scrub_type);return 0 ;
@@ -182,14 +203,14 @@ _("Filesystem is shut down, aborting.")); fallthrough;case EINVAL :/* Kernel doesn't know how to repair this? */ -str_corrupt (ctx,descr_render (&dsc), +str_corrupt (ctx,descr_render (dsc),_ ("Don't know how to fix; offline repair required." ));scrub_item_clean_state (sri, scrub_type);return 0 ;case EROFS :/* Read-only filesystem, can't fix. */ -if (verbose || debug ||needs_repair (&oldm)) -str_error (ctx,descr_render (&dsc), +if (verbose || debug ||needs_repair (oldm)) +str_error (ctx,descr_render (dsc),_ ("Read-only filesystem; cannot make changes." ));return ECANCELED ;case ENOENT :
@@ -199,7 +220,7 @@ _("Read-only filesystem; cannot make changes."));case ENOMEM :case ENOSPC :/* Don't care if preen fails due to low resources. */ -if (is_unoptimized (&oldm) && !needs_repair (&oldm)) { +if (is_unoptimized (oldm) && !needs_repair (oldm)) {scrub_item_clean_state (sri, scrub_type);return 0 ; }
@@ -214,7 +235,7 @@ _("Read-only filesystem; cannot make changes."));*/ if (!(repair_flags &XRM_FINAL_WARNING ))return 0 ; -str_liberror (ctx, error,descr_render (&dsc)); +str_liberror (ctx, error,descr_render (dsc));scrub_item_clean_state (sri, scrub_type);return 0 ; }
@@ -225,12 +246,12 @@ _("Read-only filesystem; cannot make changes."));* the repair again, just in case the fs was busy. Only retry so many * times. */ -if (want_retry (&meta) &&scrub_item_schedule_retry (sri, scrub_type)) +if (want_retry (meta) &&scrub_item_schedule_retry (sri, scrub_type))return 0 ;if (repair_flags &XRM_FINAL_WARNING ) -scrub_warn_incomplete_scrub (ctx, &dsc, &meta); -if (needs_repair (&meta) ||is_incomplete (&meta)) { +scrub_warn_incomplete_scrub (ctx, dsc, meta); +if (needs_repair (meta) ||is_incomplete (meta)) {/* * Still broken; if we've been told not to complain then we * just requeue this and try again later. Otherwise we
@@ -238,9 +259,9 @@ _("Read-only filesystem; cannot make changes."));*/ if (!(repair_flags &XRM_FINAL_WARNING ))return 0 ; -str_corrupt (ctx,descr_render (&dsc), +str_corrupt (ctx,descr_render (dsc),_ ("Repair unsuccessful; offline repair required." )); - }else if (xref_failed (&meta)) { + }else if (xref_failed (meta)) {/* * This metadata object itself looks ok, but we still noticed * inconsistencies when comparing it with the other filesystem
@@ -249,25 +270,25 @@ _("Read-only filesystem; cannot make changes."));* reverify the cross-referencing as repairs progress. */ if (repair_flags &XRM_FINAL_WARNING ) { -str_info (ctx,descr_render (&dsc), +str_info (ctx,descr_render (dsc),_ ("Seems correct but cross-referencing failed; offline repair recommended." )); }else {if (verbose) -str_info (ctx,descr_render (&dsc), +str_info (ctx,descr_render (dsc),_ ("Seems correct but cross-referencing failed; will keep checking." ));return 0 ; } - }else if (meta.sm_flags &XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED ) { + }else if (meta->sm_flags &XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED ) {if (verbose) -str_info (ctx,descr_render (&dsc), +str_info (ctx,descr_render (dsc),_ ("No modification needed." )); }else {/* Clean operation, no corruption detected. */ -if (needs_repair (&oldm)) -record_repair (ctx,descr_render (&dsc), +if (needs_repair (oldm)) +record_repair (ctx,descr_render (dsc),_ ("Repairs successful." ));else -record_preen (ctx,descr_render (&dsc), +record_preen (ctx,descr_render (dsc),_ ("Optimization successful." )); }
PATCH 7/11 xfs_scrub: convert scrub and repair epilogues to use xfs_scrub_vec
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Convert the scrub and repair epilogue code to pass around xfs_scrub_vecs as we prepare for vectorized operation.
--- scrub/repair.c | 35 ++++++++++++++++++----------------- scrub/scrub.c | 27 ++++++++++++++------------- scrub/scrub_private.h | 34 +++++++++++++++++----------------- 3 files changed, 49 insertions(+), 47 deletions(-)
scrub/repair.c +18 -17
@@ -22,8 +22,8 @@static int repair_epilogue (struct scrub_ctx *ctx,struct descr *dsc,struct scrub_item *sri,unsigned int repair_flags, -struct xfs_scrub_metadata *oldm, -struct xfs_scrub_metadata *meta,int error); +const struct xfs_scrub_vec *oldm, +const struct xfs_scrub_vec *meta);/* General repair routines. */
@@ -101,10 +101,9 @@ xfs_repair_metadata( unsigned int repair_flags) {struct xfs_scrub_metadata meta = {0 }; -struct xfs_scrub_metadata oldm; +struct xfs_scrub_vec oldm, vec;DEFINE_DESCR (dsc, ctx, format_scrub_descr);bool repair_only; -int error;/* * If the caller boosted the priority of this scrub type on behalf of a
@@ -133,22 +132,24 @@ xfs_repair_metadata(break ; } -if (!is_corrupt (&meta) && repair_only) + vec.sv_type = scrub_type; + vec.sv_flags = sri->sri_state[scrub_type] &SCRUB_ITEM_REPAIR_ANY ; +memcpy (&oldm, &vec,sizeof (struct xfs_scrub_vec )); +if (!is_corrupt (&vec) && repair_only)return 0 ; -memcpy (&oldm, &meta,sizeof (oldm)); - oldm.sm_flags = sri->sri_state[scrub_type] &SCRUB_ITEM_REPAIR_ANY ; -descr_set (&dsc, &oldm); +descr_set (&dsc, &meta); -if (needs_repair (&oldm)) +if (needs_repair (&vec))str_info (ctx,descr_render (&dsc),_ ("Attempting repair." ));else if (debug || verbose)str_info (ctx,descr_render (&dsc),_ ("Attempting optimization." )); - error = -xfrog_scrub_metadata (xfdp, &meta); -return repair_epilogue (ctx, &dsc, sri, repair_flags, &oldm, &meta, - error); + vec.sv_ret =xfrog_scrub_metadata (xfdp, &meta); + vec.sv_flags = meta.sm_flags; + +return repair_epilogue (ctx, &dsc, sri, repair_flags, &oldm, &vec); } static int
@@ -157,11 +158,11 @@ repair_epilogue(struct descr *dsc, struct scrub_item *sri, unsigned int repair_flags, - struct xfs_scrub_metadata *oldm, - struct xfs_scrub_metadata *meta, - int error) + const struct xfs_scrub_vec *oldm, + const struct xfs_scrub_vec *meta) { - unsigned int scrub_type = meta->sm_type; + unsigned int scrub_type = meta->sv_type; +int error = -meta->sv_ret;switch (error) {case 0 :
@@ -278,7 +279,7 @@ _("Read-only filesystem; cannot make changes.")); _("Seems correct but cross-referencing failed; will keep checking."));return 0 ; } - }else if (meta->sm_flags &XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED ) { + }else if (meta->sv_flags &XFS_SCRUB_OFLAG_NO_REPAIR_NEEDED ) {if (verbose)str_info (ctx,descr_render (dsc),_ ("No modification needed." ));
scrub/scrub.c +14 -13
@@ -23,8 +23,7 @@#include "scrub_private.h" static int scrub_epilogue (struct scrub_ctx *ctx,struct descr *dsc, -struct scrub_item *sri,struct xfs_scrub_metadata *meta, -int error); +struct scrub_item *sri,struct xfs_scrub_vec *vec);/* Online scrub and repair wrappers. */
@@ -65,7 +64,7 @@ void scrub_warn_incomplete_scrub( struct scrub_ctx *ctx, struct descr *dsc, - struct xfs_scrub_metadata *meta) + const struct xfs_scrub_vec *meta) { if (is_incomplete(meta)) str_info(ctx, descr_render(dsc), _("Check incomplete."));
@@ -94,8 +93,8 @@ xfs_check_metadata( {DEFINE_DESCR (dsc, ctx, format_scrub_descr);struct xfs_scrub_metadata meta = { }; +struct xfs_scrub_vec vec;enum xfrog_scrub_group group; -int error;background_sleep ();
@@ -124,8 +123,10 @@ xfs_check_metadata(dbg_printf ("check %s flags %xh\n" ,descr_render (&dsc), meta.sm_flags); - error = -xfrog_scrub_metadata (xfdp, &meta); -return scrub_epilogue (ctx, &dsc, sri, &meta, error); + vec.sv_ret =xfrog_scrub_metadata (xfdp, &meta); + vec.sv_type = scrub_type; + vec.sv_flags = meta.sm_flags; +return scrub_epilogue (ctx, &dsc, sri, &vec); }/*
@@ -137,11 +138,11 @@ scrub_epilogue(struct scrub_ctx *ctx, struct descr *dsc, struct scrub_item *sri, - struct xfs_scrub_metadata *meta, - int error) + struct xfs_scrub_vec *meta) { - unsigned int scrub_type = meta->sm_type; + unsigned int scrub_type = meta->sv_type;enum xfrog_scrub_group group; +int error = -meta->sv_ret; group = xfrog_scrubbers[scrub_type].group;
@@ -150,7 +151,7 @@ scrub_epilogue(/* No operational errors encountered. */ if (!sri->sri_revalidate &&debug_tweak_on ("XFS_SCRUB_FORCE_REPAIR" )) - meta->sm_flags |=XFS_SCRUB_OFLAG_CORRUPT ; + meta->sv_flags |=XFS_SCRUB_OFLAG_CORRUPT ;break ;case ENOENT :/* Metadata not present, just skip it. */
@@ -211,7 +212,7 @@ _("Repairs are required.")); }/* Schedule repairs. */ -scrub_item_save_state (sri, scrub_type, meta->sm_flags); +scrub_item_save_state (sri, scrub_type, meta->sv_flags);return 0 ; }
@@ -238,7 +239,7 @@ _("Optimization is possible.")); }/* Schedule optimizations. */ -scrub_item_save_state (sri, scrub_type, meta->sm_flags); +scrub_item_save_state (sri, scrub_type, meta->sv_flags);return 0 ; }
@@ -250,7 +251,7 @@ _("Optimization is possible."));* deem it completely consistent at some point. */ if (xref_failed (meta) && ctx->mode ==SCRUB_MODE_REPAIR ) { -scrub_item_save_state (sri, scrub_type, meta->sm_flags); +scrub_item_save_state (sri, scrub_type, meta->sv_flags);return 0 ; }
scrub/scrub_private.h +17 -17
@@ -13,40 +13,40 @@ int format_scrub_descr(struct scrub_ctx *ctx, char *buf, size_t buflen,/* Predicates for scrub flag state. */ -static inline bool is_corrupt (struct xfs_scrub_metadata *sm) +static inline bool is_corrupt (const struct xfs_scrub_vec *sv) { -return sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT ; +return sv->sv_flags &XFS_SCRUB_OFLAG_CORRUPT ; } -static inline bool is_unoptimized (struct xfs_scrub_metadata *sm) +static inline bool is_unoptimized (const struct xfs_scrub_vec *sv) { -return sm->sm_flags &XFS_SCRUB_OFLAG_PREEN ; +return sv->sv_flags &XFS_SCRUB_OFLAG_PREEN ; } -static inline bool xref_failed (struct xfs_scrub_metadata *sm) +static inline bool xref_failed (const struct xfs_scrub_vec *sv) { -return sm->sm_flags &XFS_SCRUB_OFLAG_XFAIL ; +return sv->sv_flags &XFS_SCRUB_OFLAG_XFAIL ; } -static inline bool xref_disagrees (struct xfs_scrub_metadata *sm) +static inline bool xref_disagrees (const struct xfs_scrub_vec *sv) { -return sm->sm_flags &XFS_SCRUB_OFLAG_XCORRUPT ; +return sv->sv_flags &XFS_SCRUB_OFLAG_XCORRUPT ; } -static inline bool is_incomplete (struct xfs_scrub_metadata *sm) +static inline bool is_incomplete (const struct xfs_scrub_vec *sv) { -return sm->sm_flags &XFS_SCRUB_OFLAG_INCOMPLETE ; +return sv->sv_flags &XFS_SCRUB_OFLAG_INCOMPLETE ; } -static inline bool is_suspicious (struct xfs_scrub_metadata *sm) +static inline bool is_suspicious (const struct xfs_scrub_vec *sv) { -return sm->sm_flags &XFS_SCRUB_OFLAG_WARNING ; +return sv->sv_flags &XFS_SCRUB_OFLAG_WARNING ; }/* Should we fix it? */ -static inline bool needs_repair (struct xfs_scrub_metadata *sm) +static inline bool needs_repair (const struct xfs_scrub_vec *sv) { -return is_corrupt (sm) ||xref_disagrees (sm); +return is_corrupt (sv) ||xref_disagrees (sv); }/*
@@ -54,13 +54,13 @@ static inline bool needs_repair(struct xfs_scrub_metadata *sm)* scan/repair; or if there were cross-referencing problems but the object was * not obviously corrupt. */ -static inline bool want_retry (struct xfs_scrub_metadata *sm) +static inline bool want_retry (const struct xfs_scrub_vec *sv) { -return is_incomplete (sm) || (xref_disagrees (sm) && !is_corrupt (sm)); +return is_incomplete (sv) || (xref_disagrees (sv) && !is_corrupt (sv)); }void scrub_warn_incomplete_scrub (struct scrub_ctx *ctx,struct descr *dsc, -struct xfs_scrub_metadata *meta); +const struct xfs_scrub_vec *meta);/* Scrub item functions */
PATCH 8/11 xfs_scrub: vectorize scrub calls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use the new vectorized kernel scrub calls to reduce the overhead of checking metadata.
--- scrub/phase1.c | 2 scrub/scrub.c | 265 +++++++++++++++++++++++++++++++++++-------------- scrub/scrub.h | 2 scrub/scrub_private.h | 21 ++++ 4 files changed, 216 insertions(+), 74 deletions(-)
scrub/phase1.c +2 -0
@@ -216,6 +216,8 @@ _("Kernel metadata scrubbing facility is not available."));return ECANCELED ; } +check_scrubv (ctx); +/* * Normally, callers are required to pass -n if the provided path is a * readonly filesystem or the kernel wasn't built with online repair
scrub/scrub.c +191 -74
314 lines not on this page · raw message
scrub/scrub.h +2 -0
@@ -147,6 +147,8 @@ bool can_scrub_parent(struct scrub_ctx *ctx);bool can_repair (struct scrub_ctx *ctx);bool can_force_rebuild (struct scrub_ctx *ctx); +void check_scrubv (struct scrub_ctx *ctx); +int scrub_file (struct scrub_ctx *ctx,int fd,const struct xfs_bulkstat *bstat,unsigned int type,struct scrub_item *sri);
scrub/scrub_private.h +21 -0
@@ -8,6 +8,26 @@/* Shared code between scrub.c and repair.c. */ +/* +* Declare a structure big enough to handle all scrub types + barriers, and +* an iteration pointer. So far we only need two barriers. +*/ +struct scrubv_head { +struct xfs_scrub_vec_head head; +struct xfs_scrub_vec __vecs[XFS_SCRUB_TYPE_NR +2 ]; +unsigned int i; +}; + +#define foreach_bighead_vec (bh, v) \ + for ((bh)->i = 0, (v) = (bh)->head.svh_vecs; \ + (bh)->i < (bh)->head.svh_nr; \ + (bh)->i++, (v)++) + +void scrub_item_to_vhead (struct scrubv_head *bighead, +const struct scrub_item *sri); +void scrub_vhead_add (struct scrubv_head *bighead,const struct scrub_item *sri, +unsigned int scrub_type); +int format_scrub_descr (struct scrub_ctx *ctx,char *buf,size_t buflen,void *where);
@@ -104,5 +124,6 @@ scrub_item_schedule_retry(struct scrub_item *sri, unsigned int scrub_type)bool scrub_item_call_kernel_again (struct scrub_item *sri,unsigned int scrub_type,uint8_t work_mask,const struct scrub_item *old); +bool scrub_item_schedule_work (struct scrub_item *sri,uint8_t state_flags);#endif /* XFS_SCRUB_SCRUB_PRIVATE_H_ */
PATCH 9/11 xfs_scrub: vectorize repair calls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use the new vectorized scrub kernel calls to reduce the overhead of performing repairs.
--- scrub/repair.c | 268 +++++++++++++++++++++++++++---------------------- scrub/scrub.c | 82 +++------------ scrub/scrub_private.h | 7 + 3 files changed, 166 insertions(+), 191 deletions(-)
scrub/repair.c +147 -121
@@ -20,11 +20,6 @@#include "descr.h" #include "scrub_private.h" -static int repair_epilogue (struct scrub_ctx *ctx,struct descr *dsc, -struct scrub_item *sri,unsigned int repair_flags, -const struct xfs_scrub_vec *oldm, -const struct xfs_scrub_vec *meta); -/* General repair routines. */ /*
@@ -91,65 +86,14 @@ repair_want_service_downgrade(return false; } -/* Repair some metadata. */ -static int -xfs_repair_metadata ( -struct scrub_ctx *ctx, -struct xfs_fd *xfdp, -unsigned int scrub_type, -struct scrub_item *sri, -unsigned int repair_flags) +static inline void +restore_oldvec ( +struct xfs_scrub_vec *oldvec, +const struct scrub_item *sri, +unsigned int scrub_type) { -struct xfs_scrub_metadata meta = {0 }; -struct xfs_scrub_vec oldm, vec; -DEFINE_DESCR (dsc, ctx, format_scrub_descr); -bool repair_only; - -/* -* If the caller boosted the priority of this scrub type on behalf of a -* higher level repair by setting IFLAG_REPAIR, turn off REPAIR_ONLY. -*/ - repair_only = (repair_flags &XRM_REPAIR_ONLY ) && -scrub_item_type_boosted (sri, scrub_type); - -assert (scrub_type <XFS_SCRUB_TYPE_NR ); -assert (!debug_tweak_on ("XFS_SCRUB_NO_KERNEL" )); - meta.sm_type = scrub_type; - meta.sm_flags =XFS_SCRUB_IFLAG_REPAIR ; -if (use_force_rebuild) - meta.sm_flags |=XFS_SCRUB_IFLAG_FORCE_REBUILD ; -switch (xfrog_scrubbers[scrub_type].group) { -case XFROG_SCRUB_GROUP_AGHEADER : -case XFROG_SCRUB_GROUP_PERAG : -case XFROG_SCRUB_GROUP_RTGROUP : - meta.sm_agno = sri->sri_agno; -break ; -case XFROG_SCRUB_GROUP_INODE : - meta.sm_ino = sri->sri_ino; - meta.sm_gen = sri->sri_gen; -break ; -default : -break ; - } - - vec.sv_type = scrub_type; - vec.sv_flags = sri->sri_state[scrub_type] &SCRUB_ITEM_REPAIR_ANY ; -memcpy (&oldm, &vec,sizeof (struct xfs_scrub_vec )); -if (!is_corrupt (&vec) && repair_only) -return 0 ; - -descr_set (&dsc, &meta); - -if (needs_repair (&vec)) -str_info (ctx,descr_render (&dsc),_ ("Attempting repair." )); -else if (debug || verbose) -str_info (ctx,descr_render (&dsc), -_ ("Attempting optimization." )); - - vec.sv_ret =xfrog_scrub_metadata (xfdp, &meta); - vec.sv_flags = meta.sm_flags; - -return repair_epilogue (ctx, &dsc, sri, repair_flags, &oldm, &vec); + oldvec->sv_type = scrub_type; + oldvec->sv_flags = sri->sri_state[scrub_type] &SCRUB_ITEM_REPAIR_ANY ; } static int
@@ -158,12 +102,15 @@ repair_epilogue(struct descr *dsc, struct scrub_item *sri, unsigned int repair_flags, - const struct xfs_scrub_vec *oldm, const struct xfs_scrub_vec *meta) { + struct xfs_scrub_vec oldv; +struct xfs_scrub_vec *oldm = &oldv;unsigned int scrub_type = meta->sv_type;int error = -meta->sv_ret; +restore_oldvec (oldm, sri, meta->sv_type); +switch (error) {case 0 :/* No operational errors encountered. */
@@ -297,6 +244,132 @@ _("Read-only filesystem; cannot make changes."));return 0 ; } +/* Decide if the dependent scrub types of the given scrub type are ok. */ +static bool +repair_item_dependencies_ok ( +const struct scrub_item *sri, +unsigned int scrub_type) +{ +unsigned int dep_mask = repair_deps[scrub_type]; +unsigned int b; + +for (b =0 ; dep_mask && b <XFS_SCRUB_TYPE_NR ; b++, dep_mask >>=1 ) { +if (!(dep_mask &1 )) +continue ; +/* +* If this lower level object also needs repair, we can't fix +* the higher level item. +*/ +if (sri->sri_state[b] &SCRUB_ITEM_NEEDSREPAIR ) +return false; + } + +return true; +} + +/* Decide if we want to repair a particular type of metadata. */ +static bool +can_repair_now ( +const struct scrub_item *sri, +unsigned int scrub_type, +__u32 repair_mask, +unsigned int repair_flags) +{ +struct xfs_scrub_vec oldvec; +bool repair_only; + +/* Do we even need to repair this thing? */ +if (!(sri->sri_state[scrub_type] & repair_mask)) +return false; + +restore_oldvec (&oldvec, sri, scrub_type); + +/* +* If the caller boosted the priority of this scrub type on behalf of a +* higher level repair by setting IFLAG_REPAIR, ignore REPAIR_ONLY. +*/ + repair_only = (repair_flags &XRM_REPAIR_ONLY ) && + !(sri->sri_state[scrub_type] &SCRUB_ITEM_BOOST_REPAIR ); +if (!is_corrupt (&oldvec) && repair_only) +return false; + +/* +* Don't try to repair higher level items if their lower-level +* dependencies haven't been verified, unless this is our last chance +* to fix things without complaint. +*/ +if (!(repair_flags &XRM_FINAL_WARNING ) && + !repair_item_dependencies_ok (sri, scrub_type)) +return false; + +return true; +} + +/* +* Repair some metadata. +* +* Returns 0 for success (or repair item deferral), or ECANCELED to abort the +* program. +*/ +static int +repair_call_kernel ( +struct scrub_ctx *ctx, +struct xfs_fd *xfdp, +struct scrub_item *sri, +__u32 repair_mask, +unsigned int repair_flags) +{ +DEFINE_DESCR (dsc, ctx, format_scrubv_descr); +struct scrubv_head bh = { }; +struct xfs_scrub_vec *v; +unsigned int scrub_type; +int error; + +assert (!debug_tweak_on ("XFS_SCRUB_NO_KERNEL" )); + +scrub_item_to_vhead (&bh, sri); +descr_set (&dsc, &bh); + +foreach_scrub_type (scrub_type) { +if (scrub_excessive_errors (ctx)) +return ECANCELED ; + +if (!can_repair_now (sri, scrub_type, repair_mask, + repair_flags)) +continue ; + +scrub_vhead_add (&bh, sri, scrub_type, true); + +if (sri->sri_state[scrub_type] &SCRUB_ITEM_NEEDSREPAIR ) +str_info (ctx,descr_render (&dsc), +_ ("Attempting repair." )); +else if (debug || verbose) +str_info (ctx,descr_render (&dsc), +_ ("Attempting optimization." )); + +dbg_printf ("repair %s flags %xh tries %u\n" ,descr_render (&dsc), + sri->sri_state[scrub_type], + sri->sri_tries[scrub_type]); + } + + error = -xfrog_scrubv_metadata (xfdp, &bh.head); +if (error) +return error; + + foreach_bighead_vec(&bh, v) { + error =repair_epilogue (ctx, &dsc, sri, repair_flags, v); +if (error) +return error; + +/* Maybe update progress if we fixed the problem. */ +if (!(repair_flags &XRM_NOPROGRESS ) && + !(sri->sri_state[v->sv_type] &SCRUB_ITEM_REPAIR_ANY )) +progress_add (1 ); + } + +return 0 ; +} +/* * Prioritize action items in order of how long we can wait. *
@@ -636,29 +709,6 @@ action_list_process(return ret; } -/* Decide if the dependent scrub types of the given scrub type are ok. */ -static bool -repair_item_dependencies_ok ( -const struct scrub_item *sri, -unsigned int scrub_type) -{ -unsigned int dep_mask = repair_deps[scrub_type]; -unsigned int b; - -for (b =0 ; dep_mask && b <XFS_SCRUB_TYPE_NR ; b++, dep_mask >>=1 ) { -if (!(dep_mask &1 )) -continue ; -/* -* If this lower level object also needs repair, we can't fix -* the higher level item. -*/ -if (sri->sri_state[b] &SCRUB_ITEM_NEEDSREPAIR ) -return false; - } - -return true; -} -/* * For a given filesystem object, perform all repairs of a given class * (corrupt, xcorrupt, xfail, preen) if the repair item says it's needed.
@@ -674,13 +724,14 @@ repair_item_class(struct xfs_fd xfd;struct scrub_item old_sri;struct xfs_fd *xfdp = &ctx->mnt; -unsigned int scrub_type;int error =0 ;if (ctx->mode ==SCRUB_MODE_DRY_RUN )return 0 ;if (ctx->mode ==SCRUB_MODE_PREEN && !(repair_mask &SCRUB_ITEM_PREEN ))return 0 ; +if (!scrub_item_schedule_work (sri, repair_mask)) +return 0 ;/* * If the caller passed us a file descriptor for a scrub, use it
@@ -693,39 +744,14 @@ repair_item_class( xfdp = &xfd; } -foreach_scrub_type (scrub_type) { -if (scrub_excessive_errors (ctx)) -return ECANCELED ; - -if (!(sri->sri_state[scrub_type] & repair_mask)) -continue ; - -/* -* Don't try to repair higher level items if their lower-level -* dependencies haven't been verified, unless this is our last -* chance to fix things without complaint. -*/ -if (!(flags &XRM_FINAL_WARNING ) && - !repair_item_dependencies_ok (sri, scrub_type)) -continue ; - - sri->sri_tries[scrub_type] =SCRUB_ITEM_MAX_RETRIES ; -do { -memcpy (&old_sri, sri,sizeof (old_sri)); - error =xfs_repair_metadata (ctx, xfdp, scrub_type, sri, - flags); -if (error) -return error; - }while (scrub_item_call_kernel_again (sri, scrub_type, - repair_mask, &old_sri)); - -/* Maybe update progress if we fixed the problem. */ -if (!(flags &XRM_NOPROGRESS ) && - !(sri->sri_state[scrub_type] &SCRUB_ITEM_REPAIR_ANY )) -progress_add (1 ); - } - -return error; +do { +memcpy (&old_sri, sri,sizeof (struct scrub_item )); + error =repair_call_kernel (ctx, xfdp, sri, repair_mask, flags); +if (error) +return error; + }while (scrub_item_call_kernel_again (sri, repair_mask, &old_sri)); + +return 0 ; }/*
scrub/scrub.c +16 -66
136 lines not on this page · raw message
scrub/scrub_private.h +3 -4
@@ -26,9 +26,9 @@ struct scrubv_head {void scrub_item_to_vhead (struct scrubv_head *bighead,const struct scrub_item *sri);void scrub_vhead_add (struct scrubv_head *bighead,const struct scrub_item *sri, -unsigned int scrub_type); +unsigned int scrub_type,bool repair); -int format_scrub_descr (struct scrub_ctx *ctx,char *buf,size_t buflen, +int format_scrubv_descr (struct scrub_ctx *ctx,char *buf,size_t buflen,void *where);/* Predicates for scrub flag state. */
@@ -121,8 +121,7 @@ scrub_item_schedule_retry(struct scrub_item *sri, unsigned int scrub_type)return true; } -bool scrub_item_call_kernel_again (struct scrub_item *sri, -unsigned int scrub_type,uint8_t work_mask, +bool scrub_item_call_kernel_again (struct scrub_item *sri,uint8_t work_mask,const struct scrub_item *old);bool scrub_item_schedule_work (struct scrub_item *sri,uint8_t state_flags);
PATCH 10/11 xfs_scrub: use scrub barriers to reduce kernel calls
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Use scrub barriers so that we can submit a single scrub request for a bunch of things, and have the kernel stop midway through if it finds anything broken.
--- scrub/phase2.c | 15 ++------- scrub/phase3.c | 17 +--------- scrub/repair.c | 32 ++++++++++++++++++- scrub/scrub.c | 81 ++++++++++++++++++++++++++++++++++++++++++++++++- scrub/scrub.h | 17 ++++++++++ scrub/scrub_private.h | 4 ++ 6 files changed, 134 insertions(+), 32 deletions(-)
scrub/phase2.c +3 -12
@@ -99,21 +99,12 @@ scan_ag_metadata(snprintf (descr,DESCR_BUFSZ ,_ ("AG %u" ), agno);/* -* First we scrub and fix the AG headers, because we need -* them to work well enough to check the AG btrees. +* First we scrub and fix the AG headers, because we need them to work +* well enough to check the AG btrees. Then scrub the AG btrees. */ scrub_item_schedule_group (&sri,XFROG_SCRUB_GROUP_AGHEADER ); - ret =scrub_item_check (ctx, &sri); -if (ret) - goto err; - -/* Repair header damage. */ - ret =repair_item_corruption (ctx, &sri); -if (ret) - goto err; - -/* Now scrub the AG btrees. */ scrub_item_schedule_group (&sri,XFROG_SCRUB_GROUP_PERAG ); + ret =scrub_item_check (ctx, &sri);if (ret) goto err;
scrub/phase3.c +2 -15
@@ -145,25 +145,11 @@ scrub_inode(/* Scrub the inode. */ scrub_item_schedule (&sri,XFS_SCRUB_TYPE_INODE ); - error =scrub_item_check_file (ctx, &sri, fd); -if (error) - goto out; - - error =try_inode_repair (ictx, &sri, fd); -if (error) - goto out;/* Scrub all block mappings. */ scrub_item_schedule (&sri,XFS_SCRUB_TYPE_BMBTD );scrub_item_schedule (&sri,XFS_SCRUB_TYPE_BMBTA );scrub_item_schedule (&sri,XFS_SCRUB_TYPE_BMBTC ); - error =scrub_item_check_file (ctx, &sri, fd); -if (error) - goto out; - - error =try_inode_repair (ictx, &sri, fd); -if (error) - goto out;/* Check everything accessible via file mapping. */ if (S_ISLNK (bstat->bs_mode))
@@ -173,11 +159,12 @@ scrub_inode(scrub_item_schedule (&sri,XFS_SCRUB_TYPE_XATTR );scrub_item_schedule (&sri,XFS_SCRUB_TYPE_PARENT ); + +/* Try to check and repair the file while it's open. */ error =scrub_item_check_file (ctx, &sri, fd);if (error) goto out; -/* Try to repair the file while it's open. */ error =try_inode_repair (ictx, &sri, fd);if (error) goto out;
scrub/repair.c +30 -2
@@ -323,6 +323,7 @@ repair_call_kernel(struct scrubv_head bh = { };struct xfs_scrub_vec *v;unsigned int scrub_type; +bool need_barrier = false;int error;assert (!debug_tweak_on ("XFS_SCRUB_NO_KERNEL" ));
@@ -338,6 +339,11 @@ repair_call_kernel( repair_flags))continue ; +if (need_barrier) { +scrub_vhead_add_barrier (&bh); + need_barrier = false; + } +scrub_vhead_add (&bh, sri, scrub_type, true);if (sri->sri_state[scrub_type] &SCRUB_ITEM_NEEDSREPAIR )
@@ -350,6 +356,17 @@ repair_call_kernel(dbg_printf ("repair %s flags %xh tries %u\n" ,descr_render (&dsc), sri->sri_state[scrub_type], sri->sri_tries[scrub_type]); + +/* +* One of the other scrub types depends on this one. Set us up +* to add a repair barrier if we decide to schedule a repair +* after this one. If the UNFIXED flag is set, that means this +* is our last chance to fix things, so we skip the barriers +* just let everything run. +*/ +if (!(repair_flags &XRM_FINAL_WARNING ) && + (sri->sri_state[scrub_type] &SCRUB_ITEM_BARRIER )) + need_barrier = true; } error = -xfrog_scrubv_metadata (xfdp, &bh.head);
@@ -357,6 +374,16 @@ repair_call_kernel(return error; foreach_bighead_vec(&bh, v) { +/* Deal with barriers separately. */ +if (v->sv_type ==XFS_SCRUB_TYPE_BARRIER ) { +/* -ECANCELED means the kernel stopped here. */ +if (v->sv_ret == -ECANCELED ) +return 0 ; +if (v->sv_ret) +return -v->sv_ret; +continue ; + } + error =repair_epilogue (ctx, &dsc, sri, repair_flags, v);if (error)return error;
@@ -445,7 +472,8 @@ repair_item_boost_priorities(* bits are left untouched to force a rescan in phase 4. */ #define MUSTFIX_STATES (SCRUB_ITEM_CORRUPT | \ - SCRUB_ITEM_BOOST_REPAIR) + SCRUB_ITEM_BOOST_REPAIR | \ + SCRUB_ITEM_BARRIER)/* * Figure out which AG metadata must be fixed before we can move on * to the inode scan.
@@ -730,7 +758,7 @@ repair_item_class(return 0 ;if (ctx->mode ==SCRUB_MODE_PREEN && !(repair_mask &SCRUB_ITEM_PREEN ))return 0 ; -if (!scrub_item_schedule_work (sri, repair_mask)) +if (!scrub_item_schedule_work (sri, repair_mask, repair_deps))return 0 ;/*
scrub/scrub.c +79 -2
139 lines not on this page · raw message
scrub/scrub.h +17 -0
@@ -30,6 +30,9 @@ enum xfrog_scrub_group;/* This scrub type needs to be checked. */ #define SCRUB_ITEM_NEEDSCHECK (1 << 5) +/* Scrub barrier. */ +#define SCRUB_ITEM_BARRIER (1 << 6) +/* All of the state flags that we need to prioritize repair work. */ #define SCRUB_ITEM_REPAIR_ANY (SCRUB_ITEM_CORRUPT | \ SCRUB_ITEM_PREEN | \
@@ -135,6 +138,20 @@ scrub_item_check(struct scrub_ctx *ctx, struct scrub_item *sri)return scrub_item_check_file (ctx, sri,-1 ); } +/* Count the number of metadata objects still needing a scrub. */ +static inline unsigned int +scrub_item_count_needscheck ( +const struct scrub_item *sri) +{ +unsigned int ret =0 ; +unsigned int i; + + foreach_scrub_type(i) + if (sri->sri_state[i] & SCRUB_ITEM_NEEDSCHECK) + ret++; +return ret; +} +void scrub_report_preen_triggers (struct scrub_ctx *ctx);bool can_scrub_fs_metadata (struct scrub_ctx *ctx);
scrub/scrub_private.h +3 -1
@@ -27,6 +27,7 @@ void scrub_item_to_vhead(struct scrubv_head *bighead, const struct scrub_item *sri);void scrub_vhead_add (struct scrubv_head *bighead,const struct scrub_item *sri,unsigned int scrub_type,bool repair); +void scrub_vhead_add_barrier (struct scrubv_head *bighead);int format_scrubv_descr (struct scrub_ctx *ctx,char *buf,size_t buflen,void *where);
@@ -123,6 +124,7 @@ scrub_item_schedule_retry(struct scrub_item *sri, unsigned int scrub_type)bool scrub_item_call_kernel_again (struct scrub_item *sri,uint8_t work_mask,const struct scrub_item *old); -bool scrub_item_schedule_work (struct scrub_item *sri,uint8_t state_flags); +bool scrub_item_schedule_work (struct scrub_item *sri,uint8_t state_flags, +const unsigned int *schedule_deps);#endif /* XFS_SCRUB_SCRUB_PRIVATE_H_ */
PATCH 11/11 xfs_scrub: try spot repairs of metadata items to make scrub progress
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that we've enabled scrub dependency barriers, it's possible that a scrub_item_check call will return with some of the scrub items still in NEEDSCHECK state. If, for example, scrub type B depends on scrub type A being clean and A is not clean, B will still be in NEEDSCHECK state.
In order to make as much scanning progress as possible during phase 2 and phase 3, allow ourselves to try some spot repairs in the hopes that it will enable us to make progress towards at least scanning the whole metadata item. If we can't make any forward progress, we'll queue the scrub item for repair in phase 4, which means that anything still in in NEEDSCHECK state becomes CORRUPT state. (At worst, the NEEDSCHECK item will actually be clean by phase 4, and xfs_scrub will report that it didn't need any work after all.)
--- scrub/phase2.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ scrub/phase3.c | 71 +++++++++++++++++++++++++++++++++++++++++++- scrub/repair.c | 15 +++++++++ 3 files changed, 176 insertions(+), 1 deletion(-)
scrub/phase2.c +91 -0
@@ -77,6 +77,53 @@ defer_fs_repair(return 0 ; } +/* +* If we couldn't check all the scheduled metadata items, try performing spot +* repairs until we check everything or stop making forward progress. +*/ +static int +repair_and_scrub_loop ( +struct scrub_ctx *ctx, +struct scrub_item *sri, +const char *descr, +bool *defer) +{ +unsigned int to_check; +int ret; + + *defer = false; +if (ctx->mode !=SCRUB_MODE_REPAIR ) +return 0 ; + + to_check =scrub_item_count_needscheck (sri); +while (to_check >0 ) { +unsigned int nr; + + ret =repair_item_corruption (ctx, sri); +if (ret) +return ret; + + ret =scrub_item_check (ctx, sri); +if (ret) +return ret; + + nr =scrub_item_count_needscheck (sri); +if (nr == to_check) { +/* +* We cannot make forward scanning progress with this +* metadata, so defer the rest until phase 4. +*/ +str_info (ctx, descr, +_ ("Unable to make forward checking progress; will try again in phase 4." )); + *defer = true; +return 0 ; + } + to_check = nr; + } + +return 0 ; +} +/* Scrub each AG's metadata btrees. */ static void scan_ag_metadata(
@@ -90,6 +137,7 @@ scan_ag_metadata(struct scan_ctl *sctl = arg;char descr[DESCR_BUFSZ ];unsigned int difficulty; +bool defer_repairs;int ret;if (sctl->aborted)
@@ -105,10 +153,22 @@ scan_ag_metadata(scrub_item_schedule_group (&sri,XFROG_SCRUB_GROUP_AGHEADER );scrub_item_schedule_group (&sri,XFROG_SCRUB_GROUP_PERAG ); +/* +* Try to check all of the AG metadata items that we just scheduled. +* If we return with some types still needing a check, try repairing +* any damaged metadata that we've found so far, and try again. Abort +* if we stop making forward progress. +*/ ret =scrub_item_check (ctx, &sri);if (ret) goto err; + ret =repair_and_scrub_loop (ctx, &sri, descr, &defer_repairs); +if (ret) + goto err; +if (defer_repairs) + goto defer; +/* * Figure out if we need to perform early fixing. The only * reason we need to do this is if the inobt is broken, which
@@ -125,6 +185,7 @@ scan_ag_metadata(if (ret) goto err; +defer:/* Everything else gets fixed during phase 4. */ ret =defer_fs_repair (ctx, &sri);if (ret)
@@ -145,11 +206,18 @@ scan_metafile(struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx;struct scan_ctl *sctl = arg;unsigned int difficulty; +bool defer_repairs;int ret;if (sctl->aborted) goto out; +/* +* Try to check all of the metadata files that we just scheduled. If +* we return with some types still needing a check, try repairing any +* damaged metadata that we've found so far, and try again. Abort if +* we stop making forward progress. +*/ scrub_item_init_fs (&sri);scrub_item_schedule (&sri, type); ret =scrub_item_check (ctx, &sri);
@@ -158,10 +226,20 @@ scan_metafile( goto out; } + ret =repair_and_scrub_loop (ctx, &sri, xfrog_scrubbers[type].descr, + &defer_repairs); +if (ret) { + sctl->aborted = true; + goto out; + } +if (defer_repairs) + goto defer; +/* Complain about metadata corruptions that might not be fixable. */ difficulty =repair_item_difficulty (&sri);warn_repair_difficulties (ctx, difficulty, xfrog_scrubbers[type].descr); +defer: ret =defer_fs_repair (ctx, &sri);if (ret) { sctl->aborted = true;
@@ -188,6 +266,7 @@ scan_rtgroup_metadata(struct scrub_ctx *ctx = (struct scrub_ctx *)wq->wq_ctx;struct scan_ctl *sctl = arg;char descr[DESCR_BUFSZ ]; +bool defer_repairs;int ret;if (sctl->aborted)
@@ -196,6 +275,12 @@ scan_rtgroup_metadata(scrub_item_init_rtgroup (&sri, rgno);snprintf (descr,DESCR_BUFSZ ,_ ("rtgroup %u" ), rgno); +/* +* Try to check all of the rtgroup metadata items that we just +* scheduled. If we return with some types still needing a check, try +* repairing any damaged metadata that we've found so far, and try +* again. Abort if we stop making forward progress. +*/ scrub_item_schedule_group (&sri,XFROG_SCRUB_GROUP_RTGROUP ); ret =scrub_item_check (ctx, &sri);if (ret) {
@@ -203,6 +288,12 @@ scan_rtgroup_metadata( goto out; } + ret =repair_and_scrub_loop (ctx, &sri, descr, &defer_repairs); +if (ret) { + sctl->aborted = true; + goto out; + } +/* Everything else gets fixed during phase 4. */ ret =defer_fs_repair (ctx, &sri);if (ret) {
scrub/phase3.c +70 -1
87 lines not on this page · raw message
scrub/repair.c +15 -0
@@ -849,6 +849,7 @@ repair_item_to_action_item( struct action_item **aitemp) {struct action_item *aitem; +unsigned int scrub_type;if (repair_item_count_needsrepair (sri) ==0 )return 0 ;
@@ -864,6 +865,20 @@ repair_item_to_action_item(INIT_LIST_HEAD (&aitem->list);memcpy (&aitem->sri, sri,sizeof (struct scrub_item )); +/* +* If the scrub item indicates that there is unchecked metadata, assume +* that the scrub type checker depends on something that couldn't be +* fixed. Mark that type as corrupt so that phase 4 will try it again. +*/ +foreach_scrub_type (scrub_type) { +__u8 *state = aitem->sri.sri_state; + +if (state[scrub_type] &SCRUB_ITEM_NEEDSCHECK ) { + state[scrub_type] &= ~SCRUB_ITEM_NEEDSCHECK ; + state[scrub_type] |=SCRUB_ITEM_CORRUPT ; + } + } + *aitemp = aitem;return 0 ; }
cover libxfs: report refcount information to userspace
In reply to Darrick J. WongHi all,
Create a new ioctl to report the number of owners of each disk block so that reflink-aware defraggers can make better decisions about which extents to target.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=report-refcounts
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=report-refcounts
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=report-refcounts
--- configure.ac | 1 include/builddefs.in | 4 io/Makefile | 5 + io/fsrefcounts.c | 478 +++++++++++++++++++++++++++++++++++++++++++++++++ io/init.c | 1 io/io.h | 1 libfrog/fsrefcounts.h | 100 ++++++++++ m4/package_libcdev.m4 | 19 ++ man/man8/xfs_io.8 | 86 +++++++++ 9 files changed, 695 insertions(+) create mode 100644 io/fsrefcounts.c create mode 100644 libfrog/fsrefcounts.h
PATCH 1/1 xfs_io: dump reference count information
From: Darrick J. Wong <[email protected]>
Dump refcount info from the kernel so we can prototype a sharing-aware defrag/fs rearranging tool.
--- configure.ac | 1 include/builddefs.in | 4 io/Makefile | 5 + io/fsrefcounts.c | 478 +++++++++++++++++++++++++++++++++++++++++++++++++ io/init.c | 1 io/io.h | 1 libfrog/fsrefcounts.h | 100 ++++++++++ m4/package_libcdev.m4 | 19 ++ man/man8/xfs_io.8 | 86 +++++++++ 9 files changed, 695 insertions(+) create mode 100644 io/fsrefcounts.c create mode 100644 libfrog/fsrefcounts.h
configure.ac +1 -0
@@ -188,6 +188,7 @@ AC_HAVE_MREMAP AC_NEED_INTERNAL_FSXATTR AC_NEED_INTERNAL_FSCRYPT_ADD_KEY_ARG AC_HAVE_GETFSMAP +AC_HAVE_GETFSREFCOUNTS AC_HAVE_STATFS_FLAGS AC_HAVE_MAP_SYNC AC_HAVE_DEVMAPPER
include/builddefs.in +4 -0
@@ -114,6 +114,7 @@ HAVE_MREMAP = @have_mremap@ NEED_INTERNAL_FSXATTR = @need_internal_fsxattr@ NEED_INTERNAL_FSCRYPT_ADD_KEY_ARG = @need_internal_fscrypt_add_key_arg@ HAVE_GETFSMAP = @have_getfsmap@ +HAVE_GETFSREFCOUNTS = @have_getfsrefcounts@ HAVE_STATFS_FLAGS = @have_statfs_flags@ HAVE_MAP_SYNC = @have_map_sync@ HAVE_DEVMAPPER = @have_devmapper@
@@ -165,6 +166,9 @@ endif ifeq ($(HAVE_GETFSMAP),yes) PCFLAGS+= -DHAVE_GETFSMAP endif +ifeq ($(HAVE_GETFSREFCOUNTS),yes) +PCFLAGS+= -DHAVE_GETFSREFCOUNTS +endif ifeq ($(HAVE_FALLOCATE),yes) PCFLAGS += -DHAVE_FALLOCATE endif
io/Makefile +5 -0
@@ -116,6 +116,11 @@ ifeq ($(HAVE_FIEXCHANGE),yes) LCFLAGS += -DHAVE_FIEXCHANGE endif +# On linux we get fsrefcounts from the system or define it ourselves +# so include this unconditionally. If this reverts to only +# the autoconf check w/o local definition, test HAVE_GETFSREFCOUNTS +CFILES += fsrefcounts.c + default: depend $(LTCOMMAND) include $(BUILDRULES)
io/fsrefcounts.c new file +478 -0
478 lines not on this page · raw message
io/init.c +1 -0
@@ -58,6 +58,7 @@ init_commands(void)flink_init ();freeze_init ();fsmap_init (); +fsrefcounts_init ();fsync_init ();getrusage_init ();help_init ();
io/io.h +1 -0
@@ -190,3 +190,4 @@ extern void crc32cselftest_init(void);extern void bulkstat_init (void );extern void atomicupdate_init (void );extern void aginfo_init (void ); +extern void fsrefcounts_init (void );
libfrog/fsrefcounts.h new file +100 -0
100 lines not on this page · raw message
m4/package_libcdev.m4 +19 -0
@@ -347,6 +347,25 @@ struct fsmap_head fh; AC_SUBST(have_getfsmap) ]) +# +# Check if we have a FS_IOC_GETFSREFCOUNTS ioctl (Linux) +# +AC_DEFUN([AC_HAVE_GETFSREFCOUNTS], + [ AC_MSG_CHECKING([for GETFSREFCOUNTS]) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[ +#define _GNU_SOURCE +#include <sys/syscall.h> +#include <unistd.h> +#include <linux/fs.h> +#include <linux/fsrefcounts.h> + ]], [[ + unsigned long x = FS_IOC_GETFSREFCOUNTS; + struct fsrefs_head fh; + ]])],[have_getfsrefcounts=yes + AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)]) + AC_SUBST(have_getfsrefcounts) + ]) + AC_DEFUN([AC_HAVE_STATFS_FLAGS], [ AC_CHECK_TYPE(struct statfs,
man/man8/xfs_io.8 +86 -0
92 lines not on this page · raw message
cover xfsprogs: defragment free space
In reply to Darrick J. WongHi all,
These patches contain experimental code to enable userspace to defragment the free space in a filesystem. Two purposes are imagined for this
functionality: clearing space at the end of a filesystem before shrinking it, and clearing free space in anticipation of making a large allocation.
The first patch adds a new fallocate mode that allows userspace to allocate free space from the filesystem into a file. The goal here is to allow the filesystem shrink process to prevent allocation from a certain part of the filesystem while a free space defragmenter evacuates all the files from the doomed part of the filesystem.
The second patch amends the online repair system to allow the sysadmin to forcibly rebuild metadata structures, even if they're not corrupt. Without adding an ioctl to move metadata btree blocks, this is the only way to dislodge metadata.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=defrag-freespace
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=defrag-freespace
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=defrag-freespace
--- Makefile | 2 db/agfl.c | 297 +++++ include/xfs_trace.h | 4 io/prealloc.c | 37 + libfrog/Makefile | 6 libfrog/clearspace.c | 2940 ++++++++++++++++++++++++++++++++++++++++++++++ libfrog/clearspace.h | 72 + libxfs/libxfs_api_defs.h | 3 libxfs/libxfs_priv.h | 10 libxfs/xfs_alloc.c | 88 + libxfs/xfs_alloc.h | 4 libxfs/xfs_bmap.c | 149 ++ libxfs/xfs_bmap.h | 3 man/man8/xfs_db.8 | 11 man/man8/xfs_io.8 | 8 man/man8/xfs_spaceman.8 | 17 spaceman/Makefile | 6 spaceman/clearfree.c | 164 +++ spaceman/init.c | 1 spaceman/space.h | 2 20 files changed, 3815 insertions(+), 9 deletions(-) create mode 100644 libfrog/clearspace.c create mode 100644 libfrog/clearspace.h create mode 100644 spaceman/clearfree.c
PATCH 1/5 xfs: fallocate free space into a file
From: Darrick J. Wong <[email protected]>
Add a new fallocate mode to map free physical space into a file, at the same file offset as if the file were a sparse image of the physical device backing the filesystem. The intent here is to use this to prototype a free space defragmentation tool.
--- include/xfs_trace.h | 4 + libxfs/libxfs_priv.h | 10 +++ libxfs/xfs_alloc.c | 88 ++++++++++++++++++++++++++++++ libxfs/xfs_alloc.h | 4 + libxfs/xfs_bmap.c | 149 ++++++++++++++++++++++++++++++++++++++++++++++++++ libxfs/xfs_bmap.h | 3 + 6 files changed, 258 insertions(+)
include/xfs_trace.h +4 -0
@@ -26,6 +26,8 @@#define trace_xfs_alloc_exact_done (a) ((void) 0)#define trace_xfs_alloc_exact_notfound (a) ((void) 0)#define trace_xfs_alloc_exact_error (a) ((void) 0) +#define trace_xfs_alloc_find_freesp (...) ((void) 0) +#define trace_xfs_alloc_find_freesp_done (...) ((void) 0)#define trace_xfs_alloc_near_first (a) ((void) 0)#define trace_xfs_alloc_near_greater (a) ((void) 0)#define trace_xfs_alloc_near_lesser (a) ((void) 0)
@@ -189,6 +191,8 @@#define trace_xfs_bmap_pre_update (a,b,c,d) ((void) 0)#define trace_xfs_bmap_post_update (a,b,c,d) ((void) 0) +#define trace_xfs_bmapi_freesp (...) ((void) 0) +#define trace_xfs_bmapi_freesp_done (...) ((void) 0)#define trace_xfs_bunmap (a,b,c,d,e) ((void) 0)#define trace_xfs_read_extent (a,b,c,d) ((void) 0)
libxfs/libxfs_priv.h +10 -0
@@ -502,6 +502,16 @@ void __xfs_buf_mark_corrupt(struct xfs_buf *bp, xfs_failaddr_t fa);#define xfs_filestream_lookup_ag (ip) (0)#define xfs_filestream_new_ag (ip,ag) (0) +struct xfs_trans ; + +static inline int +xfs_rtallocate_extent (struct xfs_trans *tp,xfs_rtblock_t bno, +xfs_extlen_t minlen,xfs_extlen_t maxlen,xfs_extlen_t *len, +int wasdel,xfs_extlen_t prod,xfs_rtblock_t *rtblock) +{ +return -EOPNOTSUPP ; +} +#define xfs_trans_inode_buf (tp, bp) ((void) 0)/* quota bits */
libxfs/xfs_alloc.c +88 -0
91 lines not on this page · raw message
libxfs/xfs_alloc.h +4 -0
@@ -268,4 +268,8 @@ extern struct kmem_cache *xfs_extfree_item_cache;int __init xfs_extfree_intent_init_cache (void );void xfs_extfree_intent_destroy_cache (void ); +int xfs_alloc_find_freesp (struct xfs_trans *tp,struct xfs_perag *pag, +xfs_agblock_t *agbno,xfs_agblock_t end_agbno, +xfs_extlen_t *len); +#endif /* __XFS_ALLOC_H__ */
libxfs/xfs_bmap.c +149 -0
152 lines not on this page · raw message
libxfs/xfs_bmap.h +3 -0
@@ -193,6 +193,9 @@ int xfs_bmapi_read(struct xfs_inode *ip, xfs_fileoff_t bno,int xfs_bmapi_write (struct xfs_trans *tp,struct xfs_inode *ip,xfs_fileoff_t bno,xfs_filblks_t len,uint32_t flags,xfs_extlen_t total,struct xfs_bmbt_irec *mval,int *nmap); +int xfs_bmapi_freesp (struct xfs_trans *tp,struct xfs_inode *ip, +xfs_fsblock_t fsbno,xfs_extlen_t len, +struct xfs_bmbt_irec *mval);int __xfs_bunmapi (struct xfs_trans *tp,struct xfs_inode *ip,xfs_fileoff_t bno,xfs_filblks_t *rlen,uint32_t flags,xfs_extnum_t nexts);
PATCH 2/5 xfs_io: support using fallocate to map free space
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Support FALLOC_FL_MAP_FREE_SPACE as a fallocate mode. This is experimental code to see if we can build a free space defragmenter out of this.
--- io/prealloc.c | 37 +++++++++++++++++++++++++++++++++++++ man/man8/xfs_io.8 | 8 +++++++- 2 files changed, 44 insertions(+), 1 deletion(-)
io/prealloc.c +37 -0
@@ -32,6 +32,10 @@#define FALLOC_FL_UNSHARE_RANGE 0x40#endif +#ifndef FALLOC_FL_MAP_FREE_SPACE +#define FALLOC_FL_MAP_FREE_SPACE (1U << 30) +#endif +static cmdinfo_t allocsp_cmd;static cmdinfo_t freesp_cmd;static cmdinfo_t resvsp_cmd;
@@ -44,6 +48,7 @@ static cmdinfo_t fcollapse_cmd;static cmdinfo_t finsert_cmd;static cmdinfo_t fzero_cmd;static cmdinfo_t funshare_cmd; +static cmdinfo_t fmapfree_cmd;#endif static int
@@ -381,6 +386,28 @@ funshare_f( }return 0 ; } + +static int +fmapfree_f ( +int argc, +char **argv) +{ +xfs_flock64_t segment; +int mode =FALLOC_FL_MAP_FREE_SPACE ; +int index =1 ; + +if (!offset_length (argv[index], argv[index +1 ], &segment)) { + exitcode =1 ; +return 0 ; + } + +if (fallocate (file->fd, mode, segment.l_start, segment.l_len)) { +perror ("fallocate" ); + exitcode =1 ; +return 0 ; + } +return 0 ; +}#endif /* HAVE_FALLOCATE */ void
@@ -496,5 +523,15 @@ prealloc_init(void) funshare_cmd.oneline =_ ("unshares shared blocks within the range" );add_command (&funshare_cmd); + + fmapfree_cmd.name ="fmapfree" ; + fmapfree_cmd.cfunc = fmapfree_f; + fmapfree_cmd.argmin =2 ; + fmapfree_cmd.argmax =2 ; + fmapfree_cmd.flags =CMD_NOMAP_OK |CMD_FOREIGN_OK ; + fmapfree_cmd.args =_ ("off len" ); + fmapfree_cmd.oneline = +_ ("maps free space into a file" ); +add_command (&fmapfree_cmd);#endif /* HAVE_FALLOCATE */ }
man/man8/xfs_io.8 +7 -1
@@ -513,8 +513,14 @@ Call fallocate with FALLOC_FL_INSERT_RANGE flag as described in the .BR fallocate (2) manual page to create the hole by shifting data blocks. .TP +.BI fmapfree " offset length" +Maps free physical space into the file by calling fallocate with +the FALLOC_FL_MAP_FREE_SPACE flag as described in the +.BR fallocate (2) +manual page. +.TP .BI fpunch " offset length" -Punches (de-allocates) blocks in the file by calling fallocate with +Punches (de-allocates) blocks in the file by calling fallocate with the FALLOC_FL_PUNCH_HOLE flag as described in the .BR fallocate (2) manual page.
PATCH 3/5 xfs_db: get and put blocks on the AGFL
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add a new xfs_db command to let people add and remove blocks from an AGFL. This isn't really related to rmap btree reconstruction, other than enabling debugging code to mess around with the AGFL to exercise various odd scenarios.
--- db/agfl.c | 297 ++++++++++++++++++++++++++++++++++++++++++++++ libxfs/libxfs_api_defs.h | 3 man/man8/xfs_db.8 | 11 ++ 3 files changed, 307 insertions(+), 4 deletions(-)
db/agfl.c +294 -3
@@ -15,13 +15,14 @@#include "output.h" #include "init.h" #include "agfl.h" +#include "libfrog/bitmap.h" static int agfl_bno_size (void *obj,int startoff);static int agfl_f (int argc,char **argv);static void agfl_help (void );static const cmdinfo_t agfl_cmd = - {"agfl" ,NULL , agfl_f,0 ,1 ,1 ,N_ ("[agno]" ), + {"agfl" ,NULL , agfl_f,0 ,-1 ,1 ,N_ ("[agno] [-g nr] [-p nr]" ),N_ ("set address to agfl block" ), agfl_help };const field_t agfl_hfld[] = { {
@@ -77,10 +78,280 @@ agfl_help(void)" for each allocation group. This acts as a reserved pool of space\n" " separate from the general filesystem freespace (not used for user data).\n" "\n" +" -g quantity\tRemove this many blocks from the AGFL.\n" +" -p quantity\tAdd this many blocks to the AGFL.\n" +"\n" )); } +struct dump_info { +struct xfs_perag *pag; +bool leak; +}; + +/* Return blocks freed from the AGFL to the free space btrees. */ +static int +free_grabbed ( +uint64_t start, +uint64_t length, +void *data) +{ +struct dump_info *di = data; +struct xfs_perag *pag = di->pag; +struct xfs_mount *mp = pag->pag_mount; +struct xfs_trans *tp; +struct xfs_buf *agf_bp; +int error; + + error = -libxfs_trans_alloc (mp, &M_RES (mp)->tr_itruncate,0 ,0 ,0 , + &tp); +if (error) +return error; + + error = -libxfs_alloc_read_agf (pag, tp,0 , &agf_bp); +if (error) + goto out_cancel; + + error = -libxfs_free_extent (tp, pag, start, length, &XFS_RMAP_OINFO_AG , +XFS_AG_RESV_AGFL ); +if (error) + goto out_cancel; + +return -libxfs_trans_commit (tp); + +out_cancel: +libxfs_trans_cancel (tp); +return error; +} + +/* Report blocks freed from the AGFL. */ +static int +dump_grabbed ( +uint64_t start, +uint64_t length, +void *data) +{ +struct dump_info *di = data; +const char *fmt; + +if (length ==1 ) + fmt = di->leak ?_ ("agfl %u: leaked agbno %u\n" ) : +_ ("agfl %u: removed agbno %u\n" ); +else + fmt = di->leak ?_ ("agfl %u: leaked agbno %u-%u\n" ) : +_ ("agfl %u: removed agbno %u-%u\n" ); + +printf (fmt, di->pag->pag_agno, (unsigned int )start, + (unsigned int )(start + length -1 )); +return 0 ; +} + +/* Remove blocks from the AGFL. */ +static int +agfl_get ( +struct xfs_perag *pag, +int quantity) +{ +struct dump_info di = { + .pag = pag, + .leak = quantity <0 , + }; +struct xfs_agf *agf; +struct xfs_buf *agf_bp; +struct xfs_trans *tp; +struct bitmap *grabbed; +const unsigned int agfl_size =libxfs_agfl_size (pag->pag_mount); +unsigned int i; +int error; + +if (!quantity) +return 0 ; + +if (di.leak) + quantity = -quantity; + quantity =min (quantity, agfl_size); + + error =bitmap_alloc (&grabbed); +if (error) + goto out; + + error = -libxfs_trans_alloc (mp, &M_RES (mp)->tr_itruncate, quantity,0 , +0 , &tp); +if (error) + goto out_bitmap; + + error = -libxfs_alloc_read_agf (pag, tp,0 , &agf_bp); +if (error) + goto out_cancel; + + agf = agf_bp->b_addr; + quantity =min (quantity,be32_to_cpu (agf->agf_flcount)); + +for (i =0 ; i < quantity; i++) { +xfs_agblock_t agbno; + + error = -libxfs_alloc_get_freelist (pag, tp, agf_bp, &agbno,0 ); +if (error) + goto out_cancel; + +if (agbno ==NULLAGBLOCK ) { + error =ENOSPC ; + goto out_cancel; + } + + error =bitmap_set (grabbed, agbno,1 ); +if (error) + goto out_cancel; + } + + error = -libxfs_trans_commit (tp); +if (error) + goto out_bitmap; + + error =bitmap_iterate (grabbed, dump_grabbed, &di); +if (error) + goto out_bitmap; + +if (!di.leak) { + error =bitmap_iterate (grabbed, free_grabbed, &di); +if (error) + goto out_bitmap; + } + +bitmap_free (&grabbed); +return 0 ; + +out_cancel: +libxfs_trans_cancel (tp); +out_bitmap: +bitmap_free (&grabbed); +out: +if (error) +printf (_ ("agfl %u: %s\n" ), pag->pag_agno,strerror (error)); +return error; +} + +/* Add blocks to the AGFL. */ +static int +agfl_put ( +struct xfs_perag *pag, +int quantity) +{ +struct xfs_alloc_arg targs = { + .mp = pag->pag_mount, + .alignment =1 , + .minlen =1 , + .prod =1 , + .type =XFS_ALLOCTYPE_NEAR_BNO , + .resv =XFS_AG_RESV_AGFL , + .oinfo =XFS_RMAP_OINFO_AG , + }; +struct xfs_buf *agfl_bp; +struct xfs_agf *agf; +struct xfs_trans *tp; +const unsigned int agfl_size =libxfs_agfl_size (pag->pag_mount); +unsigned int i; +bool eoag = quantity <0 ; +int error; + +if (!quantity) +return 0 ; + +if (eoag) + quantity = -quantity; + quantity =min (quantity, agfl_size); + + error = -libxfs_trans_alloc (mp, &M_RES (mp)->tr_itruncate, quantity,0 , +0 , &tp); +if (error) +return error; + targs.tp = tp; + + error = -libxfs_alloc_read_agf (pag, tp,0 , &targs.agbp); +if (error) + goto out_cancel; + + agf = targs.agbp->b_addr; + targs.maxlen =min (quantity, agfl_size -be32_to_cpu (agf->agf_flcount)); + +if (eoag) + targs.fsbno =XFS_AGB_TO_FSB (pag->pag_mount, pag->pag_agno, +be32_to_cpu (agf->agf_length) -1 ); +else + targs.fsbno =XFS_AGB_TO_FSB (pag->pag_mount, pag->pag_agno,0 ); + + error = -libxfs_alloc_read_agfl (pag, tp, &agfl_bp); +if (error) + goto out_cancel; + + error = -libxfs_alloc_vextent (&targs); +if (error) + goto out_cancel; + +if (targs.agbno ==NULLAGBLOCK ) { + error =ENOSPC ; + goto out_cancel; + } + +for (i =0 ; i < targs.len; i++) { + error = -libxfs_alloc_put_freelist (pag, tp, targs.agbp, + agfl_bp, targs.agbno + i,0 ); +if (error) + goto out_cancel; + } + +if (i ==1 ) +printf (_ ("agfl %u: added agbno %u\n" ), pag->pag_agno, + targs.agbno); +else if (i >1 ) +printf (_ ("agfl %u: added agbno %u-%u\n" ), pag->pag_agno, + targs.agbno, targs.agbno + i -1 ); + + error = -libxfs_trans_commit (tp); +if (error) + goto out; + +return 0 ; + +out_cancel: +libxfs_trans_cancel (tp); +out: +if (error) +printf (_ ("agfl %u: %s\n" ), pag->pag_agno,strerror (error)); +return error; +} + +static void +agfl_adjust ( +struct xfs_mount *mp, +xfs_agnumber_t agno, +int gblocks, +int pblocks) +{ +struct xfs_perag *pag; +int error; + +if (!expert_mode) { +printf (_ ("AGFL get/put only supported in expert mode.\n" )); + exitcode =1 ; +return ; + } + + pag =libxfs_perag_get (mp, agno); + + error =agfl_get (pag, gblocks); +if (error) + goto out_pag; + + error =agfl_put (pag, pblocks); + +out_pag: +libxfs_perag_put (pag); +if (error) + exitcode =1 ; +} + static int agfl_f( int argc,
@@ -88,9 +359,25 @@ agfl_f( {xfs_agnumber_t agno;char *p; +int c; +int gblocks =0 , pblocks =0 ; -if (argc >1 ) { - agno = (xfs_agnumber_t )strtoul (argv[1 ], &p,0 ); +while ((c =getopt (argc, argv,"g:p:" )) !=-1 ) { +switch (c) { +case 'g' : + gblocks =atoi (optarg); +break ; +case 'p' : + pblocks =atoi (optarg); +break ; +default : +agfl_help (); +return 1 ; + } + } + +if (argc > optind) { + agno = (xfs_agnumber_t )strtoul (argv[optind], &p,0 );if (*p !='\0' || agno >= mp->m_sb.sb_agcount) {dbprintf (_ ("bad allocation group number %s\n" ), argv[1 ]);return 0 ;
@@ -98,6 +385,10 @@ agfl_f( cur_agno = agno; }else if (cur_agno ==NULLAGNUMBER ) cur_agno =0 ; + +if (gblocks || pblocks) +agfl_adjust (mp, cur_agno, gblocks, pblocks); +ASSERT (typtab[TYP_AGFL ].typnm ==TYP_AGFL ); set_cur(&typtab[TYP_AGFL], XFS_AG_DADDR(mp, cur_agno, XFS_AGFL_DADDR(mp)),
libxfs/libxfs_api_defs.h +3 -0
@@ -29,8 +29,11 @@#define xfs_allocbt_maxrecs libxfs_allocbt_maxrecs#define xfs_allocbt_stage_cursor libxfs_allocbt_stage_cursor#define xfs_alloc_fix_freelist libxfs_alloc_fix_freelist +#define xfs_alloc_get_freelist libxfs_alloc_get_freelist#define xfs_alloc_min_freelist libxfs_alloc_min_freelist +#define xfs_alloc_put_freelist libxfs_alloc_put_freelist#define xfs_alloc_read_agf libxfs_alloc_read_agf +#define xfs_alloc_read_agfl libxfs_alloc_read_agfl#define xfs_alloc_vextent libxfs_alloc_vextent#define xfs_attr_get libxfs_attr_get
man/man8/xfs_db.8 +10 -1
@@ -182,10 +182,19 @@ Set current address to the AGF block for allocation group .IR agno . If no argument is given, use the current allocation group. .TP -.BI "agfl [" agno ] +.BI "agfl [" agno "] [\-g " " quantity" "] [\-p " quantity ] Set current address to the AGFL block for allocation group .IR agno . If no argument is given, use the current allocation group. +If the +.B -g +option is specified with a positive quantity, remove that many blocks from the +AGFL and put them in the free space btrees. +If the quantity is negative, remove the blocks and leak them. +If the +.B -p +option is specified, add that many blocks to the AGFL. +If the quantity is negative, the blocks are selected from the end of the AG. .TP .BI "agi [" agno ] Set current address to the AGI block for allocation group
PATCH 4/5 xfs_spaceman: implement clearing free space
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
First attempt at evacuating all the used blocks from part of a filesystem.
--- Makefile | 2 libfrog/Makefile | 6 libfrog/clearspace.c | 2723 +++++++++++++++++++++++++++++++++++++++++++++++ libfrog/clearspace.h | 72 + man/man8/xfs_spaceman.8 | 17 spaceman/Makefile | 6 spaceman/clearfree.c | 164 +++ spaceman/init.c | 1 spaceman/space.h | 2 9 files changed, 2989 insertions(+), 4 deletions(-) create mode 100644 libfrog/clearspace.c create mode 100644 libfrog/clearspace.h create mode 100644 spaceman/clearfree.c
Makefile +1 -1
@@ -105,7 +105,7 @@ quota: libxcmd repair: libxlog libxcmd copy: libxlog mkfs: libxcmd -spaceman: libxcmd +spaceman: libhandle libxcmd scrub: libhandle libxcmd rtcp: libfrog
libfrog/Makefile +6 -0
@@ -61,6 +61,12 @@ ifeq ($(HAVE_FIEXCHANGE),yes) LCFLAGS += -DHAVE_FIEXCHANGE endif +ifeq ($(HAVE_GETFSMAP),yes) +CFILES+=clearspace.c +HFILES+=clearspace.h +endif + + LDIRT = gen_crc32table crc32table.h crc32selftest default: crc32selftest ltdepend $(LTLIBRARY)
libfrog/clearspace.c new file +2723 -0
2,723 lines not on this page · raw message
libfrog/clearspace.h new file +72 -0
72 lines not on this page · raw message
man/man8/xfs_spaceman.8 +17 -0
@@ -25,6 +25,23 @@ then the program exits. .SH COMMANDS .TP +.BI "clearfree [ \-n nr ] [ \-r ] [ \-v mask ] " start " " length +Try to clear the specified physical range in the filesystem. +The +.B start +and +.B length +arguments must be given in units of bytes. +If the +.B -n +option is given, run the clearing algorithm this many times. +If the +.B -r +option is given, clear the realtime device. +If the +.B -v +option is given, print what's happening every step of the way. +.TP .BI "freesp [ \-dgrs ] [-a agno]... [ \-b | \-e bsize | \-h bsize | \-m factor ]" With no arguments, .B freesp
spaceman/Makefile +3 -3
@@ -10,8 +10,8 @@ HFILES = init.h space.h CFILES = info.c init.c file.c health.c prealloc.c trim.c LSRCFILES = xfs_info.sh -LLDLIBS = $(LIBXCMD) $(LIBFROG) -LTDEPENDENCIES = $(LIBXCMD) $(LIBFROG) +LLDLIBS = $(LIBHANDLE) $(LIBXCMD) $(LIBFROG) +LTDEPENDENCIES = $(LIBHANDLE) $(LIBXCMD) $(LIBFROG) LLDFLAGS = -static ifeq ($(ENABLE_EDITLINE),yes)
@@ -19,7 +19,7 @@ LLDLIBS += $(LIBEDITLINE) $(LIBTERMCAP) endif ifeq ($(HAVE_GETFSMAP),yes) -CFILES += freesp.c +CFILES += freesp.c clearfree.c endif default: depend $(LTCOMMAND)
spaceman/clearfree.c new file +164 -0
144 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Part of the diff is not shown here. View the raw message.
PATCH 5/5 xfs_spaceman: defragment free space with normal files
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
--- libfrog/clearspace.c | 377 +++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 297 insertions(+), 80 deletions(-)
libfrog/clearspace.c +297 -80
@@ -1362,6 +1362,17 @@ csp_evac_dedupe_loop( fdr->src_length = old_reqlen;continue ; } +if (ret ==EINVAL ) { +/* +* If we can't dedupe get the block, it's possible that +* src_fd was punched or truncated out from under us. +* Treat this the same way we would if the contents +* didn't match. +*/ +trace_dedupe (req,"cannot evac space, moving on" ,0 ); + same = false; + ret =0 ; + }if (ret) {fprintf (stderr,_ ("evacuating inode 0x%llx: %s\n" ), ino,strerror (ret));
@@ -1939,8 +1950,14 @@ csp_evac_fs_metadata(* the space capture file, or 1 if there's nothing to transfer to the space * capture file. */ -static int -csp_freeze_check_attempt ( +enum freeze_outcome { +FREEZE_FAILED =-1 , +FREEZE_DONE , +FREEZE_SKIP , +}; + +static enum freeze_outcome +csp_freeze_check_outcome (struct clearspace_req *req,const struct fsmap *mrec,unsigned long long *len)
@@ -1950,13 +1967,12 @@ csp_freeze_check_attempt( *len =0 ; - ret =bmapx_one (req, req->work_fd, mrec->fmr_physical, - mrec->fmr_length, &brec); + ret =bmapx_one (req, req->work_fd,0 , mrec->fmr_length, &brec);if (ret) -return ret; +return FREEZE_FAILED ; trace_freeze(req, - "does workfd pos 0x%llx len 0x%llx map to phys 0x%llx len 0x%llx?", + "check if workfd pos 0x0 phys 0x%llx len 0x%llx maps to phys 0x%llx len 0x%llx", (unsigned long long)mrec->fmr_physical, (unsigned long long)mrec->fmr_length, (unsigned long long)BBTOB(brec.bmv_block),
@@ -1964,8 +1980,8 @@ csp_freeze_check_attempt(/* freeze of an unwritten extent punches a hole in the work file. */ if ((mrec->fmr_flags &FMR_OF_PREALLOC ) && brec.bmv_block ==-1 ) { - *len =BBTOB (brec.bmv_length); -return 1 ; + *len =min (mrec->fmr_length,BBTOB (brec.bmv_length)); +return FREEZE_SKIP ; }/*
@@ -1974,8 +1990,8 @@ csp_freeze_check_attempt(*/ if (!(mrec->fmr_flags &FMR_OF_PREALLOC ) &&BBTOB (brec.bmv_block) == mrec->fmr_physical) { - *len =BBTOB (brec.bmv_length); -return 0 ; + *len =min (mrec->fmr_length,BBTOB (brec.bmv_length)); +return FREEZE_DONE ; }/*
@@ -1984,20 +2000,15 @@ csp_freeze_check_attempt(* have been mapped into the work file. Set @len to zero and return so * that we try again with the next mapping. */ +trace_falloc (req,"reset workfd isize 0x0" ,0 ); -trace_falloc (req,"fpunch workfd pos 0x%llx bytecount 0x%llx" , - (unsigned long long )mrec->fmr_physical, - (unsigned long long )mrec->fmr_length); - - ret =fallocate (req->work_fd, -FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE , - mrec->fmr_physical, mrec->fmr_length); + ret =ftruncate (req->work_fd,0 );if (ret) {perror (_ ("resetting work file after failed freeze" )); -return ret; +return FREEZE_FAILED ; } -return 1 ; +return FREEZE_SKIP ; }/*
@@ -2014,6 +2025,7 @@ csp_freeze_open( int *fd) {struct xfs_bulkstat bulkstat; +int oflags =O_RDWR ;int target_fd;int ret;
@@ -2041,7 +2053,10 @@ csp_freeze_open(if (!S_ISREG (bulkstat.bs_mode) && !S_ISDIR (bulkstat.bs_mode))return 0 ; - target_fd =csp_open_by_handle (req,O_RDONLY , mrec->fmr_owner, +if (S_ISDIR (bulkstat.bs_mode)) + oflags =O_RDONLY ; + + target_fd =csp_open_by_handle (req, oflags, mrec->fmr_owner, bulkstat.bs_gen);if (target_fd ==-2 )return 0 ;
@@ -2061,6 +2076,122 @@ csp_freeze_open(return 0 ; } +static inline uint64_t rounddown_64 (uint64_t x,uint64_t y) +{ +return (x / y) * y; +} + +/* +* Deal with a frozen extent containing a partially written EOF block. Either +* we use funshare to get src_fd to release the block, or we reduce the length +* of the frozen extent by one block. +*/ +static int +csp_freeze_unaligned_eofblock ( +struct clearspace_req *req, +int src_fd, +const struct fsmap *mrec, +unsigned long long *frozen_len) +{ +struct getbmapx brec; +struct stat statbuf; +loff_t work_offset, length; +int ret; + + ret =fstat (req->work_fd, &statbuf); +if (ret) { +perror (_ ("statting work file" )); +return ret; + } + +/* +* The frozen extent is less than the size of the work file, which +* means that we're already block aligned. +*/ +if (*frozen_len <= statbuf.st_size) +return 0 ; + +/* The frozen extent does not contain a partially written EOF block. */ +if (statbuf.st_size % statbuf.st_blksize ==0 ) +return 0 ; + +/* +* Unshare what we think is a partially written EOF block of the +* original file, to try to force it to release that block. +*/ + work_offset =rounddown_64 (statbuf.st_size, statbuf.st_blksize); + length = statbuf.st_size - work_offset; + +trace_freeze (req, +"unaligned eofblock 0x%llx work_size 0x%llx blksize 0x%x work_offset 0x%llx work_length 0x%llx" , + *frozen_len, statbuf.st_size, statbuf.st_blksize, + work_offset, length); + + ret =fallocate (src_fd,FALLOC_FL_UNSHARE_RANGE , + mrec->fmr_offset + work_offset, length); +if (ret) { +perror (_ ("unsharing original file" )); +return ret; + } + + ret =fsync (src_fd); +if (ret) { +perror (_ ("flushing original file" )); +return ret; + } + + ret =bmapx_one (req, req->work_fd, work_offset, length, &brec); +if (ret) +return ret; + +if (BBTOB (brec.bmv_block) != mrec->fmr_physical + work_offset) { +fprintf (stderr, +_ ("work file offset 0x%llx maps to phys 0x%llx, expected 0x%llx" ), + (unsigned long long )work_offset, + (unsigned long long )BBTOB (brec.bmv_block), + (unsigned long long )mrec->fmr_physical); +return -1 ; + } + +/* +* If the block is still shared, there must be other owners of this +* block. Round down the frozen length and we'll come back to it +* eventually. +*/ +if (brec.bmv_oflags &BMV_OF_SHARED ) { + *frozen_len = work_offset; +return 0 ; + } + +/* +* Not shared anymore, so increase the size of the file to the next +* block boundary so that we can reflink it into the space capture +* file. +*/ + ret =ftruncate (req->work_fd, +BBTOB (brec.bmv_length) +BBTOB (brec.bmv_offset)); +if (ret) { +perror (_ ("expanding work file" )); +return ret; + } + +/* Double-check that we didn't lose the block. */ + ret =bmapx_one (req, req->work_fd, work_offset, length, &brec); +if (ret) +return ret; + +if (BBTOB (brec.bmv_block) != mrec->fmr_physical + work_offset) { +fprintf (stderr, +_ ("work file offset 0x%llx maps to phys 0x%llx, should be 0x%llx" ), + (unsigned long long )work_offset, + (unsigned long long )BBTOB (brec.bmv_block), + (unsigned long long )mrec->fmr_physical); +return -1 ; + } + +return 0 ; +} +/* * Given a fsmap, try to reflink the physical space into the space capture * file.
@@ -2074,6 +2205,7 @@ csp_freeze_req_fsmap(struct fsmap short_mrec;struct file_clone_range fcr = { };unsigned long long frozen_len; +enum freeze_outcome outcome;int src_fd;int ret, ret2;
@@ -2126,33 +2258,86 @@ csp_freeze_req_fsmap( }/* -* Reflink the mapping from the source file into the work file. If we +* Reflink the mapping from the source file into the empty work file so +* that a write will be written elsewhere. The only way to reflink a +* partially written EOF block is if the kernel can reset the work file +* size so that the post-EOF part of the block remains post-EOF. If we * can't do that, we're sunk. If the mapping is unwritten, we'll leave * a hole in the work file. */ + ret =ftruncate (req->work_fd,0 ); +if (ret) { +perror (_ ("truncating work file for freeze" )); + goto out_fd; + } + fcr.src_fd = src_fd; fcr.src_offset = mrec->fmr_offset; fcr.src_length = mrec->fmr_length; - fcr.dest_offset = mrec->fmr_physical; + fcr.dest_offset =0 ; -trace_freeze (req,"freeze to workfd pos 0x%llx" , - (unsigned long long )fcr.dest_offset); +trace_freeze (req, +"reflink ino 0x%llx offset 0x%llx bytecount 0x%llx into workfd" , + (unsigned long long )mrec->fmr_owner, + (unsigned long long )fcr.src_offset, + (unsigned long long )fcr.src_length); ret =clonerange (req->work_fd, &fcr); -if (ret) { -fprintf (stderr,_ ("freezing space to work file: %s\n" ), -strerror (ret)); - goto out_fd; +if (ret ==EINVAL ) { +/* +* If that didn't work, try reflinking to EOF and picking out +* whatever pieces we want. +*/ + fcr.src_length =0 ; + +trace_freeze (req, +"reflink ino 0x%llx offset 0x%llx to EOF into workfd" , + (unsigned long long )mrec->fmr_owner, + (unsigned long long )fcr.src_offset); + + ret =clonerange (req->work_fd, &fcr); } - - req->trace_indent++; - ret =csp_freeze_check_attempt (req, mrec, &frozen_len); - req->trace_indent--; -if (ret <0 ) - goto out_fd; -if (ret ==1 ) { +if (ret ==EINVAL ) { +/* +* If we still can't get the block, it's possible that src_fd +* was punched or truncated out from under us, so we just move +* on to the next fsmap. +*/ +trace_freeze (req,"cannot freeze space, moving on" ,0 ); ret =0 ; - goto advance; + goto out_fd; + } +if (ret) { +fprintf (stderr,_ ("freezing space to work file: %s\n" ), +strerror (ret)); + goto out_fd; + } + + req->trace_indent++; + outcome =csp_freeze_check_outcome (req, mrec, &frozen_len); + req->trace_indent--; +switch (outcome) { +case FREEZE_FAILED : + ret =-1 ; + goto out_fd; +case FREEZE_SKIP : + *cursor += frozen_len; + goto out_fd; +case FREEZE_DONE : +break ; + } + +/* +* If we tried reflinking to EOF to capture a partially written EOF +* block in the work file, we need to unshare the end of the source +* file before we try to reflink the frozen space into the space +* capture file. +*/ +if (fcr.src_length ==0 ) { + ret =csp_freeze_unaligned_eofblock (req, src_fd, mrec, + &frozen_len); +if (ret) + goto out_fd; }/*
@@ -2164,11 +2349,11 @@ csp_freeze_req_fsmap(* the contents of the work file. */ fcr.src_fd = req->work_fd; - fcr.src_offset = mrec->fmr_physical; + fcr.src_offset =0 ; fcr.dest_offset = mrec->fmr_physical; fcr.src_length = frozen_len; -trace_freeze (req,"link phys 0x%llx len 0x%llx to spacefd" , +trace_freeze (req,"reflink phys 0x%llx len 0x%llx to spacefd" , (unsigned long long )mrec->fmr_physical, (unsigned long long )mrec->fmr_length);
@@ -2187,7 +2372,6 @@ csp_freeze_req_fsmap( goto out_fd; } -advance: *cursor += frozen_len; out_fd: ret2 =close (src_fd);
@@ -2278,6 +2462,79 @@ csp_collect_garbage(return 0 ; } +static int +csp_prepare ( +struct clearspace_req *req) +{ +blkcnt_t old_blocks =0 ; +int ret; + +/* +* Empty out CoW forks and speculative post-EOF preallocations before +* starting the clearing process. This may be somewhat overkill. +*/ + ret =syncfs (req->xfd->fd); +if (ret) { +perror (_ ("syncing filesystem" )); +return ret; + } + + ret =csp_collect_garbage (req); +if (ret) +return ret; + +/* +* Set up the space capture file as a large sparse file mirroring the +* physical space that we want to defragment. +*/ + ret =ftruncate (req->space_fd, req->start + req->length); +if (ret) { +perror (_ ("setting up space capture file" )); +return ret; + } + +/* +* If we don't have reflink, just grab the free space and move on to +* copying and exchanging file contents. +*/ +if (!req->use_reflink) +return csp_grab_free_space (req); + +/* +* Try to freeze as much of the requested range as we can, grab the +* free space in that range, and run freeze again to pick up anything +* that may have been allocated while all that was going on. +*/ +do { +struct stat statbuf; + + ret =csp_freeze_req_range (req); +if (ret) +return ret; + + ret =csp_grab_free_space (req); +if (ret) +return ret; + + ret =fstat (req->space_fd, &statbuf); +if (ret) +return ret; + +if (old_blocks == statbuf.st_blocks) +break ; + old_blocks = statbuf.st_blocks; + }while (1 ); + +/* +* If reflink is enabled, our strategy is to dedupe to free blocks in +* the area that we're clearing without making any user-visible changes +* to the file contents. For all the written file data blocks in area +* we're clearing, make an identical copy in the work file that is +* backed by blocks that are not in the clearing area. +*/ +return csp_prepare_for_dedupe (req); +} +/* Set up the target to clear all metadata from the given range. */ static inline void csp_target_metadata(
@@ -2330,50 +2587,10 @@ clearspace_run(return ret; } -/* -* Empty out CoW forks and speculative post-EOF preallocations before -* starting the clearing process. This may be somewhat overkill. -*/ - ret =syncfs (req->xfd->fd); -if (ret) { -perror (_ ("syncing filesystem" )); - goto out_bitmap; - } - - ret =csp_collect_garbage (req); -if (ret) - goto out_bitmap; - -/* -* Try to freeze as much of the requested range as we can, grab the -* free space in that range, and run freeze again to pick up anything -* that may have been allocated while all that was going on. -*/ - ret =csp_freeze_req_range (req); -if (ret) - goto out_bitmap; - - ret =csp_grab_free_space (req); -if (ret) - goto out_bitmap; - - ret =csp_freeze_req_range (req); + ret =csp_prepare (req);if (ret) goto out_bitmap; -/* -* If reflink is enabled, our strategy is to dedupe to free blocks in -* the area that we're clearing without making any user-visible changes -* to the file contents. For all the written file data blocks in area -* we're clearing, make an identical copy in the work file that is -* backed by blocks that are not in the clearing area. -*/ -if (req->use_reflink) { - ret =csp_prepare_for_dedupe (req); -if (ret) - goto out_bitmap; - } -/* Evacuate as many file blocks as we can. */ do { ret = csp_find_target(req, &target);
cover xfs_scrub: vectorize kernel calls
In reply to Darrick J. WongHi all,
Create a vectorized version of the metadata scrub and repair ioctl, and adapt xfs_scrub to use that. This is an experiment to measure overhead and to try refactoring xfs_scrub.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=vectorized-scrub
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=vectorized-scrub
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=vectorized-scrub
--- tests/xfs/122.out | 2 ++ 1 file changed, 2 insertions(+)
PATCH 1/1 xfs/122: update for vectored scrub
From: Darrick J. Wong <[email protected]>
Add the two new vectored scrub structures.
--- tests/xfs/122.out | 2 ++ 1 file changed, 2 insertions(+)
tests/xfs/122.out +2 -0
@@ -126,6 +126,8 @@ sizeof(struct xfs_rtsb) = 104 sizeof(struct xfs_rud_log_format) = 16 sizeof(struct xfs_rui_log_format) = 16 sizeof(struct xfs_scrub_metadata) = 64 +sizeof(struct xfs_scrub_vec) = 16 +sizeof(struct xfs_scrub_vec_head) = 24 sizeof(struct xfs_swap_extent) = 64 sizeof(struct xfs_sxd_log_format) = 16 sizeof(struct xfs_sxi_log_format) = 80
cover fstests: functional test for refcount reporting
In reply to Darrick J. WongHi all,
Add a short functional test for the new GETFSREFCOUNTS ioctl that allows userspace to query reference count information for a given range of physical blocks.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=report-refcounts
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=report-refcounts
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=report-refcounts
--- common/rc | 4 + doc/group-names.txt | 1 tests/xfs/921 | 168 +++++++++++++++++++++++++++++++++++++++++++++++++++ tests/xfs/921.out | 4 + 4 files changed, 175 insertions(+), 2 deletions(-) create mode 100755 tests/xfs/921 create mode 100644 tests/xfs/921.out
PATCH 1/1 xfs: test output of new FSREFCOUNTS ioctl
From: Darrick J. Wong <[email protected]>
Make sure the cursors work properly and that refcounts are correct.
--- common/rc | 4 + doc/group-names.txt | 1 tests/xfs/921 | 168 +++++++++++++++++++++++++++++++++++++++++++++++++++ tests/xfs/921.out | 4 + 4 files changed, 175 insertions(+), 2 deletions(-) create mode 100755 tests/xfs/921 create mode 100644 tests/xfs/921.out
common/rc +2 -2
@@ -2543,8 +2543,8 @@ _require_xfs_io_command() echo $testio | grep -q "Operation not supported" && \ _notrun "O_TMPFILE is not supported" ;; - "fsmap") - testio=`$XFS_IO_PROG -f -c "fsmap" $testfile 2>&1` + "fsmap"|"fsrefcounts") + testio=`$XFS_IO_PROG -f -c "$command" $testfile 2>&1` echo $testio | grep -q "Inappropriate ioctl" && \ _notrun "xfs_io $command support is missing" ;;
doc/group-names.txt +1 -0
@@ -56,6 +56,7 @@ freeze filesystem freeze tests fsck general fsck tests fsmap FS_IOC_GETFSMAP ioctl fsr XFS free space reorganizer +fsrefcounts FS_IOC_GETFSREFCOUNTS ioctl fuzzers filesystem fuzz tests growfs increasing the size of a filesystem hardlink hardlinks
tests/xfs/921 new file +168 -0
168 lines not on this page · raw message
tests/xfs/921.out new file +4 -0
@@ -0,0 +1,4 @@ +QA output created by 921 +Format and mount +Compare fsrefcounts +Compare fsrefcounts to fsmap
cover fstests: defragment free space
In reply to Darrick J. WongHi all,
These patches contain experimental code to enable userspace to defragment the free space in a filesystem. Two purposes are imagined for this
functionality: clearing space at the end of a filesystem before shrinking it, and clearing free space in anticipation of making a large allocation.
The first patch adds a new fallocate mode that allows userspace to allocate free space from the filesystem into a file. The goal here is to allow the filesystem shrink process to prevent allocation from a certain part of the filesystem while a free space defragmenter evacuates all the files from the doomed part of the filesystem.
The second patch amends the online repair system to allow the sysadmin to forcibly rebuild metadata structures, even if they're not corrupt. Without adding an ioctl to move metadata btree blocks, this is the only way to dislodge metadata.
If you're going to start using this mess, you probably ought to just pull from my git trees, which are linked below.
This is an extraordinary way to destroy everything. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=defrag-freespace
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=defrag-freespace
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=defrag-freespace
--- common/rc | 2 + tests/xfs/1400 | 57 +++++++++++++++++++++++++++++++++++++ tests/xfs/1400.out | 2 + tests/xfs/1401 | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++ tests/xfs/1401.out | 2 + 5 files changed, 142 insertions(+), 1 deletion(-) create mode 100755 tests/xfs/1400 create mode 100644 tests/xfs/1400.out create mode 100755 tests/xfs/1401 create mode 100644 tests/xfs/1401.out
PATCH 1/1 xfs: test clearing of free space
From: Darrick J. Wong <[email protected]>
Simple regression test for the spaceman clearspace command, which tries to free all the used space in some part of the filesystem.
--- common/rc | 2 + tests/xfs/1400 | 57 +++++++++++++++++++++++++++++++++++++ tests/xfs/1400.out | 2 + tests/xfs/1401 | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++ tests/xfs/1401.out | 2 + 5 files changed, 142 insertions(+), 1 deletion(-) create mode 100755 tests/xfs/1400 create mode 100644 tests/xfs/1400.out create mode 100755 tests/xfs/1401 create mode 100644 tests/xfs/1401.out
common/rc +1 -1
@@ -2512,7 +2512,7 @@ _require_xfs_io_command() testio=`$XFS_IO_PROG -F -f -c "$command $param 0 1m" $testfile 2>&1` param_checked="$param" ;; - "fpunch" | "fcollapse" | "zero" | "fzero" | "finsert" | "funshare") + "fpunch" | "fcollapse" | "zero" | "fzero" | "finsert" | "funshare" | "fmapfree") local blocksize=$(_get_file_block_size $TEST_DIR) testio=`$XFS_IO_PROG -F -f -c "pwrite 0 $((5 * $blocksize))" \ -c "fsync" -c "$command $blocksize $((2 * $blocksize))" \
tests/xfs/1400 new file +57 -0
57 lines not on this page · raw message
tests/xfs/1400.out new file +2 -0
@@ -0,0 +1,2 @@ +QA output created by 1400 +mapfree space used is in range
tests/xfs/1401 new file +80 -0
80 lines not on this page · raw message
tests/xfs/1401.out new file +2 -0
@@ -0,0 +1,2 @@ +QA output created by 1401 +Silence is golden