Bail out if transaction can cause extent count to overflow
v4 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-v4.
I have a patch that defines the newly introduced error injection tag in xfsprogs
(https://github.com/chandanr/xfsprogs-dev/commit/7fd7aeef1cefbcc9abd6dd5887e710c80e48079d).
I have also written tests (https://paste.debian.net/1164261/) for verifying the checks introduced in the kernel. The tests have to be edited to make them suitable for merging with xfstests. But they also depend on the changes introduced in xfs_bmap_add_extent_hole_real() and xfs_growfs_rt_alloc(). Hence, I am planning to post the changes for xfsprogs and xfstests if other developers are fine with the changes made to the previously listed functions.
Changelog:
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 (10):
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
fs/xfs/libxfs/xfs_attr.c | 13 ++++++ fs/xfs/libxfs/xfs_bmap.c | 33 ++++++++++----- fs/xfs/libxfs/xfs_bmap.h | 1 + fs/xfs/libxfs/xfs_errortag.h | 4 +- fs/xfs/libxfs/xfs_inode_fork.c | 27 ++++++++++++ fs/xfs/libxfs/xfs_inode_fork.h | 77 ++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_types.h | 1 + fs/xfs/xfs_bmap_item.c | 5 +++ fs/xfs/xfs_bmap_util.c | 32 ++++++++++++++ fs/xfs/xfs_dquot.c | 8 +++- fs/xfs/xfs_error.c | 3 ++ fs/xfs/xfs_inode.c | 27 ++++++++++++ fs/xfs/xfs_iomap.c | 10 +++++ fs/xfs/xfs_reflink.c | 10 +++++ fs/xfs/xfs_rtalloc.c | 21 +++++++++- fs/xfs/xfs_symlink.c | 5 +++ 16 files changed, 262 insertions(+), 15 deletions(-)
Signature · 1 line
2.28.0
PATCH v4 1/10 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 v4 2/10 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_util.c | 5 +++++ fs/xfs/xfs_dquot.c | 8 +++++++- fs/xfs/xfs_iomap.c | 5 +++++ fs/xfs/xfs_rtalloc.c | 5 +++++ 6 files changed, 34 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_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 v4 3/10 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 | 5 +++++ fs/xfs/xfs_bmap_util.c | 10 ++++++++++ 3 files changed, 22 insertions(+)
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 +5 -0
@@ -519,6 +519,11 @@ xfs_bui_item_recover( }xfs_trans_ijoin (tp, ip,0 ); + error =xfs_iext_count_may_overflow (ip, whichfork, +XFS_IEXT_PUNCH_HOLE_CNT ); +if (error) + goto err_inode; + count = bmap->me_len; error =xfs_trans_log_finish_bmap_update (tp, budp, type, ip, whichfork, bmap->me_startoff, bmap->me_startblock, &count, state);
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 V4 03/10] xfs: Check for extent overflow when punching a hole
Quoted 34 lines · Chandan Babu R
The 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.
Signed-off-by Chandan Babu R <[email protected]>--- fs/xfs/libxfs/xfs_inode_fork.h | 7 +++++++ fs/xfs/xfs_bmap_item.c | 5 +++++ fs/xfs/xfs_bmap_util.c | 10 ++++++++++ 3 files changed, 22 insertions(+)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 +0
-0
fs/xfs/xfs_bmap_item.c xfs_bui_item_recover( · line 523
Quoted 5 lines
fs/xfs/xfs_bmap_item.c +2
-0@@ -519,6 +519,11 @@ xfs_bui_item_recover( }xfs_trans_ijoin (tp, ip,0 ); + error =xfs_iext_count_may_overflow (ip, whichfork, +XFS_IEXT_PUNCH_HOLE_CNT );
I think this ought to be XFS_IEXT_ADD_NOSPLIT_CNT if bui_type is XFS_BMAP_MAP and XFS_IEXT_PUNCH_HOLE_CNT if XFS_BMAP_UNMAP.
Whoever created the BUI should have called xfs_iext_count_may_overflow before logging the BUI (and hence this should never occur) but it does pay to be careful. :)
The rest of the logic in the patch looks ok.
--D
Quoted 37 lines
fs/xfs/xfs_bmap_item.c +3
-0+if (error) + goto err_inode; + count = bmap->me_len; error =xfs_trans_log_finish_bmap_update (tp, budp, type, ip, whichfork, bmap->me_startoff, bmap->me_startblock, &count, state);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 V4 03/10] xfs: Check for extent overflow when punching a hole
Quoted 38 lines · IST Darrick J. Wong
Quoted 37 lines · Chandan Babu R
The 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.
Signed-off-by Chandan Babu R <[email protected]>--- fs/xfs/libxfs/xfs_inode_fork.h | 7 +++++++ fs/xfs/xfs_bmap_item.c | 5 +++++ fs/xfs/xfs_bmap_util.c | 10 ++++++++++ 3 files changed, 22 insertions(+)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 +0
-0@@ -519,6 +519,11 @@ xfs_bui_item_recover( }xfs_trans_ijoin (tp, ip,0 );
Quoted 5 lines
fs/xfs/xfs_bmap_item.c xfs_bui_item_recover( · line 523
Quoted 2 lines
fs/xfs/xfs_bmap_item.c +2
-0+ error =xfs_iext_count_may_overflow (ip, whichfork, +XFS_IEXT_PUNCH_HOLE_CNT );I think this ought to be
XFS_IEXT_ADD_NOSPLIT_CNTifbui_typeisXFS_BMAP_MAPandXFS_IEXT_PUNCH_HOLE_CNTifXFS_BMAP_UNMAP.
You are right. I will include this change in the next version.
Quoted 44 lines
Whoever created the BUI should have called
xfs_iext_count_may_overflowbefore logging the BUI (and hence this should never occur) but it does pay to be careful. :)The rest of the logic in the patch looks ok.
--D
Quoted 34 lines
fs/xfs/xfs_bmap_item.c +3
-0+if (error) + goto err_inode; + count = bmap->me_len; error =xfs_trans_log_finish_bmap_update (tp, budp, type, ip, whichfork, bmap->me_startoff, bmap->me_startblock, &count, state);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
chandan
PATCH v4 4/10 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
Re: [PATCH V4 04/10] xfs: Check for extent overflow when adding/removing xattrs
Quoted 6 lines · Chandan Babu R
Adding/removing an xattr can cause
XFS_DA_NODE_MAXDEPTHextents 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.Signed-off-by Chandan Babu R <[email protected]>
Looks good, sorry I forgot to follow up on the V3 series.
--D
Quoted 72 lines
--- 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 v4 5/10 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
@@ -1159,6 +1159,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
@@ -1375,6 +1380,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
@@ -2850,6 +2860,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. */
@@ -3210,6 +3225,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
PATCH v4 6/10 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 v4 7/10 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 v4 8/10 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/libxfs/xfs_inode_fork.h | 15 +++++++++++++++ fs/xfs/xfs_reflink.c | 5 +++++ 2 files changed, 20 insertions(+)
fs/xfs/libxfs/xfs_inode_fork.h +15 -0
@@ -87,6 +87,21 @@ struct xfs_ifork {*/ #define XFS_IEXT_REFLINK_END_COW_CNT (2) +/* +* Remapping 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. +*/ +#define XFS_IEXT_REFLINK_REMAP_CNT (smap_real, dmap_written) \ + (((smap_real) ? 1 : 0) + ((dmap_written) ? 1 : 0)) +/* * Fork handling. */
fs/xfs/xfs_reflink.c +5 -0
@@ -1099,6 +1099,11 @@ xfs_reflink_remap_extent( goto out_cancel; } + error =xfs_iext_count_may_overflow (ip,XFS_DATA_FORK , +XFS_IEXT_REFLINK_REMAP_CNT (smap_real, dmap_written)); +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 v4 9/10 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_bmap.c | 18 +++++++++--------- fs/xfs/libxfs/xfs_bmap.h | 1 + fs/xfs/libxfs/xfs_inode_fork.h | 7 +++++++ fs/xfs/xfs_bmap_util.c | 17 +++++++++++++++++ 4 files changed, 34 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +9 -9
@@ -6104,15 +6104,6 @@ xfs_bmap_split_extent(return error; } -/* Deferred mapping is only for real extents in the data fork. */ -static bool -xfs_bmap_is_update_needed ( -struct xfs_bmbt_irec *bmap) -{ -return bmap->br_startblock !=HOLESTARTBLOCK && - bmap->br_startblock !=DELAYSTARTBLOCK ; -} -/* Record a bmap intent. */ static int __xfs_bmap_add(
@@ -6144,6 +6135,15 @@ __xfs_bmap_add(return 0 ; } +/* Deferred mapping is only for real extents in the data fork. */ +bool +xfs_bmap_is_update_needed ( +struct xfs_bmbt_irec *bmap) +{ +return bmap->br_startblock !=HOLESTARTBLOCK && + bmap->br_startblock !=DELAYSTARTBLOCK ; +} +/* Map an extent into a file. */ void xfs_bmap_map_extent(
fs/xfs/libxfs/xfs_bmap.h +1 -0
@@ -263,6 +263,7 @@ struct xfs_bmap_intent {struct xfs_bmbt_irec bi_bmap; }; +bool xfs_bmap_is_update_needed (struct xfs_bmbt_irec *bmap); int xfs_bmap_finish_one(struct xfs_trans *tp, struct xfs_inode *ip, enum xfs_bmap_intent_type type, int whichfork, xfs_fileoff_t startoff, xfs_fsblock_t startblock,
fs/xfs/libxfs/xfs_inode_fork.h +7 -0
@@ -102,6 +102,13 @@ struct xfs_ifork {#define XFS_IEXT_REFLINK_REMAP_CNT (smap_real, dmap_written) \ (((smap_real) ? 1 : 0) + ((dmap_written) ? 1 : 0)) +/* +* 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 +17 -0
@@ -28,6 +28,7 @@#include "xfs_icache.h" #include "xfs_iomap.h" #include "xfs_reflink.h" +#include "xfs_bmap.h" /* Kernel only BMAP related definitions and functions */
@@ -1407,6 +1408,22 @@ xfs_swap_extent_rmap( irec.br_blockcount);trace_xfs_swap_extent_rmap_remap_piece (tip, &uirec); +if (xfs_bmap_is_update_needed (&uirec)) { + error =xfs_iext_count_may_overflow (ip, +XFS_DATA_FORK , +XFS_IEXT_SWAP_RMAP_CNT ); +if (error) + goto out; + } + +if (xfs_bmap_is_update_needed (&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
Re: [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents
Quoted 34 lines · Chandan Babu R
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.
Signed-off-by Chandan Babu R <[email protected]>--- fs/xfs/libxfs/xfs_bmap.c | 18 +++++++++--------- fs/xfs/libxfs/xfs_bmap.h | 1 + fs/xfs/libxfs/xfs_inode_fork.h | 7 +++++++ fs/xfs/xfs_bmap_util.c | 17 +++++++++++++++++ 4 files changed, 34 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_bmap.c +0
-9@@ -6104,15 +6104,6 @@ xfs_bmap_split_extent(return error; } -/* Deferred mapping is only for real extents in the data fork. */ -static bool -xfs_bmap_is_update_needed ( -struct xfs_bmbt_irec *bmap) -{ -return bmap->br_startblock !=HOLESTARTBLOCK && - bmap->br_startblock !=DELAYSTARTBLOCK ; -} -/* Record a bmap intent. */ static int __xfs_bmap_add(@@ -6144,6 +6135,15 @@ __xfs_bmap_add(return 0 ;
fs/xfs/libxfs/xfs_bmap.c __xfs_bmap_add( · line 6145
Quoted 10 lines
fs/xfs/libxfs/xfs_bmap.c +8
-0} +/* Deferred mapping is only for real extents in the data fork. */ +bool +xfs_bmap_is_update_needed ( +struct xfs_bmbt_irec *bmap) +{ +return bmap->br_startblock !=HOLESTARTBLOCK && + bmap->br_startblock !=DELAYSTARTBLOCK ; +}
I think the predicate you want below is xfs_bmap_is_real_extent().
(I think that mostly because I'm going to kill this predicate entirely in a patch for the next cycle, because it is redundant and _is_real_extent is a better name.)
--D
Quoted 72 lines
fs/xfs/libxfs/xfs_bmap.c +1
-0+/* Map an extent into a file. */ void xfs_bmap_map_extent(fs/xfs/libxfs/xfs_bmap.h +1
-0@@ -263,6 +263,7 @@ struct xfs_bmap_intent {struct xfs_bmbt_irec bi_bmap; }; +bool xfs_bmap_is_update_needed (struct xfs_bmbt_irec *bmap); int xfs_bmap_finish_one(struct xfs_trans *tp, struct xfs_inode *ip, enum xfs_bmap_intent_type type, int whichfork, xfs_fileoff_t startoff, xfs_fsblock_t startblock,fs/xfs/libxfs/xfs_inode_fork.h +7
-0@@ -102,6 +102,13 @@ struct xfs_ifork {#define XFS_IEXT_REFLINK_REMAP_CNT (smap_real, dmap_written) \ (((smap_real) ? 1 : 0) + ((dmap_written) ? 1 : 0)) +/* +* 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 +17
-0@@ -28,6 +28,7 @@#include "xfs_icache.h" #include "xfs_iomap.h" #include "xfs_reflink.h" +#include "xfs_bmap.h" /* Kernel only BMAP related definitions and functions */ @@ -1407,6 +1408,22 @@ xfs_swap_extent_rmap( irec.br_blockcount);trace_xfs_swap_extent_rmap_remap_piece (tip, &uirec); +if (xfs_bmap_is_update_needed (&uirec)) { + error =xfs_iext_count_may_overflow (ip, +XFS_DATA_FORK , +XFS_IEXT_SWAP_RMAP_CNT ); +if (error) + goto out; + } + +if (xfs_bmap_is_update_needed (&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
Re: [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents
Quoted 37 lines · IST Darrick J. Wong
Quoted 36 lines · Chandan Babu R
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.
Signed-off-by Chandan Babu R <[email protected]>--- fs/xfs/libxfs/xfs_bmap.c | 18 +++++++++--------- fs/xfs/libxfs/xfs_bmap.h | 1 + fs/xfs/libxfs/xfs_inode_fork.h | 7 +++++++ fs/xfs/xfs_bmap_util.c | 17 +++++++++++++++++ 4 files changed, 34 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_bmap.c +0
-9@@ -6104,15 +6104,6 @@ xfs_bmap_split_extent(return error; } -/* Deferred mapping is only for real extents in the data fork. */ -static bool -xfs_bmap_is_update_needed ( -struct xfs_bmbt_irec *bmap) -{ -return bmap->br_startblock !=HOLESTARTBLOCK && - bmap->br_startblock !=DELAYSTARTBLOCK ; -} -/* Record a bmap intent. */ static int __xfs_bmap_add(@@ -6144,6 +6135,15 @@ __xfs_bmap_add(return 0 ; }
Quoted 10 lines
fs/xfs/libxfs/xfs_bmap.c __xfs_bmap_add( · line 6145
Quoted 8 lines
fs/xfs/libxfs/xfs_bmap.c +8
-0+/* Deferred mapping is only for real extents in the data fork. */ +bool +xfs_bmap_is_update_needed ( +struct xfs_bmbt_irec *bmap) +{ +return bmap->br_startblock !=HOLESTARTBLOCK && + bmap->br_startblock !=DELAYSTARTBLOCK ; +}I think the predicate you want below is
xfs_bmap_is_real_extent().
Yes, that is indeed correct. I will fix this one too.
Quoted 77 lines
(I think that mostly because I'm going to kill this predicate entirely in a patch for the next cycle, because it is redundant and
_is_real_extentis a better name.)--D
Quoted 69 lines
fs/xfs/libxfs/xfs_bmap.c +1
-0+/* Map an extent into a file. */ void xfs_bmap_map_extent(fs/xfs/libxfs/xfs_bmap.h +1
-0@@ -263,6 +263,7 @@ struct xfs_bmap_intent {struct xfs_bmbt_irec bi_bmap; }; +bool xfs_bmap_is_update_needed (struct xfs_bmbt_irec *bmap); int xfs_bmap_finish_one(struct xfs_trans *tp, struct xfs_inode *ip, enum xfs_bmap_intent_type type, int whichfork, xfs_fileoff_t startoff, xfs_fsblock_t startblock,fs/xfs/libxfs/xfs_inode_fork.h +7
-0@@ -102,6 +102,13 @@ struct xfs_ifork {#define XFS_IEXT_REFLINK_REMAP_CNT (smap_real, dmap_written) \ (((smap_real) ? 1 : 0) + ((dmap_written) ? 1 : 0)) +/* +* 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 +17
-0@@ -28,6 +28,7 @@#include "xfs_icache.h" #include "xfs_iomap.h" #include "xfs_reflink.h" +#include "xfs_bmap.h" /* Kernel only BMAP related definitions and functions */ @@ -1407,6 +1408,22 @@ xfs_swap_extent_rmap( irec.br_blockcount);trace_xfs_swap_extent_rmap_remap_piece (tip, &uirec); +if (xfs_bmap_is_update_needed (&uirec)) { + error =xfs_iext_count_may_overflow (ip, +XFS_DATA_FORK , +XFS_IEXT_SWAP_RMAP_CNT ); +if (error) + goto out; + } + +if (xfs_bmap_is_update_needed (&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
chandan
PATCH v4 10/10 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 (i.e. MAXERRTAGEXTNUM).
This commit makes the following additional changes to enable writing deterministic userspace tests for checking inode extent count overflow,
1. xfs_bmap_add_extent_hole_real()
File & disk offsets at which extents are allocated by Directory, Xattr and Realtime code cannot be controlled explicitly from userspace. When XFS_ERRTAG_REDUCE_MAX_IEXTENTS error tag is enabled, xfs_bmap_add_extent_hole_real() prevents extents from being merged even though the new extent might be contiguous and have the same state as its neighbours.
2. xfs_growfs_rt_alloc()
This function allocates as large an extent as possible to fit in the additional bitmap/summary blocks. We now force allocation of block sized extents when XFS_ERRTAG_REDUCE_MAX_IEXTENTS error tag is enabled.
--- fs/xfs/libxfs/xfs_bmap.c | 9 +++++++-- fs/xfs/libxfs/xfs_errortag.h | 4 +++- fs/xfs/libxfs/xfs_inode_fork.c | 4 ++++ fs/xfs/libxfs/xfs_types.h | 1 + fs/xfs/xfs_error.c | 3 +++ fs/xfs/xfs_rtalloc.c | 16 ++++++++++++++-- 6 files changed, 32 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +7 -2
@@ -2729,11 +2729,14 @@ xfs_bmap_add_extent_hole_real(int rval=0 ;/* return value (logging flags) */ int state =xfs_bmap_fork_to_state (whichfork);struct xfs_bmbt_irec old; +int test_iext_overflow;ASSERT (!isnullstartblock (new->br_startblock));ASSERT (!cur || !(cur->bc_ino.flags &XFS_BTCUR_BMBT_WASDEL ));XFS_STATS_INC (mp, xs_add_exlist); + test_iext_overflow =XFS_TEST_ERROR (false, ip->i_mount, +XFS_ERRTAG_REDUCE_MAX_IEXTENTS );/* * Check and set flags if this segment has a left neighbor.
@@ -2762,7 +2765,8 @@ xfs_bmap_add_extent_hole_real( left.br_startoff + left.br_blockcount == new->br_startoff && left.br_startblock + left.br_blockcount == new->br_startblock && left.br_state == new->br_state && - left.br_blockcount + new->br_blockcount <= MAXEXTLEN) + left.br_blockcount + new->br_blockcount <=MAXEXTLEN && + !test_iext_overflow) state |= BMAP_LEFT_CONTIG; if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
@@ -2772,7 +2776,8 @@ xfs_bmap_add_extent_hole_real( new->br_blockcount + right.br_blockcount <=MAXEXTLEN && (!(state &BMAP_LEFT_CONTIG ) || left.br_blockcount + new->br_blockcount + - right.br_blockcount <= MAXEXTLEN)) + right.br_blockcount <=MAXEXTLEN ) && + !test_iext_overflow) state |= BMAP_RIGHT_CONTIG; error =0 ;
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 =MAXERRTAGEXTNUM ; + nr_exts = ifp->if_nextents + nr_to_add;if (nr_exts < ifp->if_nextents || nr_exts > max_exts)return -EFBIG ;
fs/xfs/libxfs/xfs_types.h +1 -0
@@ -61,6 +61,7 @@ typedef void * xfs_failaddr_t;#define MAXEXTLEN ((xfs_extlen_t)0x001fffff)/* 21 bits */ #define MAXEXTNUM ((xfs_extnum_t)0x7fffffff)/* signed int */ #define MAXAEXTNUM ((xfs_aextnum_t)0x7fff)/* signed short */ +#define MAXERRTAGEXTNUM ((xfs_extnum_t)0xa)/* * Minimum and maximum blocksize and sectorsize.
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, };
fs/xfs/xfs_rtalloc.c +14 -2
@@ -18,6 +18,8 @@#include "xfs_trans_space.h" #include "xfs_icache.h" #include "xfs_rtalloc.h" +#include "xfs_error.h" +#include "xfs_errortag.h" /*
@@ -780,17 +782,27 @@ xfs_growfs_rt_alloc(int resblks;/* space reservation */ enum xfs_blft buf_type;struct xfs_trans *tp; +xfs_extlen_t nr_blks_alloc; +int test_iext_overflow;if (ip == mp->m_rsumip) buf_type =XFS_BLFT_RTSUMMARY_BUF ;else buf_type =XFS_BLFT_RTBITMAP_BUF ; + test_iext_overflow =XFS_TEST_ERROR (false, ip->i_mount, +XFS_ERRTAG_REDUCE_MAX_IEXTENTS ); +/* * Allocate space to the file, as necessary. */ while (oblocks < nblocks) { - resblks =XFS_GROWFSRT_SPACE_RES (mp, nblocks - oblocks); +if (likely (!test_iext_overflow)) + nr_blks_alloc = nblocks - oblocks; +else + nr_blks_alloc =1 ; + + resblks =XFS_GROWFSRT_SPACE_RES (mp, nr_blks_alloc);/* * Reserve space & log for one extent added to the file. */
@@ -813,7 +825,7 @@ xfs_growfs_rt_alloc(* Allocate blocks to the bitmap file. */ nmap =1 ; - error =xfs_bmapi_write (tp, ip, oblocks, nblocks - oblocks, + error =xfs_bmapi_write (tp, ip, oblocks, nr_blks_alloc,XFS_BMAPI_METADATA ,0 , &map, &nmap);if (!error && nmap <1 ) error = -ENOSPC ;
Signature · 1 line
2.28.0
Re: [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count
Quoted 5 lines · Chandan Babu R
This commit adds
XFS_ERRTAG_REDUCE_MAX_IEXTENTSerror tag which enables userspace programs to test "Inode fork extent count overflow detection" by reducing maximum possible inode fork extent count to
10 (i.e. MAXERRTAGEXTNUM).
Quoted 9 lines
This commit makes the following additional changes to enable writing deterministic userspace tests for checking inode extent count overflow,
1.xfs_bmap_add_extent_hole_real()
File & disk offsets at which extents are allocated by Directory, Xattr and Realtime code cannot be controlled explicitly from userspace. WhenXFS_ERRTAG_REDUCE_MAX_IEXTENTSerror tag is enabled,xfs_bmap_add_extent_hole_real()prevents extents from being merged even though the new extent might be contiguous and have the same state as its neighbours.
That sounds like fs corruption to me, since btree records are supposed to be maximally sized.
Quoted 5 lines
2.
xfs_growfs_rt_alloc()
This function allocates as large an extent as possible to fit in the additional bitmap/summary blocks. We now force allocation of block sized extents whenXFS_ERRTAG_REDUCE_MAX_IEXTENTSerror tag is enabled.
Ah, so your goal is to dramatically cut the MAX?EXTNUM and then force the allocator to fragment the fs, so that it will quickly hit that maximum.
/me suspects that "maximally fragment" ought to be a separate error injector that teaches the alloctor to satisfy the minimum required allocation, and to look only in the short end of the cntbt.
Quoted 97 lines
Signed-off-by Chandan Babu R <[email protected]>--- fs/xfs/libxfs/xfs_bmap.c | 9 +++++++-- fs/xfs/libxfs/xfs_errortag.h | 4 +++- fs/xfs/libxfs/xfs_inode_fork.c | 4 ++++ fs/xfs/libxfs/xfs_types.h | 1 + fs/xfs/xfs_error.c | 3 +++ fs/xfs/xfs_rtalloc.c | 16 ++++++++++++++-- 6 files changed, 32 insertions(+), 5 deletions(-)fs/xfs/libxfs/xfs_bmap.c +7
-2@@ -2729,11 +2729,14 @@ xfs_bmap_add_extent_hole_real(int rval=0 ;/* return value (logging flags) */ int state =xfs_bmap_fork_to_state (whichfork);struct xfs_bmbt_irec old; +int test_iext_overflow;ASSERT (!isnullstartblock (new->br_startblock));ASSERT (!cur || !(cur->bc_ino.flags &XFS_BTCUR_BMBT_WASDEL ));XFS_STATS_INC (mp, xs_add_exlist); + test_iext_overflow =XFS_TEST_ERROR (false, ip->i_mount, +XFS_ERRTAG_REDUCE_MAX_IEXTENTS );/* * Check and set flags if this segment has a left neighbor. @@ -2762,7 +2765,8 @@ xfs_bmap_add_extent_hole_real( left.br_startoff + left.br_blockcount == new->br_startoff && left.br_startblock + left.br_blockcount == new->br_startblock && left.br_state == new->br_state && - left.br_blockcount + new->br_blockcount <= MAXEXTLEN) + left.br_blockcount + new->br_blockcount <=MAXEXTLEN && + !test_iext_overflow) state |= BMAP_LEFT_CONTIG; if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&@@ -2772,7 +2776,8 @@ xfs_bmap_add_extent_hole_real( new->br_blockcount + right.br_blockcount <=MAXEXTLEN && (!(state &BMAP_LEFT_CONTIG ) || left.br_blockcount + new->br_blockcount + - right.br_blockcount <= MAXEXTLEN)) + right.br_blockcount <=MAXEXTLEN ) && + !test_iext_overflow) state |= BMAP_RIGHT_CONTIG; error =0 ;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 =MAXERRTAGEXTNUM ; + nr_exts = ifp->if_nextents + nr_to_add;if (nr_exts < ifp->if_nextents || nr_exts > max_exts)return -EFBIG ;fs/xfs/libxfs/xfs_types.h +0
-0
fs/xfs/libxfs/xfs_types.h typedef void * xfs_failaddr_t; · line 64
Quoted 4 lines
fs/xfs/libxfs/xfs_types.h +1
-0@@ -61,6 +61,7 @@ typedef void * xfs_failaddr_t;#define MAXEXTLEN ((xfs_extlen_t)0x001fffff)/* 21 bits */ #define MAXEXTNUM ((xfs_extnum_t)0x7fffffff)/* signed int */ #define MAXAEXTNUM ((xfs_aextnum_t)0x7fff)/* signed short */ +#define MAXERRTAGEXTNUM ((xfs_extnum_t)0xa)
FWIW you could probably just hardcode this in _count_may_overflow.
--D
Quoted 85 lines
fs/xfs/libxfs/xfs_types.h +0
-0/* * Minimum and maximum blocksize and sectorsize. 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, };fs/xfs/xfs_rtalloc.c +14
-2@@ -18,6 +18,8 @@#include "xfs_trans_space.h" #include "xfs_icache.h" #include "xfs_rtalloc.h" +#include "xfs_error.h" +#include "xfs_errortag.h" /* @@ -780,17 +782,27 @@ xfs_growfs_rt_alloc(int resblks;/* space reservation */ enum xfs_blft buf_type;struct xfs_trans *tp; +xfs_extlen_t nr_blks_alloc; +int test_iext_overflow;if (ip == mp->m_rsumip) buf_type =XFS_BLFT_RTSUMMARY_BUF ;else buf_type =XFS_BLFT_RTBITMAP_BUF ; + test_iext_overflow =XFS_TEST_ERROR (false, ip->i_mount, +XFS_ERRTAG_REDUCE_MAX_IEXTENTS ); +/* * Allocate space to the file, as necessary. */ while (oblocks < nblocks) { - resblks =XFS_GROWFSRT_SPACE_RES (mp, nblocks - oblocks); +if (likely (!test_iext_overflow)) + nr_blks_alloc = nblocks - oblocks; +else + nr_blks_alloc =1 ; + + resblks =XFS_GROWFSRT_SPACE_RES (mp, nr_blks_alloc);/* * Reserve space & log for one extent added to the file. */ @@ -813,7 +825,7 @@ xfs_growfs_rt_alloc(* Allocate blocks to the bitmap file. */ nmap =1 ; - error =xfs_bmapi_write (tp, ip, oblocks, nblocks - oblocks, + error =xfs_bmapi_write (tp, ip, oblocks, nr_blks_alloc,XFS_BMAPI_METADATA ,0 , &map, &nmap);if (!error && nmap <1 ) error = -ENOSPC ;Signature · 1 line
2.28.0
Re: [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count
Quoted 25 lines · IST Darrick J. Wong
Quoted 5 lines · Chandan Babu R
This commit adds
XFS_ERRTAG_REDUCE_MAX_IEXTENTSerror tag which enables userspace programs to test "Inode fork extent count overflow detection" by reducing maximum possible inode fork extent count to
10 (i.e. MAXERRTAGEXTNUM).Quoted 9 lines
This commit makes the following additional changes to enable writing deterministic userspace tests for checking inode extent count overflow,
1.xfs_bmap_add_extent_hole_real()
File & disk offsets at which extents are allocated by Directory, Xattr and Realtime code cannot be controlled explicitly from userspace. WhenXFS_ERRTAG_REDUCE_MAX_IEXTENTSerror tag is enabled,xfs_bmap_add_extent_hole_real()prevents extents from being merged even though the new extent might be contiguous and have the same state as its neighbours.That sounds like fs corruption to me, since btree records are supposed to be maximally sized.
Quoted 5 lines
2.
xfs_growfs_rt_alloc()
This function allocates as large an extent as possible to fit in the additional bitmap/summary blocks. We now force allocation of block sized extents whenXFS_ERRTAG_REDUCE_MAX_IEXTENTSerror tag is enabled.
Quoted 7 lines
Ah, so your goal is to dramatically cut the MAX?EXTNUM and then force the allocator to fragment the fs, so that it will quickly hit that maximum.
/me suspects that "maximally fragment" ought to be a separate error injector that teaches the alloctor to satisfy the minimum required allocation, and to look only in the short end of the cntbt.
This looks like a perfect fit for my requirements. I will take a shot at implementing this. Thanks for the suggestion.
Signature · 1 line
chandan