Bail out if transaction can cause extent count to overflow
PATCH v10 10/14 xfs: Introduce error injection to reduce maximum inode fork extent count
In reply to Chandan Babu RThis commit adds XFS_ERRTAG_REDUCE_MAX_IEXTENTS error tag which enables userspace programs to test "Inode fork extent count overflow detection" by reducing maximum possible inode fork extent count to 10.
--- fs/xfs/libxfs/xfs_errortag.h | 4 +++- fs/xfs/libxfs/xfs_inode_fork.c | 4 ++++ fs/xfs/xfs_error.c | 3 +++ 3 files changed, 10 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_errortag.h +3 -1
@@ -56,7 +56,8 @@#define XFS_ERRTAG_FORCE_SUMMARY_RECALC 33#define XFS_ERRTAG_IUNLINK_FALLBACK 34#define XFS_ERRTAG_BUF_IOERROR 35 -#define XFS_ERRTAG_MAX 36 +#define XFS_ERRTAG_REDUCE_MAX_IEXTENTS 36 +#define XFS_ERRTAG_MAX 37/* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -97,5 +98,6 @@#define XFS_RANDOM_FORCE_SUMMARY_RECALC 1#define XFS_RANDOM_IUNLINK_FALLBACK (XFS_RANDOM_DEFAULT/10)#define XFS_RANDOM_BUF_IOERROR XFS_RANDOM_DEFAULT +#define XFS_RANDOM_REDUCE_MAX_IEXTENTS 1#endif /* __XFS_ERRORTAG_H_ */
fs/xfs/libxfs/xfs_inode_fork.c +4 -0
@@ -24,6 +24,7 @@#include "xfs_dir2_priv.h" #include "xfs_attr_leaf.h" #include "xfs_types.h" +#include "xfs_errortag.h" kmem_zone_t *xfs_ifork_zone;
@@ -745,6 +746,9 @@ xfs_iext_count_may_overflow( max_exts = (whichfork ==XFS_ATTR_FORK ) ?MAXAEXTNUM :MAXEXTNUM ; +if (XFS_TEST_ERROR (false, ip->i_mount,XFS_ERRTAG_REDUCE_MAX_IEXTENTS )) + max_exts =10 ; + nr_exts = ifp->if_nextents + nr_to_add;if (nr_exts < ifp->if_nextents || nr_exts > max_exts)return -EFBIG ;
fs/xfs/xfs_error.c +3 -0
@@ -54,6 +54,7 @@ static unsigned int xfs_errortag_random_default[] = {XFS_RANDOM_FORCE_SUMMARY_RECALC ,XFS_RANDOM_IUNLINK_FALLBACK ,XFS_RANDOM_BUF_IOERROR , + XFS_RANDOM_REDUCE_MAX_IEXTENTS, }; struct xfs_errortag_attr {
@@ -164,6 +165,7 @@ XFS_ERRORTAG_ATTR_RW(force_repair, XFS_ERRTAG_FORCE_SCRUB_REPAIR);XFS_ERRORTAG_ATTR_RW (bad_summary,XFS_ERRTAG_FORCE_SUMMARY_RECALC );XFS_ERRORTAG_ATTR_RW (iunlink_fallback,XFS_ERRTAG_IUNLINK_FALLBACK );XFS_ERRORTAG_ATTR_RW (buf_ioerror,XFS_ERRTAG_BUF_IOERROR ); +XFS_ERRORTAG_ATTR_RW (reduce_max_iextents,XFS_ERRTAG_REDUCE_MAX_IEXTENTS );static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (noerror),
@@ -202,6 +204,7 @@ static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (bad_summary),XFS_ERRORTAG_ATTR_LIST (iunlink_fallback),XFS_ERRORTAG_ATTR_LIST (buf_ioerror), +XFS_ERRORTAG_ATTR_LIST (reduce_max_iextents), NULL, };
Signature · 1 line
2.28.0
PATCH v10 11/14 xfs: Remove duplicate assert statement in xfs_bmap_btalloc()
In reply to Chandan Babu RThe check for verifying if the allocated extent is from an AG whose index is greater than or equal to that of tp->t_firstblock is already done a couple of statements earlier in the same function. Hence this commit removes the redundant assert statement.
--- fs/xfs/libxfs/xfs_bmap.c | 1 - 1 file changed, 1 deletion(-)
fs/xfs/libxfs/xfs_bmap.c +0 -1
@@ -3699,7 +3699,6 @@ xfs_bmap_btalloc( ap->blkno = args.fsbno;if (ap->tp->t_firstblock ==NULLFSBLOCK ) ap->tp->t_firstblock = args.fsbno; -ASSERT (nullfb || fb_agno <= args.agno); ap->length = args.len;/* * If the extent size hint is active, we tried to round the
Signature · 1 line
2.28.0
PATCH v10 12/14 xfs: Compute bmap extent alignments in a separate function
In reply to Chandan Babu RThis commit moves over the code which computes stripe alignment and extent size hint alignment into a separate function. Apart from xfs_bmap_btalloc(), the new function will be used by another function introduced in a future commit.
--- fs/xfs/libxfs/xfs_bmap.c | 89 +++++++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 37 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +52 -37
@@ -3463,13 +3463,59 @@ xfs_bmap_btalloc_accounting( args->len); } +static int +xfs_bmap_compute_alignments ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args) +{ +struct xfs_mount *mp = args->mp; +xfs_extlen_t align =0 ;/* minimum allocation alignment */ +int stripe_align =0 ; +int error; + +/* stripe alignment for allocation is determined by mount parameters */ +if (mp->m_swidth && (mp->m_flags &XFS_MOUNT_SWALLOC )) + stripe_align = mp->m_swidth; +else if (mp->m_dalign) + stripe_align = mp->m_dalign; + +if (ap->flags &XFS_BMAPI_COWFORK ) + align =xfs_get_cowextsz_hint (ap->ip); +else if (ap->datatype &XFS_ALLOC_USERDATA ) + align =xfs_get_extsz_hint (ap->ip); +if (align) { + error =xfs_bmap_extsize_align (mp, &ap->got, &ap->prev, + align,0 , ap->eof,0 , ap->conv, + &ap->offset, &ap->length); +ASSERT (!error); +ASSERT (ap->length); + } + +/* apply extent size hints if obtained earlier */ +if (align) { + args->prod = align; +div_u64_rem (ap->offset, args->prod, &args->mod); +if (args->mod) + args->mod = args->prod - args->mod; + }else if (mp->m_sb.sb_blocksize >=PAGE_SIZE ) { + args->prod =1 ; + args->mod =0 ; + }else { + args->prod =PAGE_SIZE >> mp->m_sb.sb_blocklog; +div_u64_rem (ap->offset, args->prod, &args->mod); +if (args->mod) + args->mod = args->prod - args->mod; + } + +return stripe_align; +} + STATIC intxfs_bmap_btalloc (struct xfs_bmalloca *ap)/* bmap alloc argument struct */ {xfs_mount_t *mp;/* mount point structure */ xfs_alloctype_t atype =0 ;/* type for allocation routines */ -xfs_extlen_t align =0 ;/* minimum allocation alignment */ xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ xfs_agnumber_t ag;xfs_alloc_arg_t args;
@@ -3489,25 +3535,11 @@ xfs_bmap_btalloc( mp = ap->ip->i_mount; -/* stripe alignment for allocation is determined by mount parameters */ - stripe_align =0 ; -if (mp->m_swidth && (mp->m_flags &XFS_MOUNT_SWALLOC )) - stripe_align = mp->m_swidth; -else if (mp->m_dalign) - stripe_align = mp->m_dalign; - -if (ap->flags &XFS_BMAPI_COWFORK ) - align =xfs_get_cowextsz_hint (ap->ip); -else if (ap->datatype &XFS_ALLOC_USERDATA ) - align =xfs_get_extsz_hint (ap->ip); -if (align) { - error =xfs_bmap_extsize_align (mp, &ap->got, &ap->prev, - align,0 , ap->eof,0 , ap->conv, - &ap->offset, &ap->length); -ASSERT (!error); -ASSERT (ap->length); - } +memset (&args,0 ,sizeof (args)); + args.tp = ap->tp; + args.mp = mp; + stripe_align =xfs_bmap_compute_alignments (ap, &args); nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ; fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,
@@ -3538,9 +3570,6 @@ xfs_bmap_btalloc(* Normal allocation, done through xfs_alloc_vextent. */ tryagain = isaligned =0 ; -memset (&args,0 ,sizeof (args)); - args.tp = ap->tp; - args.mp = mp; args.fsbno = ap->blkno; args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ;
@@ -3571,21 +3600,7 @@ xfs_bmap_btalloc( args.total = ap->total; args.minlen = ap->minlen; } -/* apply extent size hints if obtained earlier */ -if (align) { - args.prod = align; -div_u64_rem (ap->offset, args.prod, &args.mod); -if (args.mod) - args.mod = args.prod - args.mod; - }else if (mp->m_sb.sb_blocksize >=PAGE_SIZE ) { - args.prod =1 ; - args.mod =0 ; - }else { - args.prod =PAGE_SIZE >> mp->m_sb.sb_blocklog; -div_u64_rem (ap->offset, args.prod, &args.mod); -if (args.mod) - args.mod = args.prod - args.mod; - } +/* * If we are not low on available data blocks, and the underlying * logical volume manager is a stripe, and the file offset is zero then
Signature · 1 line
2.28.0
PATCH v10 14/14 xfs: Introduce error injection to allocate only minlen size extents for files
In reply to Chandan Babu RThis commit adds XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT error tag which helps userspace test programs to get xfs_bmap_btalloc() to always allocate minlen sized extents.
This is required for test programs which need a guarantee that minlen extents allocated for a file do not get merged with their existing neighbours in the inode's BMBT. "Inode fork extent overflow check" for Directories, Xattrs and extension of realtime inodes need this since the file offset at which the extents are being allocated cannot be explicitly controlled from userspace.
One way to use this error tag is to,
1. Consume all of the free space by sequentially writing to a file.
2. Punch alternate blocks of the file. This causes CNTBT to contain sufficient number of one block sized extent records.
3. Inject XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT error tag. After step 3, xfs_bmap_btalloc() will issue space allocation requests for minlen sized extents only.
ENOSPC error code is returned to userspace when there aren't any "one block sized" extents left in any of the AGs.
--- fs/xfs/libxfs/xfs_alloc.c | 50 ++++++++++++++ fs/xfs/libxfs/xfs_alloc.h | 3 + fs/xfs/libxfs/xfs_bmap.c | 124 ++++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_errortag.h | 4 +- fs/xfs/xfs_error.c | 3 + 5 files changed, 159 insertions(+), 25 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +50 -0
@@ -2473,6 +2473,47 @@ xfs_defer_agfl_block(xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_AGFL_FREE , &new->xefi_list); } +#ifdef DEBUG +/* +* Check if an AGF has a free extent record whose length is equal to +* args->minlen. +*/ +STATIC int +xfs_exact_minlen_extent_available ( +struct xfs_alloc_arg *args, +struct xfs_buf *agbp, +int *stat) +{ +struct xfs_btree_cur *cnt_cur; +xfs_agblock_t fbno; +xfs_extlen_t flen; +int error =0 ; + + cnt_cur =xfs_allocbt_init_cursor (args->mp, args->tp, agbp, + args->agno,XFS_BTNUM_CNT ); + error =xfs_alloc_lookup_ge (cnt_cur,0 , args->minlen, stat); +if (error) + goto out; + +if (*stat ==0 ) { + error = -EFSCORRUPTED ; + goto out; + } + + error =xfs_alloc_get_rec (cnt_cur, &fbno, &flen, stat); +if (error) + goto out; + +if (*stat ==1 && flen != args->minlen) + *stat =0 ; + +out: +xfs_btree_del_cursor (cnt_cur, error); + +return error; +} +#endif +/* * Decide whether to use this allocation group for this allocation. * If so, fix up the btree freelist's size.
@@ -2544,6 +2585,15 @@ xfs_alloc_fix_freelist(if (!xfs_alloc_space_available (args, need, flags)) goto out_agbp_relse; +#ifdef DEBUG +if (args->alloc_minlen_only) { +int stat; + + error =xfs_exact_minlen_extent_available (args, agbp, &stat); +if (error || !stat) + goto out_agbp_relse; + } +#endif /* * Make the freelist shorter if it's too long. *
fs/xfs/libxfs/xfs_alloc.h +3 -0
@@ -75,6 +75,9 @@ typedef struct xfs_alloc_arg {char wasfromfl;/* set if allocation is from freelist */ struct xfs_owner_info oinfo;/* owner of blocks being allocated */ enum xfs_ag_resv_type resv;/* block reservation to use */ +#ifdef DEBUG +bool alloc_minlen_only;/* allocate exact minlen extent */ +#endif } xfs_alloc_arg_t;/*
fs/xfs/libxfs/xfs_bmap.c +100 -24
152 lines not on this page · raw message
fs/xfs/libxfs/xfs_errortag.h +3 -1
@@ -57,7 +57,8 @@#define XFS_ERRTAG_IUNLINK_FALLBACK 34#define XFS_ERRTAG_BUF_IOERROR 35#define XFS_ERRTAG_REDUCE_MAX_IEXTENTS 36 -#define XFS_ERRTAG_MAX 37 +#define XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT 37 +#define XFS_ERRTAG_MAX 38/* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -99,5 +100,6 @@#define XFS_RANDOM_IUNLINK_FALLBACK (XFS_RANDOM_DEFAULT/10)#define XFS_RANDOM_BUF_IOERROR XFS_RANDOM_DEFAULT#define XFS_RANDOM_REDUCE_MAX_IEXTENTS 1 +#define XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT 1#endif /* __XFS_ERRORTAG_H_ */
fs/xfs/xfs_error.c +3 -0
@@ -55,6 +55,7 @@ static unsigned int xfs_errortag_random_default[] = {XFS_RANDOM_IUNLINK_FALLBACK ,XFS_RANDOM_BUF_IOERROR ,XFS_RANDOM_REDUCE_MAX_IEXTENTS , + XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT, }; struct xfs_errortag_attr {
@@ -166,6 +167,7 @@ XFS_ERRORTAG_ATTR_RW(bad_summary, XFS_ERRTAG_FORCE_SUMMARY_RECALC);XFS_ERRORTAG_ATTR_RW (iunlink_fallback,XFS_ERRTAG_IUNLINK_FALLBACK );XFS_ERRORTAG_ATTR_RW (buf_ioerror,XFS_ERRTAG_BUF_IOERROR );XFS_ERRORTAG_ATTR_RW (reduce_max_iextents,XFS_ERRTAG_REDUCE_MAX_IEXTENTS ); +XFS_ERRORTAG_ATTR_RW (bmap_alloc_minlen_extent,XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT );static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (noerror),
@@ -205,6 +207,7 @@ static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (iunlink_fallback),XFS_ERRORTAG_ATTR_LIST (buf_ioerror),XFS_ERRORTAG_ATTR_LIST (reduce_max_iextents), +XFS_ERRORTAG_ATTR_LIST (bmap_alloc_minlen_extent), NULL, };
Signature · 1 line
2.28.0
PATCH v10 13/14 xfs: Process allocated extent in a separate function
In reply to Chandan Babu RThis commit moves over the code in xfs_bmap_btalloc() which is responsible for processing an allocated extent to a new function. Apart from xfs_bmap_btalloc(), the new function will be invoked by another function introduced in a future commit.
--- fs/xfs/libxfs/xfs_bmap.c | 74 ++++++++++++++++++++++++---------------- 1 file changed, 45 insertions(+), 29 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +45 -29
@@ -3510,6 +3510,48 @@ xfs_bmap_compute_alignments(return stripe_align; } +static void +xfs_bmap_process_allocated_extent ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args, +xfs_fileoff_t orig_offset, +xfs_extlen_t orig_length) +{ +int nullfb; + + nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ; + +/* +* check the allocation happened at the same or higher AG than +* the first block that was allocated. +*/ +ASSERT (nullfb || +XFS_FSB_TO_AGNO (args->mp, ap->tp->t_firstblock) <= +XFS_FSB_TO_AGNO (args->mp, args->fsbno)); + + ap->blkno = args->fsbno; +if (nullfb) + ap->tp->t_firstblock = args->fsbno; + ap->length = args->len; +/* +* If the extent size hint is active, we tried to round the +* caller's allocation request offset down to extsz and the +* length up to another extsz boundary. If we found a free +* extent we mapped it in starting at this new offset. If the +* newly mapped space isn't long enough to cover any of the +* range of offsets that was originally requested, move the +* mapping up so that we can fill as much of the caller's +* original request as possible. Free space is apparently +* very fragmented so we're unlikely to be able to satisfy the +* hints anyway. +*/ +if (ap->length <= orig_length) + ap->offset = orig_offset; +else if (ap->offset + ap->length < orig_offset + orig_length) + ap->offset = orig_offset + orig_length - ap->length; +xfs_bmap_btalloc_accounting (ap, args); +} + STATIC intxfs_bmap_btalloc (struct xfs_bmalloca *ap)/* bmap alloc argument struct */
@@ -3702,36 +3744,10 @@ xfs_bmap_btalloc(return error; ap->tp->t_flags |=XFS_TRANS_LOWMODE ; } +if (args.fsbno !=NULLFSBLOCK ) { -/* -* check the allocation happened at the same or higher AG than -* the first block that was allocated. -*/ -ASSERT (ap->tp->t_firstblock ==NULLFSBLOCK || -XFS_FSB_TO_AGNO (mp, ap->tp->t_firstblock) <= -XFS_FSB_TO_AGNO (mp, args.fsbno)); - - ap->blkno = args.fsbno; -if (ap->tp->t_firstblock ==NULLFSBLOCK ) - ap->tp->t_firstblock = args.fsbno; - ap->length = args.len; -/* -* If the extent size hint is active, we tried to round the -* caller's allocation request offset down to extsz and the -* length up to another extsz boundary. If we found a free -* extent we mapped it in starting at this new offset. If the -* newly mapped space isn't long enough to cover any of the -* range of offsets that was originally requested, move the -* mapping up so that we can fill as much of the caller's -* original request as possible. Free space is apparently -* very fragmented so we're unlikely to be able to satisfy the -* hints anyway. -*/ -if (ap->length <= orig_length) - ap->offset = orig_offset; -else if (ap->offset + ap->length < orig_offset + orig_length) - ap->offset = orig_offset + orig_length - ap->length; -xfs_bmap_btalloc_accounting (ap, &args); +xfs_bmap_process_allocated_extent (ap, &args, orig_offset, + orig_length); }else { ap->blkno =NULLFSBLOCK ; ap->length =0 ;
Signature · 1 line
2.28.0
PATCH v10 9/14 xfs: Check for extent overflow when swapping extents
In reply to Chandan Babu RRemoving an initial range of source/donor file's extent and adding a new extent (from donor/source file) in its place will cause extent count to increase by 1.
--- fs/xfs/libxfs/xfs_inode_fork.h | 7 +++++++ fs/xfs/xfs_bmap_util.c | 16 ++++++++++++++++ 2 files changed, 23 insertions(+)
fs/xfs/libxfs/xfs_inode_fork.h +7 -0
@@ -87,6 +87,13 @@ struct xfs_ifork {*/ #define XFS_IEXT_REFLINK_END_COW_CNT (2) +/* +* Removing an initial range of source/donor file's extent and adding a new +* extent (from donor/source file) in its place will cause extent count to +* increase by 1. +*/ +#define XFS_IEXT_SWAP_RMAP_CNT (1) +/* * Fork handling. */
fs/xfs/xfs_bmap_util.c +16 -0
@@ -1407,6 +1407,22 @@ xfs_swap_extent_rmap( irec.br_blockcount);trace_xfs_swap_extent_rmap_remap_piece (tip, &uirec); +if (xfs_bmap_is_real_extent (&uirec)) { + error =xfs_iext_count_may_overflow (ip, +XFS_DATA_FORK , +XFS_IEXT_SWAP_RMAP_CNT ); +if (error) + goto out; + } + +if (xfs_bmap_is_real_extent (&irec)) { + error =xfs_iext_count_may_overflow (tip, +XFS_DATA_FORK , +XFS_IEXT_SWAP_RMAP_CNT ); +if (error) + goto out; + } +/* Remove the mapping from the donor file. */ xfs_bmap_unmap_extent (tp, tip, &uirec);
Signature · 1 line
2.28.0
PATCH v10 6/14 xfs: Check for extent overflow when writing to unwritten extent
In reply to Chandan Babu RA write to a sub-interval of an existing unwritten extent causes the original extent to be split into 3 extents
i.e. | Unwritten | Real | Unwritten |
Hence extent count can increase by 2.
--- fs/xfs/libxfs/xfs_inode_fork.h | 8 ++++++++ fs/xfs/xfs_iomap.c | 5 +++++ 2 files changed, 13 insertions(+)
fs/xfs/libxfs/xfs_inode_fork.h +8 -0
@@ -70,6 +70,14 @@ struct xfs_ifork {#define XFS_IEXT_DIR_MANIP_CNT (mp) \ ((XFS_DA_NODE_MAXDEPTH + 1 + 1) * (mp)->m_dir_geo->fsbcount) +/* +* A write to a sub-interval of an existing unwritten extent causes the original +* extent to be split into 3 extents +* i.e. | Unwritten | Real | Unwritten | +* Hence extent count can increase by 2. +*/ +#define XFS_IEXT_WRITE_UNWRITTEN_CNT (2) +/* * Fork handling. */
fs/xfs/xfs_iomap.c +5 -0
@@ -566,6 +566,11 @@ xfs_iomap_write_unwritten(if (error) goto error_on_bmapi_transaction; + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_WRITE_UNWRITTEN_CNT ); +if (error) + goto error_on_bmapi_transaction; +/* * Modify the unwritten extent state of the buffer. */
Signature · 1 line
2.28.0
PATCH v10 7/14 xfs: Check for extent overflow when moving extent from cow to data fork
In reply to Chandan Babu RMoving an extent to data fork can cause a sub-interval of an existing extent to be unmapped. This will increase extent count by 1. Mapping in the new extent can increase the extent count by 1 again i.e.
| Old extent | New extent | Old extent |
Hence number of extents increases by 2.
--- fs/xfs/libxfs/xfs_inode_fork.h | 9 +++++++++ fs/xfs/xfs_reflink.c | 5 +++++ 2 files changed, 14 insertions(+)
fs/xfs/libxfs/xfs_inode_fork.h +9 -0
@@ -78,6 +78,15 @@ struct xfs_ifork {*/ #define XFS_IEXT_WRITE_UNWRITTEN_CNT (2) +/* +* Moving an extent to data fork can cause a sub-interval of an existing extent +* to be unmapped. This will increase extent count by 1. Mapping in the new +* extent can increase the extent count by 1 again i.e. +* | Old extent | New extent | Old extent | +* Hence number of extents increases by 2. +*/ +#define XFS_IEXT_REFLINK_END_COW_CNT (2) +/* * Fork handling. */
fs/xfs/xfs_reflink.c +5 -0
@@ -628,6 +628,11 @@ xfs_reflink_end_cow_extent(xfs_ilock (ip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,0 ); + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_REFLINK_END_COW_CNT ); +if (error) + goto out_cancel; +/* * In case of racing, overlapping AIO writes no COW extents might be * left by the time I/O completes for the loser of the race. In that
Signature · 1 line
2.28.0
PATCH v10 8/14 xfs: Check for extent overflow when remapping an extent
In reply to Chandan Babu RRemapping an extent involves unmapping the existing extent and mapping in the new extent. When unmapping, an extent containing the entire unmap range can be split into two extents,
i.e. | Old extent | hole | Old extent |
Hence extent count increases by 1.
Mapping in the new extent into the destination file can increase the extent count by 1.
--- fs/xfs/xfs_reflink.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
fs/xfs/xfs_reflink.c +11 -0
@@ -1006,6 +1006,7 @@ xfs_reflink_remap_extent(unsigned int resblks;bool smap_real;bool dmap_written =xfs_bmap_is_written_extent (dmap); +int iext_delta =0 ;int nimaps;int error;
@@ -1099,6 +1100,16 @@ xfs_reflink_remap_extent( goto out_cancel; } +if (smap_real) + ++iext_delta; + +if (dmap_written) + ++iext_delta; + + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , iext_delta); +if (error) + goto out_cancel; +if (smap_real) {/* * If the extent we're unmapping is backed by storage (written
Signature · 1 line
2.28.0
PATCH v10 4/14 xfs: Check for extent overflow when adding/removing xattrs
In reply to Chandan Babu RAdding/removing an xattr can cause XFS_DA_NODE_MAXDEPTH extents to be added. One extra extent for dabtree in case a local attr is large enough to cause a double split. It can also cause extent count to increase proportional to the size of a remote xattr's value.
--- fs/xfs/libxfs/xfs_attr.c | 13 +++++++++++++ fs/xfs/libxfs/xfs_inode_fork.h | 10 ++++++++++ 2 files changed, 23 insertions(+)
fs/xfs/libxfs/xfs_attr.c +13 -0
@@ -396,6 +396,7 @@ xfs_attr_set(struct xfs_trans_res tres;bool rsvd = (args->attr_filter &XFS_ATTR_ROOT );int error, local; +int rmt_blks =0 ;unsigned int total;if (XFS_FORCED_SHUTDOWN (dp->i_mount))
@@ -442,11 +443,15 @@ xfs_attr_set( tres.tr_logcount =XFS_ATTRSET_LOG_COUNT ; tres.tr_logflags =XFS_TRANS_PERM_LOG_RES ; total = args->total; + +if (!local) + rmt_blks =xfs_attr3_rmt_blocks (mp, args->valuelen); }else {XFS_STATS_INC (mp, xs_attr_remove); tres =M_RES (mp)->tr_attrrm; total =XFS_ATTRRM_SPACE_RES (mp); + rmt_blks =xfs_attr3_rmt_blocks (mp,XFS_XATTR_SIZE_MAX ); }/*
@@ -460,6 +465,14 @@ xfs_attr_set(xfs_ilock (dp,XFS_ILOCK_EXCL );xfs_trans_ijoin (args->trans, dp,0 ); + +if (args->value ||xfs_inode_hasattr (dp)) { + error =xfs_iext_count_may_overflow (dp,XFS_ATTR_FORK , +XFS_IEXT_ATTR_MANIP_CNT (rmt_blks)); +if (error) + goto out_trans_cancel; + } +if (args->value) {unsigned int quota_flags =XFS_QMOPT_RES_REGBLKS ;
fs/xfs/libxfs/xfs_inode_fork.h +10 -0
@@ -47,6 +47,16 @@ struct xfs_ifork {*/ #define XFS_IEXT_PUNCH_HOLE_CNT (1) +/* +* Adding/removing an xattr can cause XFS_DA_NODE_MAXDEPTH extents to +* be added. One extra extent for dabtree in case a local attr is +* large enough to cause a double split. It can also cause extent +* count to increase proportional to the size of a remote xattr's +* value. +*/ +#define XFS_IEXT_ATTR_MANIP_CNT (rmt_blks) \ + (XFS_DA_NODE_MAXDEPTH + max(1, rmt_blks)) +/* * Fork handling. */
Signature · 1 line
2.28.0
PATCH v10 5/14 xfs: Check for extent overflow when adding/removing dir entries
In reply to Chandan Babu RDirectory entry addition/removal can cause the following,
1. Data block can be added/removed.
A new extent can cause extent count to increase by 1.
2. Free disk block can be added/removed.
Same behaviour as described above for Data block.
3. Dabtree blocks.
XFS_DA_NODE_MAXDEPTH blocks can be added. Each of these can be new extents. Hence extent count can increase by XFS_DA_NODE_MAXDEPTH.
--- fs/xfs/libxfs/xfs_inode_fork.h | 13 +++++++++++++ fs/xfs/xfs_inode.c | 27 +++++++++++++++++++++++++++ fs/xfs/xfs_symlink.c | 5 +++++ 3 files changed, 45 insertions(+)
fs/xfs/libxfs/xfs_inode_fork.h +13 -0
@@ -57,6 +57,19 @@ struct xfs_ifork {#define XFS_IEXT_ATTR_MANIP_CNT (rmt_blks) \ (XFS_DA_NODE_MAXDEPTH + max(1, rmt_blks)) +/* +* Directory entry addition/removal can cause the following, +* 1. Data block can be added/removed. +* A new extent can cause extent count to increase by 1. +* 2. Free disk block can be added/removed. +* Same behaviour as described above for Data block. +* 3. Dabtree blocks. +* XFS_DA_NODE_MAXDEPTH blocks can be added. Each of these can be new +* extents. Hence extent count can increase by XFS_DA_NODE_MAXDEPTH. +*/ +#define XFS_IEXT_DIR_MANIP_CNT (mp) \ + ((XFS_DA_NODE_MAXDEPTH + 1 + 1) * (mp)->m_dir_geo->fsbcount) +/* * Fork handling. */
fs/xfs/xfs_inode.c +27 -0
@@ -1177,6 +1177,11 @@ xfs_create(if (error) goto out_trans_cancel; + error =xfs_iext_count_may_overflow (dp,XFS_DATA_FORK , +XFS_IEXT_DIR_MANIP_CNT (mp)); +if (error) + goto out_trans_cancel; +/* * A newly created regular or special file just has one directory * entry pointing to them, but a directory also the "." entry
@@ -1393,6 +1398,11 @@ xfs_link(xfs_trans_ijoin (tp, sip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, tdp,XFS_ILOCK_EXCL ); + error =xfs_iext_count_may_overflow (tdp,XFS_DATA_FORK , +XFS_IEXT_DIR_MANIP_CNT (mp)); +if (error) + goto error_return; +/* * If we are using project inheritance, we only allow hard link * creation in our tree when the project IDs are the same; else
@@ -2861,6 +2871,11 @@ xfs_remove(xfs_trans_ijoin (tp, dp,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,XFS_ILOCK_EXCL ); + error =xfs_iext_count_may_overflow (dp,XFS_DATA_FORK , +XFS_IEXT_DIR_MANIP_CNT (mp)); +if (error) + goto out_trans_cancel; +/* * If we're removing a directory perform some additional validation. */
@@ -3221,6 +3236,18 @@ xfs_rename(if (wip)xfs_trans_ijoin (tp, wip,XFS_ILOCK_EXCL ); + error =xfs_iext_count_may_overflow (src_dp,XFS_DATA_FORK , +XFS_IEXT_DIR_MANIP_CNT (mp)); +if (error) + goto out_trans_cancel; + +if (target_ip ==NULL ) { + error =xfs_iext_count_may_overflow (target_dp,XFS_DATA_FORK , +XFS_IEXT_DIR_MANIP_CNT (mp)); +if (error) + goto out_trans_cancel; + } +/* * If we are using project inheritance, we only allow renames * into our tree when the project IDs are the same; else the
fs/xfs/xfs_symlink.c +5 -0
@@ -220,6 +220,11 @@ xfs_symlink(if (error) goto out_trans_cancel; + error =xfs_iext_count_may_overflow (dp,XFS_DATA_FORK , +XFS_IEXT_DIR_MANIP_CNT (mp)); +if (error) + goto out_trans_cancel; +/* * Allocate an inode for the symlink. */
Signature · 1 line
2.28.0
v10 cover Bail out if transaction can cause extent count to overflow
XFS does not check for possible overflow of per-inode extent counter fields when adding extents to either data or attr fork.
For e.g.
1. Insert 5 million xattrs (each having a value size of 255 bytes) and then delete 50% of them in an alternating manner.
2. On a 4k block sized XFS filesystem instance, the above causes 98511 extents to be created in the attr fork of the inode.
xfsaild/loop0 2008 [003] 1475.127209: probe:xfs_inode_to_disk: (ffffffffa43fb6b0) if_nextents=98511 i_ino=131
3. The incore inode fork extent counter is a signed 32-bit quantity. However, the on-disk extent counter is an unsigned 16-bit quantity and hence cannot hold 98511 extents.
4. The following incorrect value is stored in the xattr extent counter,
# xfs_db -f -c 'inode 131' -c 'print core.naextents' /dev/loop0 core.naextents = -32561
This patchset adds a new helper function
(i.e. xfs_iext_count_may_overflow()) to check for overflow of the per-inode data and xattr extent counters and invokes it before starting an fs operation (e.g. creating a new directory entry). With this patchset applied, XFS detects counter overflows and returns with an error rather than causing a silent corruption.
The patchset has been tested by executing xfstests with the following mkfs.xfs options,
1. -m crc=0 -b size=1k
2. -m crc=0 -b size=4k
3. -m crc=0 -b size=512
4. -m rmapbt=1,reflink=1 -b size=1k
5. -m rmapbt=1,reflink=1 -b size=4k
The patches can also be obtained from
https://github.com/chandanr/linux.git at branch xfs-reserve-extent-count-v10.
I have two patches that define the newly introduced error injection tags in xfsprogs
(https://github.com/chandanr/xfsprogs-dev/commit/7fd7aeef1cefbcc9abd6dd5887e710c80e48079d
and
https://github.com/chandanr/xfsprogs-dev/commit/3cbe12f6fdf306de06c4096eb50641fa2d834dc5).
I have also written tests
(https://github.com/chandanr/xfstests/commits/extent-overflow-tests)
for verifying the checks introduced in the kernel. They depend on error tags introduced in these patches . Hence, I am planning to post the changes for xfsprogs and xfstests if other developers are fine with the changes made in this patchset.
Changelog:
V9 -> V10:
1. Pull back changes which cause xfs_bmap_compute_alignments() to return "stripe alignment" into 12th patch i.e. "xfs: Compute bmap extent alignments in a separate function".
V8 -> V9:
1. Enabling XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT error tag will always allocate single block sized free extents (if available).
2. xfs_bmap_compute_alignments() now returns stripe alignment as its return value.
3. Dropped Allison's RVB tag for "xfs: Compute bmap extent alignments in a separate function" and "xfs: Introduce error injection to allocate only minlen size extents for files".
V7 -> V8:
1. Rename local variable in xfs_alloc_fix_freelist() from "i" to "stat".
V6 -> V7:
1. Create new function xfs_bmap_exact_minlen_extent_alloc() (enabled only when CONFIG_XFS_DEBUG is set to y) which issues allocation requests for minlen sized extents only. In order to achieve this, common code from xfs_bmap_btalloc() have been refactored into new functions.
2. All major functions implementing logic associated with XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT error tag are compiled only when CONFIG_XFS_DEBUG is set to y.
3. Remove XFS_IEXT_REFLINK_REMAP_CNT macro and replace it with an integer which holds the number of new extents to be added to the data fork.
V5 -> V6:
1. Rebased the patchset on xfs-linux/for-next branch.
2. Drop "xfs: Set tp->t_firstblock only once during a transaction's lifetime" patch from the patchset.
3. Add a comment to xfs_bmap_btalloc() describing why it was chosen to start "free space extent search" from AG 0 when XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is enabled and when the transaction is allocating its first extent.
4. Fix review comments associated with coding style.
V4 -> V5:
1. Introduce new error tag XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT to let user space programs to be able to guarantee that free space requests for files are satisfied by allocating minlen sized extents.
2. Change xfs_bmap_btalloc() and xfs_alloc_vextent() to allocate minlen sized extents when XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is enabled.
3. Introduce a new patch that causes tp->t_firstblock to be assigned to a value only when its previous value is NULLFSBLOCK.
4. Replace the previously introduced MAXERRTAGEXTNUM (maximum inode fork extent count) with the hardcoded value of 10.
5. xfs_bui_item_recover(): Use XFS_IEXT_ADD_NOSPLIT_CNT when mapping an extent.
6. xfs_swap_extent_rmap(): Use xfs_bmap_is_real_extent() instead of xfs_bmap_is_update_needed() to assess if the extent really needs to be swapped.
V3 -> V4:
1. Introduce new patch which lets userspace programs to test "extent count overflow detection" by injecting an error tag. The new error tag reduces the maximum allowed extent count to 10.
2. Injecting the newly defined error tag prevents xfs_bmap_add_extent_hole_real() from merging a new extent with its neighbours to allow writing deterministic tests for testing extent count overflow for Directories, Xattr and growing realtime devices. This is required because the new extent being allocated can be contiguous with its neighbours (w.r.t both file and disk offsets).
3. Injecting the newly defined error tag forces block sized extents to be allocated for summary/bitmap files when growing a realtime device. This is required because xfs_growfs_rt_alloc() allocates as large an extent as possible for summary/bitmap files and hence it would be impossible to write deterministic tests.
4. Rename XFS_IEXT_REMOVE_CNT to XFS_IEXT_PUNCH_HOLE_CNT to reflect the actual meaning of the fs operation.
5. Fold XFS_IEXT_INSERT_HOLE_CNT code into that associated with XFS_IEXT_PUNCH_HOLE_CNT since both perform the same job.
6. xfs_swap_extent_rmap(): Check for extent overflow should be made on the source file only if the donor file extent has a valid on-disk mapping and vice versa.
V2 -> V3:
1. Move the definition of xfs_iext_count_may_overflow() from libxfs/xfs_trans_resv.c to libxfs/xfs_inode_fork.c. Also, I tried to make xfs_iext_count_may_overflow() an inline function by placing the definition in libxfs/xfs_inode_fork.h. However this required that the definition of 'struct xfs_inode' be available, since xfs_iext_count_may_overflow() uses a 'struct xfs_inode *' type variable.
2. Handle XFS_COW_FORK within xfs_iext_count_may_overflow() by returning a success value.
3. Rename XFS_IEXT_ADD_CNT to XFS_IEXT_ADD_NOSPLIT_CNT. Thanks to Darrick for the suggesting the new name.
4. Expand comments to make use of 80 columns.
V1 -> V2:
1. Rename helper function from xfs_trans_resv_ext_cnt() to xfs_iext_count_may_overflow().
2. Define and use macros to represent fs operations and the corresponding increase in extent count.
3. Split the patches based on the fs operation being performed.
Chandan Babu R (14):
xfs: Add helper for checking per-inode extent count overflow
xfs: Check for extent overflow when trivally adding a new extent
xfs: Check for extent overflow when punching a hole
xfs: Check for extent overflow when adding/removing xattrs
xfs: Check for extent overflow when adding/removing dir entries
xfs: Check for extent overflow when writing to unwritten extent
xfs: Check for extent overflow when moving extent from cow to data
fork
xfs: Check for extent overflow when remapping an extent
xfs: Check for extent overflow when swapping extents
xfs: Introduce error injection to reduce maximum inode fork extent
count
xfs: Remove duplicate assert statement in xfs_bmap_btalloc()
xfs: Compute bmap extent alignments in a separate function
xfs: Process allocated extent in a separate function
xfs: Introduce error injection to allocate only minlen size extents
for files
fs/xfs/libxfs/xfs_alloc.c | 50 +++++++ fs/xfs/libxfs/xfs_alloc.h | 3 + fs/xfs/libxfs/xfs_attr.c | 13 ++ fs/xfs/libxfs/xfs_bmap.c | 266 +++++++++++++++++++++++---------- fs/xfs/libxfs/xfs_errortag.h | 6 +- fs/xfs/libxfs/xfs_inode_fork.c | 27 ++++ fs/xfs/libxfs/xfs_inode_fork.h | 62 ++++++++ fs/xfs/xfs_bmap_item.c | 10 ++ fs/xfs/xfs_bmap_util.c | 31 ++++ fs/xfs/xfs_dquot.c | 8 +- fs/xfs/xfs_error.c | 6 + fs/xfs/xfs_inode.c | 27 ++++ fs/xfs/xfs_iomap.c | 10 ++ fs/xfs/xfs_reflink.c | 16 ++ fs/xfs/xfs_rtalloc.c | 5 + fs/xfs/xfs_symlink.c | 5 + 16 files changed, 466 insertions(+), 79 deletions(-)
Signature · 1 line
2.28.0
PATCH v10 1/14 xfs: Add helper for checking per-inode extent count overflow
XFS does not check for possible overflow of per-inode extent counter fields when adding extents to either data or attr fork.
For e.g.
1. Insert 5 million xattrs (each having a value size of 255 bytes) and then delete 50% of them in an alternating manner.
2. On a 4k block sized XFS filesystem instance, the above causes 98511 extents to be created in the attr fork of the inode.
xfsaild/loop0 2008 [003] 1475.127209: probe:xfs_inode_to_disk: (ffffffffa43fb6b0) if_nextents=98511 i_ino=131
3. The incore inode fork extent counter is a signed 32-bit quantity. However the on-disk extent counter is an unsigned 16-bit quantity and hence cannot hold 98511 extents.
4. The following incorrect value is stored in the attr extent counter,
# xfs_db -f -c 'inode 131' -c 'print core.naextents' /dev/loop0 core.naextents = -32561
This commit adds a new helper function (i.e. xfs_iext_count_may_overflow()) to check for overflow of the per-inode data and xattr extent counters. Future patches will use this function to make sure that an FS operation won't cause the extent counter to overflow.
--- fs/xfs/libxfs/xfs_inode_fork.c | 23 +++++++++++++++++++++++ fs/xfs/libxfs/xfs_inode_fork.h | 2 ++ 2 files changed, 25 insertions(+)
fs/xfs/libxfs/xfs_inode_fork.c +23 -0
@@ -23,6 +23,7 @@#include "xfs_da_btree.h" #include "xfs_dir2_priv.h" #include "xfs_attr_leaf.h" +#include "xfs_types.h" kmem_zone_t *xfs_ifork_zone;
@@ -728,3 +729,25 @@ xfs_ifork_verify_local_attr(return 0 ; } + +int +xfs_iext_count_may_overflow ( +struct xfs_inode *ip, +int whichfork, +int nr_to_add) +{ +struct xfs_ifork *ifp =XFS_IFORK_PTR (ip, whichfork); +uint64_t max_exts; +uint64_t nr_exts; + +if (whichfork ==XFS_COW_FORK ) +return 0 ; + + max_exts = (whichfork ==XFS_ATTR_FORK ) ?MAXAEXTNUM :MAXEXTNUM ; + + nr_exts = ifp->if_nextents + nr_to_add; +if (nr_exts < ifp->if_nextents || nr_exts > max_exts) +return -EFBIG ; + +return 0 ; +}
fs/xfs/libxfs/xfs_inode_fork.h +2 -0
@@ -172,5 +172,7 @@ extern void xfs_ifork_init_cow(struct xfs_inode *ip);int xfs_ifork_verify_local_data (struct xfs_inode *ip);int xfs_ifork_verify_local_attr (struct xfs_inode *ip); +int xfs_iext_count_may_overflow (struct xfs_inode *ip,int whichfork, +int nr_to_add);#endif /* __XFS_INODE_FORK_H__ */
Signature · 1 line
2.28.0
PATCH v10 2/14 xfs: Check for extent overflow when trivally adding a new extent
In reply to Chandan Babu RWhen adding a new data extent (without modifying an inode's existing extents) the extent count increases only by 1. This commit checks for extent count overflow in such cases.
--- fs/xfs/libxfs/xfs_bmap.c | 6 ++++++ fs/xfs/libxfs/xfs_inode_fork.h | 6 ++++++ fs/xfs/xfs_bmap_item.c | 7 +++++++ fs/xfs/xfs_bmap_util.c | 5 +++++ fs/xfs/xfs_dquot.c | 8 +++++++- fs/xfs/xfs_iomap.c | 5 +++++ fs/xfs/xfs_rtalloc.c | 5 +++++ 7 files changed, 41 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_bmap.c +6 -0
@@ -4527,6 +4527,12 @@ xfs_bmapi_convert_delalloc(return error;xfs_ilock (ip,XFS_ILOCK_EXCL ); + + error =xfs_iext_count_may_overflow (ip, whichfork, +XFS_IEXT_ADD_NOSPLIT_CNT ); +if (error) + goto out_trans_cancel; +xfs_trans_ijoin (tp, ip,0 ); if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &bma.icur, &bma.got) ||
fs/xfs/libxfs/xfs_inode_fork.h +6 -0
@@ -34,6 +34,12 @@ struct xfs_ifork {#define XFS_IFEXTENTS 0x02/* All extent pointers are read in */ #define XFS_IFBROOT 0x04/* i_broot points to the bmap b-tree root */ +/* +* Worst-case increase in the fork extent count when we're adding a single +* extent to a fork and there's no possibility of splitting an existing mapping. +*/ +#define XFS_IEXT_ADD_NOSPLIT_CNT (1) +/* * Fork handling. */
fs/xfs/xfs_bmap_item.c +7 -0
@@ -497,6 +497,13 @@ xfs_bui_item_recover(xfs_ilock (ip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,0 ); +if (bui_type ==XFS_BMAP_MAP ) { + error =xfs_iext_count_may_overflow (ip, whichfork, +XFS_IEXT_ADD_NOSPLIT_CNT ); +if (error) + goto err_cancel; + } + count = bmap->me_len; error = xfs_trans_log_finish_bmap_update(tp, budp, bui_type, ip, whichfork, bmap->me_startoff, bmap->me_startblock,
fs/xfs/xfs_bmap_util.c +5 -0
@@ -822,6 +822,11 @@ xfs_alloc_file_space(if (error) goto error1; + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_ADD_NOSPLIT_CNT ); +if (error) + goto error0; +xfs_trans_ijoin (tp, ip,0 ); error = xfs_bmapi_write(tp, ip, startoffset_fsb,
fs/xfs/xfs_dquot.c +7 -1
@@ -314,8 +314,14 @@ xfs_dquot_disk_alloc(return -ESRCH ; } -/* Create the block mapping. */ xfs_trans_ijoin (tp, quotip,XFS_ILOCK_EXCL ); + + error =xfs_iext_count_may_overflow (quotip,XFS_DATA_FORK , +XFS_IEXT_ADD_NOSPLIT_CNT ); +if (error) +return error; + +/* Create the block mapping. */ error =xfs_bmapi_write (tp, quotip, dqp->q_fileoffset,XFS_DQUOT_CLUSTER_SIZE_FSB ,XFS_BMAPI_METADATA ,0 , &map, &nmaps);
fs/xfs/xfs_iomap.c +5 -0
@@ -250,6 +250,11 @@ xfs_iomap_write_direct(if (error) goto out_trans_cancel; + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_ADD_NOSPLIT_CNT ); +if (error) + goto out_trans_cancel; +xfs_trans_ijoin (tp, ip,0 );/*
fs/xfs/xfs_rtalloc.c +5 -0
@@ -804,6 +804,11 @@ xfs_growfs_rt_alloc(xfs_ilock (ip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,XFS_ILOCK_EXCL ); + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_ADD_NOSPLIT_CNT ); +if (error) + goto out_trans_cancel; +/* * Allocate blocks to the bitmap file. */
Signature · 1 line
2.28.0
PATCH v10 3/14 xfs: Check for extent overflow when punching a hole
In reply to Chandan Babu RThe extent mapping the file offset at which a hole has to be inserted will be split into two extents causing extent count to increase by 1.
--- fs/xfs/libxfs/xfs_inode_fork.h | 7 +++++++ fs/xfs/xfs_bmap_item.c | 15 +++++++++------ fs/xfs/xfs_bmap_util.c | 10 ++++++++++ 3 files changed, 26 insertions(+), 6 deletions(-)
fs/xfs/libxfs/xfs_inode_fork.h +7 -0
@@ -40,6 +40,13 @@ struct xfs_ifork {*/ #define XFS_IEXT_ADD_NOSPLIT_CNT (1) +/* +* Punching out an extent from the middle of an existing extent can cause the +* extent count to increase by 1. +* i.e. | Old extent | Hole | Old extent | +*/ +#define XFS_IEXT_PUNCH_HOLE_CNT (1) +/* * Fork handling. */
fs/xfs/xfs_bmap_item.c +9 -6
@@ -439,6 +439,7 @@ xfs_bui_item_recover(xfs_exntst_t state;unsigned int bui_type;int whichfork; +int iext_delta;int error =0 ;/* Only one mapping operation per BUI... */
@@ -497,12 +498,14 @@ xfs_bui_item_recover(xfs_ilock (ip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,0 ); -if (bui_type ==XFS_BMAP_MAP ) { - error =xfs_iext_count_may_overflow (ip, whichfork, -XFS_IEXT_ADD_NOSPLIT_CNT ); -if (error) - goto err_cancel; - } +if (bui_type ==XFS_BMAP_MAP ) + iext_delta =XFS_IEXT_ADD_NOSPLIT_CNT ; +else + iext_delta =XFS_IEXT_PUNCH_HOLE_CNT ; + + error =xfs_iext_count_may_overflow (ip, whichfork, iext_delta); +if (error) + goto err_cancel; count = bmap->me_len; error = xfs_trans_log_finish_bmap_update(tp, budp, bui_type, ip,
fs/xfs/xfs_bmap_util.c +10 -0
@@ -891,6 +891,11 @@ xfs_unmap_extent(xfs_trans_ijoin (tp, ip,0 ); + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_PUNCH_HOLE_CNT ); +if (error) + goto out_trans_cancel; + error =xfs_bunmapi (tp, ip, startoffset_fsb, len_fsb,0 ,2 , done);if (error) goto out_trans_cancel;
@@ -1176,6 +1181,11 @@ xfs_insert_file_space(xfs_ilock (ip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,0 ); + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_PUNCH_HOLE_CNT ); +if (error) + goto out_trans_cancel; +/* * The extent shifting code works on extent granularity. So, if stop_fsb * is not the starting block of extent, we need to split the extent at
Signature · 1 line
2.28.0
Re: [PATCH V10 12/14] xfs: Compute bmap extent alignments in a separate function
In reply to Chandan Babu RQuoted 6 lines · Chandan Babu R
This commit moves over the code which computes stripe alignment and extent size hint alignment into a separate function. Apart from
xfs_bmap_btalloc(), the new function will be used by another function introduced in a future commit.Signed-off-by Chandan Babu R <[email protected]>
Looks fine at last :)
Could you please add a fsstress style test that sets the errortag to see what kinds of, uh, testing artifacts fall out of that mode?
--D
Quoted 135 lines
--- fs/xfs/libxfs/xfs_bmap.c | 89 +++++++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 37 deletions(-)fs/xfs/libxfs/xfs_bmap.c +52
-37@@ -3463,13 +3463,59 @@ xfs_bmap_btalloc_accounting( args->len); } +static int +xfs_bmap_compute_alignments ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args) +{ +struct xfs_mount *mp = args->mp; +xfs_extlen_t align =0 ;/* minimum allocation alignment */ +int stripe_align =0 ; +int error; + +/* stripe alignment for allocation is determined by mount parameters */ +if (mp->m_swidth && (mp->m_flags &XFS_MOUNT_SWALLOC )) + stripe_align = mp->m_swidth; +else if (mp->m_dalign) + stripe_align = mp->m_dalign; + +if (ap->flags &XFS_BMAPI_COWFORK ) + align =xfs_get_cowextsz_hint (ap->ip); +else if (ap->datatype &XFS_ALLOC_USERDATA ) + align =xfs_get_extsz_hint (ap->ip); +if (align) { + error =xfs_bmap_extsize_align (mp, &ap->got, &ap->prev, + align,0 , ap->eof,0 , ap->conv, + &ap->offset, &ap->length); +ASSERT (!error); +ASSERT (ap->length); + } + +/* apply extent size hints if obtained earlier */ +if (align) { + args->prod = align; +div_u64_rem (ap->offset, args->prod, &args->mod); +if (args->mod) + args->mod = args->prod - args->mod; + }else if (mp->m_sb.sb_blocksize >=PAGE_SIZE ) { + args->prod =1 ; + args->mod =0 ; + }else { + args->prod =PAGE_SIZE >> mp->m_sb.sb_blocklog; +div_u64_rem (ap->offset, args->prod, &args->mod); +if (args->mod) + args->mod = args->prod - args->mod; + } + +return stripe_align; +} + STATIC intxfs_bmap_btalloc (struct xfs_bmalloca *ap)/* bmap alloc argument struct */ {xfs_mount_t *mp;/* mount point structure */ xfs_alloctype_t atype =0 ;/* type for allocation routines */ -xfs_extlen_t align =0 ;/* minimum allocation alignment */ xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ xfs_agnumber_t ag;xfs_alloc_arg_t args;@@ -3489,25 +3535,11 @@ xfs_bmap_btalloc( mp = ap->ip->i_mount; -/* stripe alignment for allocation is determined by mount parameters */ - stripe_align =0 ; -if (mp->m_swidth && (mp->m_flags &XFS_MOUNT_SWALLOC )) - stripe_align = mp->m_swidth; -else if (mp->m_dalign) - stripe_align = mp->m_dalign; - -if (ap->flags &XFS_BMAPI_COWFORK ) - align =xfs_get_cowextsz_hint (ap->ip); -else if (ap->datatype &XFS_ALLOC_USERDATA ) - align =xfs_get_extsz_hint (ap->ip); -if (align) { - error =xfs_bmap_extsize_align (mp, &ap->got, &ap->prev, - align,0 , ap->eof,0 , ap->conv, - &ap->offset, &ap->length); -ASSERT (!error); -ASSERT (ap->length); - } +memset (&args,0 ,sizeof (args)); + args.tp = ap->tp; + args.mp = mp; + stripe_align =xfs_bmap_compute_alignments (ap, &args); nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ; fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,@@ -3538,9 +3570,6 @@ xfs_bmap_btalloc(* Normal allocation, done through xfs_alloc_vextent. */ tryagain = isaligned =0 ; -memset (&args,0 ,sizeof (args)); - args.tp = ap->tp; - args.mp = mp; args.fsbno = ap->blkno; args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ;@@ -3571,21 +3600,7 @@ xfs_bmap_btalloc( args.total = ap->total; args.minlen = ap->minlen; } -/* apply extent size hints if obtained earlier */ -if (align) { - args.prod = align; -div_u64_rem (ap->offset, args.prod, &args.mod); -if (args.mod) - args.mod = args.prod - args.mod; - }else if (mp->m_sb.sb_blocksize >=PAGE_SIZE ) { - args.prod =1 ; - args.mod =0 ; - }else { - args.prod =PAGE_SIZE >> mp->m_sb.sb_blocklog; -div_u64_rem (ap->offset, args.prod, &args.mod); -if (args.mod) - args.mod = args.prod - args.mod; - } +/* * If we are not low on available data blocks, and the underlying * logical volume manager is a stripe, and the file offset is zero then Signature · 1 line
2.28.0
Re: [PATCH V10 14/14] xfs: Introduce error injection to allocate only minlen size extents for files
In reply to Chandan Babu RQuoted 205 lines · Chandan Babu R
This commit adds
XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENTerror tag which helps userspace test programs to getxfs_bmap_btalloc()to always allocate minlen sized extents.This is required for test programs which need a guarantee that minlen extents allocated for a file do not get merged with their existing neighbours in the inode's BMBT. "Inode fork extent overflow check" for Directories, Xattrs and extension of realtime inodes need this since the file offset at which the extents are being allocated cannot be explicitly controlled from userspace.
One way to use this error tag is to,
1. Consume all of the free space by sequentially writing to a file.
2. Punch alternate blocks of the file. This causes CNTBT to contain sufficient number of one block sized extent records.
3. InjectXFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENTerror tag. After step 3,xfs_bmap_btalloc()will issue space allocation requests for minlen sized extents only.ENOSPC error code is returned to userspace when there aren't any "one block sized" extents left in any of the AGs.
Signed-off-by Chandan Babu R <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 50 ++++++++++++++ fs/xfs/libxfs/xfs_alloc.h | 3 + fs/xfs/libxfs/xfs_bmap.c | 124 ++++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_errortag.h | 4 +- fs/xfs/xfs_error.c | 3 + 5 files changed, 159 insertions(+), 25 deletions(-)fs/xfs/libxfs/xfs_alloc.c +50
-0@@ -2473,6 +2473,47 @@ xfs_defer_agfl_block(xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_AGFL_FREE , &new->xefi_list); } +#ifdef DEBUG +/* +* Check if an AGF has a free extent record whose length is equal to +* args->minlen. +*/ +STATIC int +xfs_exact_minlen_extent_available ( +struct xfs_alloc_arg *args, +struct xfs_buf *agbp, +int *stat) +{ +struct xfs_btree_cur *cnt_cur; +xfs_agblock_t fbno; +xfs_extlen_t flen; +int error =0 ; + + cnt_cur =xfs_allocbt_init_cursor (args->mp, args->tp, agbp, + args->agno,XFS_BTNUM_CNT ); + error =xfs_alloc_lookup_ge (cnt_cur,0 , args->minlen, stat); +if (error) + goto out; + +if (*stat ==0 ) { + error = -EFSCORRUPTED ; + goto out; + } + + error =xfs_alloc_get_rec (cnt_cur, &fbno, &flen, stat); +if (error) + goto out; + +if (*stat ==1 && flen != args->minlen) + *stat =0 ; + +out: +xfs_btree_del_cursor (cnt_cur, error); + +return error; +} +#endif +/* * Decide whether to use this allocation group for this allocation. * If so, fix up the btree freelist's size. @@ -2544,6 +2585,15 @@ xfs_alloc_fix_freelist(if (!xfs_alloc_space_available (args, need, flags)) goto out_agbp_relse; +#ifdef DEBUG +if (args->alloc_minlen_only) { +int stat; + + error =xfs_exact_minlen_extent_available (args, agbp, &stat); +if (error || !stat) + goto out_agbp_relse; + } +#endif /* * Make the freelist shorter if it's too long. * fs/xfs/libxfs/xfs_alloc.h +3
-0@@ -75,6 +75,9 @@ typedef struct xfs_alloc_arg {char wasfromfl;/* set if allocation is from freelist */ struct xfs_owner_info oinfo;/* owner of blocks being allocated */ enum xfs_ag_resv_type resv;/* block reservation to use */ +#ifdef DEBUG +bool alloc_minlen_only;/* allocate exact minlen extent */ +#endif } xfs_alloc_arg_t;/* fs/xfs/libxfs/xfs_bmap.c +73
-7@@ -3552,35 +3552,102 @@ xfs_bmap_process_allocated_extent(xfs_bmap_btalloc_accounting (ap, args); } +#ifdef DEBUG +static int +xfs_bmap_exact_minlen_extent_alloc ( +struct xfs_bmalloca *ap) +{ +struct xfs_mount *mp = ap->ip->i_mount; +struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp }; +xfs_fileoff_t orig_offset; +xfs_extlen_t orig_length; +int error; + +ASSERT (ap->length); + +if (ap->minlen !=1 ) { + ap->blkno =NULLFSBLOCK ; + ap->length =0 ; +return 0 ; + } + + orig_offset = ap->offset; + orig_length = ap->length; + + args.alloc_minlen_only =1 ; + +xfs_bmap_compute_alignments (ap, &args); + +if (ap->tp->t_firstblock ==NULLFSBLOCK ) { +/* +* Unlike the longest extent available in an AG, we don't track +* the length of an AG's shortest extent. +* XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is a debug only knob and +* hence we can afford to start traversing from the 0th AG since +* we need not be concerned about a drop in performance in +* "debug only" code paths. +*/ + ap->blkno =XFS_AGB_TO_FSB (mp,0 ,0 ); + }else { + ap->blkno = ap->tp->t_firstblock; + } + + args.fsbno = ap->blkno; + args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ; + args.type =XFS_ALLOCTYPE_FIRST_AG ; + args.total = args.minlen = args.maxlen = ap->minlen; + + args.alignment =1 ; + args.minalignslop =0 ; + + args.minleft = ap->minleft; + args.wasdel = ap->wasdel; + args.resv =XFS_AG_RESV_NONE ; + args.datatype = ap->datatype; + + error =xfs_alloc_vextent (&args); +if (error) +return error; + +if (args.fsbno !=NULLFSBLOCK ) { +xfs_bmap_process_allocated_extent (ap, &args, orig_offset, + orig_length); + }else { + ap->blkno =NULLFSBLOCK ; + ap->length =0 ; + } + +return 0 ; +} +#else + +#define xfs_bmap_exact_minlen_extent_alloc (bma) (-EFSCORRUPTED) + +#endif + STATIC intxfs_bmap_btalloc (struct xfs_bmalloca *ap)/* bmap alloc argument struct */ { -xfs_mount_t *mp;/* mount point structure */ -xfs_alloctype_t atype =0 ;/* type for allocation routines */ -xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ -xfs_agnumber_t ag; -xfs_alloc_arg_t args; -xfs_fileoff_t orig_offset; -xfs_extlen_t orig_length;
fs/xfs/libxfs/xfs_bmap.c xfs_bmap_process_allocated_extent( · line 3634
Quoted 10 lines
fs/xfs/libxfs/xfs_bmap.c +3
-7-xfs_extlen_t blen; -xfs_extlen_t nextminlen =0 ; -int nullfb;/* true if ap->firstblock isn't set */ -int isaligned; -int tryagain; -int error; -int stripe_align; +struct xfs_mount *mp = ap->ip->i_mount;/* mount point structure */ +struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp }; +xfs_alloctype_t atype =0 ;/* type for allocation routines */
I'll remove these comments ("bmap alloc argument struct", "mount point structure", "type for allocation routines") that don't add much.
Quoted 26 lines
fs/xfs/libxfs/xfs_bmap.c +11
-6+xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ +xfs_agnumber_t ag; +xfs_fileoff_t orig_offset; +xfs_extlen_t orig_length; +xfs_extlen_t blen; +xfs_extlen_t nextminlen =0 ; +int nullfb;/* true if ap->firstblock isn't set */ +int isaligned; +int tryagain; +int error; +int stripe_align;ASSERT (ap->length); orig_offset = ap->offset; orig_length = ap->length; - mp = ap->ip->i_mount; - -memset (&args,0 ,sizeof (args)); - args.tp = ap->tp; - args.mp = mp; - stripe_align =xfs_bmap_compute_alignments (ap, &args); nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ;
fs/xfs/libxfs/xfs_bmap.c xfs_bmap_alloc_userdata( · line 4187
Quoted 9 lines
fs/xfs/libxfs/xfs_bmap.c +5
-1@@ -4113,7 +4180,11 @@ xfs_bmap_alloc_userdata(return xfs_bmap_rtalloc (bma); } -return xfs_bmap_btalloc (bma); +if (unlikely (XFS_TEST_ERROR (false, mp, +XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT ))) +return xfs_bmap_exact_minlen_extent_alloc (bma); +else +return xfs_bmap_btalloc (bma);
Minor nit: no need for the "else return" here, you can just do:
if (unlikely(...)) return xfs_bmap_exact_minlen_extent_alloc(bma); return xfs_bmap_btalloc(bma);
I'll just fix those on their way into my testing tree, but please make the changes to your dev branch if you end up sending a v11.
--D
Quoted 74 lines
fs/xfs/libxfs/xfs_bmap.c +8
-3} static int@@ -4149,10 +4220,15 @@ xfs_bmapi_allocate(else bma->minlen =1 ; -if (bma->flags &XFS_BMAPI_METADATA ) - error =xfs_bmap_btalloc (bma); -else +if (bma->flags &XFS_BMAPI_METADATA ) { +if (unlikely (XFS_TEST_ERROR (false, mp, +XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT ))) + error =xfs_bmap_exact_minlen_extent_alloc (bma); +else + error =xfs_bmap_btalloc (bma); + }else { error =xfs_bmap_alloc_userdata (bma); + }if (error || bma->blkno ==NULLFSBLOCK )return error;fs/xfs/libxfs/xfs_errortag.h +3
-1@@ -57,7 +57,8 @@#define XFS_ERRTAG_IUNLINK_FALLBACK 34#define XFS_ERRTAG_BUF_IOERROR 35#define XFS_ERRTAG_REDUCE_MAX_IEXTENTS 36 -#define XFS_ERRTAG_MAX 37 +#define XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT 37 +#define XFS_ERRTAG_MAX 38/* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc. @@ -99,5 +100,6 @@#define XFS_RANDOM_IUNLINK_FALLBACK (XFS_RANDOM_DEFAULT/10)#define XFS_RANDOM_BUF_IOERROR XFS_RANDOM_DEFAULT#define XFS_RANDOM_REDUCE_MAX_IEXTENTS 1 +#define XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT 1#endif /* __XFS_ERRORTAG_H_ */ fs/xfs/xfs_error.c +3
-0@@ -55,6 +55,7 @@ static unsigned int xfs_errortag_random_default[] = {XFS_RANDOM_IUNLINK_FALLBACK ,XFS_RANDOM_BUF_IOERROR ,XFS_RANDOM_REDUCE_MAX_IEXTENTS , + XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT, }; struct xfs_errortag_attr {@@ -166,6 +167,7 @@ XFS_ERRORTAG_ATTR_RW(bad_summary, XFS_ERRTAG_FORCE_SUMMARY_RECALC);XFS_ERRORTAG_ATTR_RW (iunlink_fallback,XFS_ERRTAG_IUNLINK_FALLBACK );XFS_ERRORTAG_ATTR_RW (buf_ioerror,XFS_ERRTAG_BUF_IOERROR );XFS_ERRORTAG_ATTR_RW (reduce_max_iextents,XFS_ERRTAG_REDUCE_MAX_IEXTENTS ); +XFS_ERRORTAG_ATTR_RW (bmap_alloc_minlen_extent,XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT );static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (noerror),@@ -205,6 +207,7 @@ static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (iunlink_fallback),XFS_ERRORTAG_ATTR_LIST (buf_ioerror),XFS_ERRORTAG_ATTR_LIST (reduce_max_iextents), +XFS_ERRORTAG_ATTR_LIST (bmap_alloc_minlen_extent), NULL, };Signature · 1 line
2.28.0
Re: [PATCH V10 12/14] xfs: Compute bmap extent alignments in a separate function
In reply to Darrick J. WongQuoted 9 lines · IST Darrick J. Wong
Quoted 6 lines · Chandan Babu R
This commit moves over the code which computes stripe alignment and extent size hint alignment into a separate function. Apart from
xfs_bmap_btalloc(), the new function will be used by another function introduced in a future commit.Signed-off-by Chandan Babu R <[email protected]>Looks fine at last :)
Thanks for the review comments.
Quoted 4 lines
Reviewed-by Darrick J. Wong <[email protected]>Could you please add a fsstress style test that sets the errortag to see what kinds of, uh, testing artifacts fall out of that mode?
Sure. I will work on that.
Quoted 136 lines
--D
Quoted 132 lines
--- fs/xfs/libxfs/xfs_bmap.c | 89 +++++++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 37 deletions(-)fs/xfs/libxfs/xfs_bmap.c +52
-37@@ -3463,13 +3463,59 @@ xfs_bmap_btalloc_accounting( args->len); } +static int +xfs_bmap_compute_alignments ( +struct xfs_bmalloca *ap, +struct xfs_alloc_arg *args) +{ +struct xfs_mount *mp = args->mp; +xfs_extlen_t align =0 ;/* minimum allocation alignment */ +int stripe_align =0 ; +int error; + +/* stripe alignment for allocation is determined by mount parameters */ +if (mp->m_swidth && (mp->m_flags &XFS_MOUNT_SWALLOC )) + stripe_align = mp->m_swidth; +else if (mp->m_dalign) + stripe_align = mp->m_dalign; + +if (ap->flags &XFS_BMAPI_COWFORK ) + align =xfs_get_cowextsz_hint (ap->ip); +else if (ap->datatype &XFS_ALLOC_USERDATA ) + align =xfs_get_extsz_hint (ap->ip); +if (align) { + error =xfs_bmap_extsize_align (mp, &ap->got, &ap->prev, + align,0 , ap->eof,0 , ap->conv, + &ap->offset, &ap->length); +ASSERT (!error); +ASSERT (ap->length); + } + +/* apply extent size hints if obtained earlier */ +if (align) { + args->prod = align; +div_u64_rem (ap->offset, args->prod, &args->mod); +if (args->mod) + args->mod = args->prod - args->mod; + }else if (mp->m_sb.sb_blocksize >=PAGE_SIZE ) { + args->prod =1 ; + args->mod =0 ; + }else { + args->prod =PAGE_SIZE >> mp->m_sb.sb_blocklog; +div_u64_rem (ap->offset, args->prod, &args->mod); +if (args->mod) + args->mod = args->prod - args->mod; + } + +return stripe_align; +} + STATIC intxfs_bmap_btalloc (struct xfs_bmalloca *ap)/* bmap alloc argument struct */ {xfs_mount_t *mp;/* mount point structure */ xfs_alloctype_t atype =0 ;/* type for allocation routines */ -xfs_extlen_t align =0 ;/* minimum allocation alignment */ xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ xfs_agnumber_t ag;xfs_alloc_arg_t args;@@ -3489,25 +3535,11 @@ xfs_bmap_btalloc( mp = ap->ip->i_mount; -/* stripe alignment for allocation is determined by mount parameters */ - stripe_align =0 ; -if (mp->m_swidth && (mp->m_flags &XFS_MOUNT_SWALLOC )) - stripe_align = mp->m_swidth; -else if (mp->m_dalign) - stripe_align = mp->m_dalign; - -if (ap->flags &XFS_BMAPI_COWFORK ) - align =xfs_get_cowextsz_hint (ap->ip); -else if (ap->datatype &XFS_ALLOC_USERDATA ) - align =xfs_get_extsz_hint (ap->ip); -if (align) { - error =xfs_bmap_extsize_align (mp, &ap->got, &ap->prev, - align,0 , ap->eof,0 , ap->conv, - &ap->offset, &ap->length); -ASSERT (!error); -ASSERT (ap->length); - } +memset (&args,0 ,sizeof (args)); + args.tp = ap->tp; + args.mp = mp; + stripe_align =xfs_bmap_compute_alignments (ap, &args); nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ; fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,@@ -3538,9 +3570,6 @@ xfs_bmap_btalloc(* Normal allocation, done through xfs_alloc_vextent. */ tryagain = isaligned =0 ; -memset (&args,0 ,sizeof (args)); - args.tp = ap->tp; - args.mp = mp; args.fsbno = ap->blkno; args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ;@@ -3571,21 +3600,7 @@ xfs_bmap_btalloc( args.total = ap->total; args.minlen = ap->minlen; } -/* apply extent size hints if obtained earlier */ -if (align) { - args.prod = align; -div_u64_rem (ap->offset, args.prod, &args.mod); -if (args.mod) - args.mod = args.prod - args.mod; - }else if (mp->m_sb.sb_blocksize >=PAGE_SIZE ) { - args.prod =1 ; - args.mod =0 ; - }else { - args.prod =PAGE_SIZE >> mp->m_sb.sb_blocklog; -div_u64_rem (ap->offset, args.prod, &args.mod); -if (args.mod) - args.mod = args.prod - args.mod; - } +/* * If we are not low on available data blocks, and the underlying * logical volume manager is a stripe, and the file offset is zero then
Signature · 1 line
chandan
Re: [PATCH V10 14/14] xfs: Introduce error injection to allocate only minlen size extents for files
In reply to Darrick J. WongQuoted 258 lines · IST Darrick J. Wong
Quoted 205 lines · Chandan Babu R
This commit adds
XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENTerror tag which helps userspace test programs to getxfs_bmap_btalloc()to always allocate minlen sized extents.This is required for test programs which need a guarantee that minlen extents allocated for a file do not get merged with their existing neighbours in the inode's BMBT. "Inode fork extent overflow check" for Directories, Xattrs and extension of realtime inodes need this since the file offset at which the extents are being allocated cannot be explicitly controlled from userspace.
One way to use this error tag is to,
1. Consume all of the free space by sequentially writing to a file.
2. Punch alternate blocks of the file. This causes CNTBT to contain sufficient number of one block sized extent records.
3. InjectXFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENTerror tag. After step 3,xfs_bmap_btalloc()will issue space allocation requests for minlen sized extents only.ENOSPC error code is returned to userspace when there aren't any "one block sized" extents left in any of the AGs.
Signed-off-by Chandan Babu R <[email protected]>--- fs/xfs/libxfs/xfs_alloc.c | 50 ++++++++++++++ fs/xfs/libxfs/xfs_alloc.h | 3 + fs/xfs/libxfs/xfs_bmap.c | 124 ++++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_errortag.h | 4 +- fs/xfs/xfs_error.c | 3 + 5 files changed, 159 insertions(+), 25 deletions(-)fs/xfs/libxfs/xfs_alloc.c +50
-0@@ -2473,6 +2473,47 @@ xfs_defer_agfl_block(xfs_defer_add (tp,XFS_DEFER_OPS_TYPE_AGFL_FREE , &new->xefi_list); } +#ifdef DEBUG +/* +* Check if an AGF has a free extent record whose length is equal to +* args->minlen. +*/ +STATIC int +xfs_exact_minlen_extent_available ( +struct xfs_alloc_arg *args, +struct xfs_buf *agbp, +int *stat) +{ +struct xfs_btree_cur *cnt_cur; +xfs_agblock_t fbno; +xfs_extlen_t flen; +int error =0 ; + + cnt_cur =xfs_allocbt_init_cursor (args->mp, args->tp, agbp, + args->agno,XFS_BTNUM_CNT ); + error =xfs_alloc_lookup_ge (cnt_cur,0 , args->minlen, stat); +if (error) + goto out; + +if (*stat ==0 ) { + error = -EFSCORRUPTED ; + goto out; + } + + error =xfs_alloc_get_rec (cnt_cur, &fbno, &flen, stat); +if (error) + goto out; + +if (*stat ==1 && flen != args->minlen) + *stat =0 ; + +out: +xfs_btree_del_cursor (cnt_cur, error); + +return error; +} +#endif +/* * Decide whether to use this allocation group for this allocation. * If so, fix up the btree freelist's size. @@ -2544,6 +2585,15 @@ xfs_alloc_fix_freelist(if (!xfs_alloc_space_available (args, need, flags)) goto out_agbp_relse; +#ifdef DEBUG +if (args->alloc_minlen_only) { +int stat; + + error =xfs_exact_minlen_extent_available (args, agbp, &stat); +if (error || !stat) + goto out_agbp_relse; + } +#endif /* * Make the freelist shorter if it's too long. * fs/xfs/libxfs/xfs_alloc.h +3
-0@@ -75,6 +75,9 @@ typedef struct xfs_alloc_arg {char wasfromfl;/* set if allocation is from freelist */ struct xfs_owner_info oinfo;/* owner of blocks being allocated */ enum xfs_ag_resv_type resv;/* block reservation to use */ +#ifdef DEBUG +bool alloc_minlen_only;/* allocate exact minlen extent */ +#endif } xfs_alloc_arg_t;/* fs/xfs/libxfs/xfs_bmap.c +73
-7@@ -3552,35 +3552,102 @@ xfs_bmap_process_allocated_extent(xfs_bmap_btalloc_accounting (ap, args); } +#ifdef DEBUG +static int +xfs_bmap_exact_minlen_extent_alloc ( +struct xfs_bmalloca *ap) +{ +struct xfs_mount *mp = ap->ip->i_mount; +struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp }; +xfs_fileoff_t orig_offset; +xfs_extlen_t orig_length; +int error; + +ASSERT (ap->length); + +if (ap->minlen !=1 ) { + ap->blkno =NULLFSBLOCK ; + ap->length =0 ; +return 0 ; + } + + orig_offset = ap->offset; + orig_length = ap->length; + + args.alloc_minlen_only =1 ; + +xfs_bmap_compute_alignments (ap, &args); + +if (ap->tp->t_firstblock ==NULLFSBLOCK ) { +/* +* Unlike the longest extent available in an AG, we don't track +* the length of an AG's shortest extent. +* XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is a debug only knob and +* hence we can afford to start traversing from the 0th AG since +* we need not be concerned about a drop in performance in +* "debug only" code paths. +*/ + ap->blkno =XFS_AGB_TO_FSB (mp,0 ,0 ); + }else { + ap->blkno = ap->tp->t_firstblock; + } + + args.fsbno = ap->blkno; + args.oinfo =XFS_RMAP_OINFO_SKIP_UPDATE ; + args.type =XFS_ALLOCTYPE_FIRST_AG ; + args.total = args.minlen = args.maxlen = ap->minlen; + + args.alignment =1 ; + args.minalignslop =0 ; + + args.minleft = ap->minleft; + args.wasdel = ap->wasdel; + args.resv =XFS_AG_RESV_NONE ; + args.datatype = ap->datatype; + + error =xfs_alloc_vextent (&args); +if (error) +return error; + +if (args.fsbno !=NULLFSBLOCK ) { +xfs_bmap_process_allocated_extent (ap, &args, orig_offset, + orig_length); + }else { + ap->blkno =NULLFSBLOCK ; + ap->length =0 ; + } + +return 0 ; +} +#else + +#define xfs_bmap_exact_minlen_extent_alloc (bma) (-EFSCORRUPTED) + +#endif + STATIC intxfs_bmap_btalloc (struct xfs_bmalloca *ap)/* bmap alloc argument struct */ { -xfs_mount_t *mp;/* mount point structure */ -xfs_alloctype_t atype =0 ;/* type for allocation routines */ -xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ -xfs_agnumber_t ag; -xfs_alloc_arg_t args; -xfs_fileoff_t orig_offset; -xfs_extlen_t orig_length;fs/xfs/libxfs/xfs_bmap.c xfs_bmap_process_allocated_extent( · line 3634
Quoted 10 lines
fs/xfs/libxfs/xfs_bmap.c +3
-7-xfs_extlen_t blen; -xfs_extlen_t nextminlen =0 ; -int nullfb;/* true if ap->firstblock isn't set */ -int isaligned; -int tryagain; -int error; -int stripe_align; +struct xfs_mount *mp = ap->ip->i_mount;/* mount point structure */ +struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp }; +xfs_alloctype_t atype =0 ;/* type for allocation routines */ I'll remove these comments ("bmap alloc argument struct", "mount point structure", "type for allocation routines") that don't add much.
Quoted 26 lines
fs/xfs/libxfs/xfs_bmap.c +11
-6+xfs_agnumber_t fb_agno;/* ag number of ap->firstblock */ +xfs_agnumber_t ag; +xfs_fileoff_t orig_offset; +xfs_extlen_t orig_length; +xfs_extlen_t blen; +xfs_extlen_t nextminlen =0 ; +int nullfb;/* true if ap->firstblock isn't set */ +int isaligned; +int tryagain; +int error; +int stripe_align;ASSERT (ap->length); orig_offset = ap->offset; orig_length = ap->length; - mp = ap->ip->i_mount; - -memset (&args,0 ,sizeof (args)); - args.tp = ap->tp; - args.mp = mp; - stripe_align =xfs_bmap_compute_alignments (ap, &args); nullfb = ap->tp->t_firstblock ==NULLFSBLOCK ;fs/xfs/libxfs/xfs_bmap.c xfs_bmap_alloc_userdata( · line 4187
Quoted 9 lines
fs/xfs/libxfs/xfs_bmap.c +5
-1@@ -4113,7 +4180,11 @@ xfs_bmap_alloc_userdata(return xfs_bmap_rtalloc (bma); } -return xfs_bmap_btalloc (bma); +if (unlikely (XFS_TEST_ERROR (false, mp, +XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT ))) +return xfs_bmap_exact_minlen_extent_alloc (bma); +else +return xfs_bmap_btalloc (bma);Minor nit: no need for the "else return" here, you can just do:
Quoted 6 lines
if (unlikely(...)) return xfs_bmap_exact_minlen_extent_alloc(bma); return xfs_bmap_btalloc(bma);I'll just fix those on their way into my testing tree, but please make the changes to your dev branch if you end up sending a v11.
Sure. I will do that.
Quoted 77 lines
Reviewed-by Darrick J. Wong <[email protected]>--D
Quoted 71 lines
fs/xfs/libxfs/xfs_bmap.c +8
-3} static int@@ -4149,10 +4220,15 @@ xfs_bmapi_allocate(else bma->minlen =1 ; -if (bma->flags &XFS_BMAPI_METADATA ) - error =xfs_bmap_btalloc (bma); -else +if (bma->flags &XFS_BMAPI_METADATA ) { +if (unlikely (XFS_TEST_ERROR (false, mp, +XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT ))) + error =xfs_bmap_exact_minlen_extent_alloc (bma); +else + error =xfs_bmap_btalloc (bma); + }else { error =xfs_bmap_alloc_userdata (bma); + }if (error || bma->blkno ==NULLFSBLOCK )return error;fs/xfs/libxfs/xfs_errortag.h +3
-1@@ -57,7 +57,8 @@#define XFS_ERRTAG_IUNLINK_FALLBACK 34#define XFS_ERRTAG_BUF_IOERROR 35#define XFS_ERRTAG_REDUCE_MAX_IEXTENTS 36 -#define XFS_ERRTAG_MAX 37 +#define XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT 37 +#define XFS_ERRTAG_MAX 38/* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc. @@ -99,5 +100,6 @@#define XFS_RANDOM_IUNLINK_FALLBACK (XFS_RANDOM_DEFAULT/10)#define XFS_RANDOM_BUF_IOERROR XFS_RANDOM_DEFAULT#define XFS_RANDOM_REDUCE_MAX_IEXTENTS 1 +#define XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT 1#endif /* __XFS_ERRORTAG_H_ */ fs/xfs/xfs_error.c +3
-0@@ -55,6 +55,7 @@ static unsigned int xfs_errortag_random_default[] = {XFS_RANDOM_IUNLINK_FALLBACK ,XFS_RANDOM_BUF_IOERROR ,XFS_RANDOM_REDUCE_MAX_IEXTENTS , + XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT, }; struct xfs_errortag_attr {@@ -166,6 +167,7 @@ XFS_ERRORTAG_ATTR_RW(bad_summary, XFS_ERRTAG_FORCE_SUMMARY_RECALC);XFS_ERRORTAG_ATTR_RW (iunlink_fallback,XFS_ERRTAG_IUNLINK_FALLBACK );XFS_ERRORTAG_ATTR_RW (buf_ioerror,XFS_ERRTAG_BUF_IOERROR );XFS_ERRORTAG_ATTR_RW (reduce_max_iextents,XFS_ERRTAG_REDUCE_MAX_IEXTENTS ); +XFS_ERRORTAG_ATTR_RW (bmap_alloc_minlen_extent,XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT );static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (noerror),@@ -205,6 +207,7 @@ static struct attribute *xfs_errortag_attrs[] = {XFS_ERRORTAG_ATTR_LIST (iunlink_fallback),XFS_ERRORTAG_ATTR_LIST (buf_ioerror),XFS_ERRORTAG_ATTR_LIST (reduce_max_iextents), +XFS_ERRORTAG_ATTR_LIST (bmap_alloc_minlen_extent), NULL, };
Signature · 1 line
chandan