* [PATCH V4 01/10] xfs: Add helper for checking per-inode extent count overflow
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 02/10] xfs: Check for extent overflow when trivally adding a new extent Chandan Babu R
` (8 subsequent siblings)
9 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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.
Suggested-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
fs/xfs/libxfs/xfs_inode_fork.c | 23 +++++++++++++++++++++++
fs/xfs/libxfs/xfs_inode_fork.h | 2 ++
2 files changed, 25 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
index 7575de5cecb1..8d48716547e5 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.c
+++ b/fs/xfs/libxfs/xfs_inode_fork.c
@@ -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;
+}
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index a4953e95c4f3..0beb8e2a00be 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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__ */
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH V4 02/10] xfs: Check for extent overflow when trivally adding a new extent
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 01/10] xfs: Add helper for checking per-inode extent count overflow Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 03/10] xfs: Check for extent overflow when punching a hole Chandan Babu R
` (7 subsequent siblings)
9 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
When 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.
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
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(-)
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 1b0a01b06a05..51c2d2690f05 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -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) ||
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index 0beb8e2a00be..7fc2b129a2e7 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index f2a8a0e75e1f..dcd6e61df711 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -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,
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 3072814e407d..5bf22d2e50cb 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -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);
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 3abb8b9d6f4c..a302a96823b8 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -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);
/*
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 9d4e33d70d2a..3e841a75f272 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -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.
*/
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH V4 03/10] xfs: Check for extent overflow when punching a hole
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 01/10] xfs: Add helper for checking per-inode extent count overflow Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 02/10] xfs: Check for extent overflow when trivally adding a new extent Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 15:54 ` Darrick J. Wong
2020-09-18 9:47 ` [PATCH V4 04/10] xfs: Check for extent overflow when adding/removing xattrs Chandan Babu R
` (6 subsequent siblings)
9 siblings, 1 reply; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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 <chandanrlinux@gmail.com>
---
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(+)
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index 7fc2b129a2e7..bcac769a7df6 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c
index ec3691372e7c..5c7d08da8ff1 100644
--- a/fs/xfs/xfs_bmap_item.c
+++ b/fs/xfs/xfs_bmap_item.c
@@ -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);
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index dcd6e61df711..0776abd0103c 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -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
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* Re: [PATCH V4 03/10] xfs: Check for extent overflow when punching a hole
2020-09-18 9:47 ` [PATCH V4 03/10] xfs: Check for extent overflow when punching a hole Chandan Babu R
@ 2020-09-18 15:54 ` Darrick J. Wong
2020-09-19 9:42 ` Chandan Babu R
0 siblings, 1 reply; 18+ messages in thread
From: Darrick J. Wong @ 2020-09-18 15:54 UTC (permalink / raw)
To: Chandan Babu R; +Cc: linux-xfs, david
On Fri, Sep 18, 2020 at 03:17:52PM +0530, Chandan Babu R wrote:
> 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 <chandanrlinux@gmail.com>
> ---
> 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(+)
>
> diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
> index 7fc2b129a2e7..bcac769a7df6 100644
> --- a/fs/xfs/libxfs/xfs_inode_fork.h
> +++ b/fs/xfs/libxfs/xfs_inode_fork.h
> @@ -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.
> */
> diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c
> index ec3691372e7c..5c7d08da8ff1 100644
> --- a/fs/xfs/xfs_bmap_item.c
> +++ b/fs/xfs/xfs_bmap_item.c
> @@ -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
> + 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);
> diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
> index dcd6e61df711..0776abd0103c 100644
> --- a/fs/xfs/xfs_bmap_util.c
> +++ b/fs/xfs/xfs_bmap_util.c
> @@ -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
> --
> 2.28.0
>
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [PATCH V4 03/10] xfs: Check for extent overflow when punching a hole
2020-09-18 15:54 ` Darrick J. Wong
@ 2020-09-19 9:42 ` Chandan Babu R
0 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-19 9:42 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs, david
On Friday 18 September 2020 9:24:52 PM IST Darrick J. Wong wrote:
> On Fri, Sep 18, 2020 at 03:17:52PM +0530, Chandan Babu R wrote:
> > 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 <chandanrlinux@gmail.com>
> > ---
> > 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(+)
> >
> > diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
> > index 7fc2b129a2e7..bcac769a7df6 100644
> > --- a/fs/xfs/libxfs/xfs_inode_fork.h
> > +++ b/fs/xfs/libxfs/xfs_inode_fork.h
> > @@ -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.
> > */
> > diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c
> > index ec3691372e7c..5c7d08da8ff1 100644
> > --- a/fs/xfs/xfs_bmap_item.c
> > +++ b/fs/xfs/xfs_bmap_item.c
> > @@ -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.
You are right. I will include this change in the next version.
>
> 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
>
> > + 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);
> > diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
> > index dcd6e61df711..0776abd0103c 100644
> > --- a/fs/xfs/xfs_bmap_util.c
> > +++ b/fs/xfs/xfs_bmap_util.c
> > @@ -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
>
--
chandan
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH V4 04/10] xfs: Check for extent overflow when adding/removing xattrs
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
` (2 preceding siblings ...)
2020-09-18 9:47 ` [PATCH V4 03/10] xfs: Check for extent overflow when punching a hole Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 15:49 ` Darrick J. Wong
2020-09-18 9:47 ` [PATCH V4 05/10] xfs: Check for extent overflow when adding/removing dir entries Chandan Babu R
` (5 subsequent siblings)
9 siblings, 1 reply; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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.
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
fs/xfs/libxfs/xfs_attr.c | 13 +++++++++++++
fs/xfs/libxfs/xfs_inode_fork.h | 10 ++++++++++
2 files changed, 23 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index fd8e6418a0d3..be51e7068dcd 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -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;
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index bcac769a7df6..5de2f07d0dd5 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* Re: [PATCH V4 04/10] xfs: Check for extent overflow when adding/removing xattrs
2020-09-18 9:47 ` [PATCH V4 04/10] xfs: Check for extent overflow when adding/removing xattrs Chandan Babu R
@ 2020-09-18 15:49 ` Darrick J. Wong
0 siblings, 0 replies; 18+ messages in thread
From: Darrick J. Wong @ 2020-09-18 15:49 UTC (permalink / raw)
To: Chandan Babu R; +Cc: linux-xfs, david
On Fri, Sep 18, 2020 at 03:17:53PM +0530, Chandan Babu R wrote:
> 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.
>
> Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
Looks good, sorry I forgot to follow up on the V3 series.
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
--D
> ---
> fs/xfs/libxfs/xfs_attr.c | 13 +++++++++++++
> fs/xfs/libxfs/xfs_inode_fork.h | 10 ++++++++++
> 2 files changed, 23 insertions(+)
>
> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> index fd8e6418a0d3..be51e7068dcd 100644
> --- a/fs/xfs/libxfs/xfs_attr.c
> +++ b/fs/xfs/libxfs/xfs_attr.c
> @@ -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;
>
> diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
> index bcac769a7df6..5de2f07d0dd5 100644
> --- a/fs/xfs/libxfs/xfs_inode_fork.h
> +++ b/fs/xfs/libxfs/xfs_inode_fork.h
> @@ -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.
> */
> --
> 2.28.0
>
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH V4 05/10] xfs: Check for extent overflow when adding/removing dir entries
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
` (3 preceding siblings ...)
2020-09-18 9:47 ` [PATCH V4 04/10] xfs: Check for extent overflow when adding/removing xattrs Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 06/10] xfs: Check for extent overflow when writing to unwritten extent Chandan Babu R
` (4 subsequent siblings)
9 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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.
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
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(+)
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index 5de2f07d0dd5..fd93fdc67ee4 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 49624973eecc..f347b1911d9c 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -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
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index 8e88a7ca387e..581a4032a817 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -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.
*/
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH V4 06/10] xfs: Check for extent overflow when writing to unwritten extent
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
` (4 preceding siblings ...)
2020-09-18 9:47 ` [PATCH V4 05/10] xfs: Check for extent overflow when adding/removing dir entries Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 07/10] xfs: Check for extent overflow when moving extent from cow to data fork Chandan Babu R
` (3 subsequent siblings)
9 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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.
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
fs/xfs/libxfs/xfs_inode_fork.h | 8 ++++++++
fs/xfs/xfs_iomap.c | 5 +++++
2 files changed, 13 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index fd93fdc67ee4..afb647e1e3fa 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index a302a96823b8..2aa788379611 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -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.
*/
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH V4 07/10] xfs: Check for extent overflow when moving extent from cow to data fork
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
` (5 preceding siblings ...)
2020-09-18 9:47 ` [PATCH V4 06/10] xfs: Check for extent overflow when writing to unwritten extent Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 08/10] xfs: Check for extent overflow when remapping an extent Chandan Babu R
` (2 subsequent siblings)
9 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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.
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
fs/xfs/libxfs/xfs_inode_fork.h | 9 +++++++++
fs/xfs/xfs_reflink.c | 5 +++++
2 files changed, 14 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index afb647e1e3fa..b99e67e7b59b 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
index 16098dc42add..4f0198f636ad 100644
--- a/fs/xfs/xfs_reflink.c
+++ b/fs/xfs/xfs_reflink.c
@@ -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
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH V4 08/10] xfs: Check for extent overflow when remapping an extent
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
` (6 preceding siblings ...)
2020-09-18 9:47 ` [PATCH V4 07/10] xfs: Check for extent overflow when moving extent from cow to data fork Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents Chandan Babu R
2020-09-18 9:47 ` [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count Chandan Babu R
9 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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.
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
fs/xfs/libxfs/xfs_inode_fork.h | 15 +++++++++++++++
fs/xfs/xfs_reflink.c | 5 +++++
2 files changed, 20 insertions(+)
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index b99e67e7b59b..ded3c1b56c94 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
index 4f0198f636ad..c9f9ff68b5bb 100644
--- a/fs/xfs/xfs_reflink.c
+++ b/fs/xfs/xfs_reflink.c
@@ -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
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
` (7 preceding siblings ...)
2020-09-18 9:47 ` [PATCH V4 08/10] xfs: Check for extent overflow when remapping an extent Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 15:44 ` Darrick J. Wong
2020-09-18 9:47 ` [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count Chandan Babu R
9 siblings, 1 reply; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
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 <chandanrlinux@gmail.com>
---
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(-)
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 51c2d2690f05..9c665e379dfc 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -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(
diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
index e1bd484e5548..60fbe184d5f4 100644
--- a/fs/xfs/libxfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
@@ -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,
diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
index ded3c1b56c94..837c01595439 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.h
+++ b/fs/xfs/libxfs/xfs_inode_fork.h
@@ -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.
*/
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 0776abd0103c..542f990247c4 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -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);
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* Re: [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents
2020-09-18 9:47 ` [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents Chandan Babu R
@ 2020-09-18 15:44 ` Darrick J. Wong
2020-09-19 9:44 ` Chandan Babu R
0 siblings, 1 reply; 18+ messages in thread
From: Darrick J. Wong @ 2020-09-18 15:44 UTC (permalink / raw)
To: Chandan Babu R; +Cc: linux-xfs, david
On Fri, Sep 18, 2020 at 03:17:58PM +0530, Chandan Babu R wrote:
> 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 <chandanrlinux@gmail.com>
> ---
> 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(-)
>
> diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
> index 51c2d2690f05..9c665e379dfc 100644
> --- a/fs/xfs/libxfs/xfs_bmap.c
> +++ b/fs/xfs/libxfs/xfs_bmap.c
> @@ -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;
> +}
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
> +
> /* Map an extent into a file. */
> void
> xfs_bmap_map_extent(
> diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
> index e1bd484e5548..60fbe184d5f4 100644
> --- a/fs/xfs/libxfs/xfs_bmap.h
> +++ b/fs/xfs/libxfs/xfs_bmap.h
> @@ -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,
> diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
> index ded3c1b56c94..837c01595439 100644
> --- a/fs/xfs/libxfs/xfs_inode_fork.h
> +++ b/fs/xfs/libxfs/xfs_inode_fork.h
> @@ -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.
> */
> diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
> index 0776abd0103c..542f990247c4 100644
> --- a/fs/xfs/xfs_bmap_util.c
> +++ b/fs/xfs/xfs_bmap_util.c
> @@ -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);
>
> --
> 2.28.0
>
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents
2020-09-18 15:44 ` Darrick J. Wong
@ 2020-09-19 9:44 ` Chandan Babu R
0 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-19 9:44 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs, david
On Friday 18 September 2020 9:14:45 PM IST Darrick J. Wong wrote:
> On Fri, Sep 18, 2020 at 03:17:58PM +0530, Chandan Babu R wrote:
> > 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 <chandanrlinux@gmail.com>
> > ---
> > 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(-)
> >
> > diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
> > index 51c2d2690f05..9c665e379dfc 100644
> > --- a/fs/xfs/libxfs/xfs_bmap.c
> > +++ b/fs/xfs/libxfs/xfs_bmap.c
> > @@ -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;
> > +}
>
> I think the predicate you want below is xfs_bmap_is_real_extent().
Yes, that is indeed correct. I will fix this one too.
>
> (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
>
> > +
> > /* Map an extent into a file. */
> > void
> > xfs_bmap_map_extent(
> > diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
> > index e1bd484e5548..60fbe184d5f4 100644
> > --- a/fs/xfs/libxfs/xfs_bmap.h
> > +++ b/fs/xfs/libxfs/xfs_bmap.h
> > @@ -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,
> > diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h
> > index ded3c1b56c94..837c01595439 100644
> > --- a/fs/xfs/libxfs/xfs_inode_fork.h
> > +++ b/fs/xfs/libxfs/xfs_inode_fork.h
> > @@ -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.
> > */
> > diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
> > index 0776abd0103c..542f990247c4 100644
> > --- a/fs/xfs/xfs_bmap_util.c
> > +++ b/fs/xfs/xfs_bmap_util.c
> > @@ -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);
> >
>
--
chandan
^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count
2020-09-18 9:47 [PATCH V4 00/10] Bail out if transaction can cause extent count to overflow Chandan Babu R
` (8 preceding siblings ...)
2020-09-18 9:47 ` [PATCH V4 09/10] xfs: Check for extent overflow when swapping extents Chandan Babu R
@ 2020-09-18 9:47 ` Chandan Babu R
2020-09-18 15:39 ` Darrick J. Wong
9 siblings, 1 reply; 18+ messages in thread
From: Chandan Babu R @ 2020-09-18 9:47 UTC (permalink / raw)
To: linux-xfs; +Cc: Chandan Babu R, darrick.wong, david
This 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.
Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
---
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(-)
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 9c665e379dfc..287f0c4f6d33 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -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;
diff --git a/fs/xfs/libxfs/xfs_errortag.h b/fs/xfs/libxfs/xfs_errortag.h
index 53b305dea381..1c56fcceeea6 100644
--- a/fs/xfs/libxfs/xfs_errortag.h
+++ b/fs/xfs/libxfs/xfs_errortag.h
@@ -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_ */
diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
index 8d48716547e5..14389d10c597 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.c
+++ b/fs/xfs/libxfs/xfs_inode_fork.c
@@ -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;
diff --git a/fs/xfs/libxfs/xfs_types.h b/fs/xfs/libxfs/xfs_types.h
index 397d94775440..f2d6736b72e0 100644
--- a/fs/xfs/libxfs/xfs_types.h
+++ b/fs/xfs/libxfs/xfs_types.h
@@ -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.
diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index 7f6e20899473..3780b118cc47 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -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,
};
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 3e841a75f272..29a519fc30fb 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -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;
--
2.28.0
^ permalink raw reply related [flat|nested] 18+ messages in thread* Re: [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count
2020-09-18 9:47 ` [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count Chandan Babu R
@ 2020-09-18 15:39 ` Darrick J. Wong
2020-09-19 9:45 ` Chandan Babu R
0 siblings, 1 reply; 18+ messages in thread
From: Darrick J. Wong @ 2020-09-18 15:39 UTC (permalink / raw)
To: Chandan Babu R; +Cc: linux-xfs, david
On Fri, Sep 18, 2020 at 03:17:59PM +0530, Chandan Babu R wrote:
> This 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.
That sounds like fs corruption to me, since btree records are supposed
to be maximally sized.
> 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.
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.
> Signed-off-by: Chandan Babu R <chandanrlinux@gmail.com>
> ---
> 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(-)
>
> diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
> index 9c665e379dfc..287f0c4f6d33 100644
> --- a/fs/xfs/libxfs/xfs_bmap.c
> +++ b/fs/xfs/libxfs/xfs_bmap.c
> @@ -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;
> diff --git a/fs/xfs/libxfs/xfs_errortag.h b/fs/xfs/libxfs/xfs_errortag.h
> index 53b305dea381..1c56fcceeea6 100644
> --- a/fs/xfs/libxfs/xfs_errortag.h
> +++ b/fs/xfs/libxfs/xfs_errortag.h
> @@ -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_ */
> diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
> index 8d48716547e5..14389d10c597 100644
> --- a/fs/xfs/libxfs/xfs_inode_fork.c
> +++ b/fs/xfs/libxfs/xfs_inode_fork.c
> @@ -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;
> diff --git a/fs/xfs/libxfs/xfs_types.h b/fs/xfs/libxfs/xfs_types.h
> index 397d94775440..f2d6736b72e0 100644
> --- a/fs/xfs/libxfs/xfs_types.h
> +++ b/fs/xfs/libxfs/xfs_types.h
> @@ -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
>
> /*
> * Minimum and maximum blocksize and sectorsize.
> diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
> index 7f6e20899473..3780b118cc47 100644
> --- a/fs/xfs/xfs_error.c
> +++ b/fs/xfs/xfs_error.c
> @@ -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,
> };
>
> diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
> index 3e841a75f272..29a519fc30fb 100644
> --- a/fs/xfs/xfs_rtalloc.c
> +++ b/fs/xfs/xfs_rtalloc.c
> @@ -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;
> --
> 2.28.0
>
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [PATCH V4 10/10] xfs: Introduce error injection to reduce maximum inode fork extent count
2020-09-18 15:39 ` Darrick J. Wong
@ 2020-09-19 9:45 ` Chandan Babu R
0 siblings, 0 replies; 18+ messages in thread
From: Chandan Babu R @ 2020-09-19 9:45 UTC (permalink / raw)
To: Darrick J. Wong; +Cc: linux-xfs, david
On Friday 18 September 2020 9:09:30 PM IST Darrick J. Wong wrote:
> On Fri, Sep 18, 2020 at 03:17:59PM +0530, Chandan Babu R wrote:
> > This 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.
>
> That sounds like fs corruption to me, since btree records are supposed
> to be maximally sized.
>
> > 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.
>
> 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.
--
chandan
^ permalink raw reply [flat|nested] 18+ messages in thread