| Message ID | 20220301103938.1106808-15-chandan.babu@oracle.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | xfs: Extend per-inode extent counters | expand |
On Tue, Mar 01, 2022 at 04:09:35PM +0530, Chandan Babu R wrote: > This commit upgrades inodes to use 64-bit extent counters when they are read > from disk. Inodes are upgraded only when the filesystem instance has > XFS_SB_FEAT_INCOMPAT_NREXT64 incompat flag set. > > Reviewed-by: Darrick J. Wong <djwong@kernel.org> > Signed-off-by: Chandan Babu R <chandan.babu@oracle.com> > --- > fs/xfs/libxfs/xfs_attr.c | 3 ++- > fs/xfs/libxfs/xfs_bmap.c | 5 ++--- > fs/xfs/libxfs/xfs_inode_fork.c | 37 ++++++++++++++++++++++++++++++++++ > fs/xfs/libxfs/xfs_inode_fork.h | 2 ++ > fs/xfs/xfs_bmap_item.c | 3 ++- > fs/xfs/xfs_bmap_util.c | 10 ++++----- > fs/xfs/xfs_dquot.c | 2 +- > fs/xfs/xfs_iomap.c | 5 +++-- > fs/xfs/xfs_reflink.c | 5 +++-- > fs/xfs/xfs_rtalloc.c | 2 +- > 10 files changed, 58 insertions(+), 16 deletions(-) > > diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c > index 23523b802539..03a358930d74 100644 > --- a/fs/xfs/libxfs/xfs_attr.c > +++ b/fs/xfs/libxfs/xfs_attr.c > @@ -774,7 +774,8 @@ xfs_attr_set( > return error; > > if (args->value || xfs_inode_hasattr(dp)) { > - error = xfs_iext_count_may_overflow(dp, XFS_ATTR_FORK, > + error = xfs_trans_inode_ensure_nextents(&args->trans, dp, > + XFS_ATTR_FORK, > XFS_IEXT_ATTR_MANIP_CNT(rmt_blks)); hmmmm. > if (error) > goto out_trans_cancel; > diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c > index be7f8ebe3cd5..3a3c99ef7f13 100644 > --- a/fs/xfs/libxfs/xfs_bmap.c > +++ b/fs/xfs/libxfs/xfs_bmap.c > @@ -4523,14 +4523,13 @@ xfs_bmapi_convert_delalloc( > return error; > > xfs_ilock(ip, XFS_ILOCK_EXCL); > + xfs_trans_ijoin(tp, ip, 0); > > - error = xfs_iext_count_may_overflow(ip, whichfork, > + error = xfs_trans_inode_ensure_nextents(&tp, 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) || > bma.got.br_startoff > offset_fsb) { > /* > diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c > index a3a3b54f9c55..d1d065abeac3 100644 > --- a/fs/xfs/libxfs/xfs_inode_fork.c > +++ b/fs/xfs/libxfs/xfs_inode_fork.c > @@ -757,3 +757,40 @@ xfs_iext_count_may_overflow( > > return 0; > } > + > +/* > + * Ensure that the inode has the ability to add the specified number of > + * extents. Caller must hold ILOCK_EXCL and have joined the inode to > + * the transaction. Upon return, the inode will still be in this state > + * upon return and the transaction will be clean. > + */ > +int > +xfs_trans_inode_ensure_nextents( > + struct xfs_trans **tpp, > + struct xfs_inode *ip, > + int whichfork, > + int nr_to_add) Ok, xfs_trans_inode* is a namespace that belongs to fs/xfs/xfs_trans_inode.c, not fs/xfs/libxfs/xfs_inode_fork.c. So my second observation is that the function needs either be renamed or moved. My first observation was that the function name didn't really make any sense to me when read in context. xfs_iext_count_may_overflow() makes sense because it's telling me that it's checking that the extent count hasn't overflowed. xfs_trans_inode_ensure_nextents() conveys none of that certainty. What does it ensure? "ensure" doesn't imply we are goign to change anything - it could just mean "check and abort if wrong" when read as "ensure we haven't overflowed". And if we already have nrext64 and we've overflowed that then it will still fail, meaning we haven't "ensured" anything. This would make much more sense if written as: error = xfs_iext_count_may_overflow(); if (error && error != -EOVERFLOW) goto out_trans_cancel; if (error == -EOVERFLOW) { error = xfs_inode_upgrade_extent_counts(); if (error) goto out_trans_cancel; } Because it splits the logic into a "do we need to do something" part and a "do an explicit modification" part. > +{ > + int error; > + > + error = xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); > + if (!error) > + return 0; > + > + /* > + * Try to upgrade if the extent count fields aren't large > + * enough. > + */ > + if (!xfs_has_nrext64(ip->i_mount) || > + (ip->i_diflags2 & XFS_DIFLAG2_NREXT64)) > + return error; Oh, that's tricky, too. The first check returns if there's no error, the second check returns the error of the first function. Keeping the initial overflow check in the caller gets rid of this, too. > + > + ip->i_diflags2 |= XFS_DIFLAG2_NREXT64; > + xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE); > + > + error = xfs_trans_roll(tpp); > + if (error) > + return error; Why does this need to roll the transaction? We can just log the inode core and return to the caller which will then commit the change. > + return xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); If the answer is so we don't cancel a dirty transaction here, then I think this check needs to be more explicit - don't even try to do the upgrade if the number of extents we are adding will cause an overflow anyway. As it is, wouldn't adding 2^47 - 2^31 extents in a single hit be indicative of a bug? We can only modify the extent count by a handful of extents (10, maybe 20?) at most in a single transaction, so why do we even need this check? Cheers, Dave.
On 04 Mar 2022 at 13:21, Dave Chinner wrote: > On Tue, Mar 01, 2022 at 04:09:35PM +0530, Chandan Babu R wrote: >> This commit upgrades inodes to use 64-bit extent counters when they are read >> from disk. Inodes are upgraded only when the filesystem instance has >> XFS_SB_FEAT_INCOMPAT_NREXT64 incompat flag set. >> >> Reviewed-by: Darrick J. Wong <djwong@kernel.org> >> Signed-off-by: Chandan Babu R <chandan.babu@oracle.com> >> --- >> fs/xfs/libxfs/xfs_attr.c | 3 ++- >> fs/xfs/libxfs/xfs_bmap.c | 5 ++--- >> fs/xfs/libxfs/xfs_inode_fork.c | 37 ++++++++++++++++++++++++++++++++++ >> fs/xfs/libxfs/xfs_inode_fork.h | 2 ++ >> fs/xfs/xfs_bmap_item.c | 3 ++- >> fs/xfs/xfs_bmap_util.c | 10 ++++----- >> fs/xfs/xfs_dquot.c | 2 +- >> fs/xfs/xfs_iomap.c | 5 +++-- >> fs/xfs/xfs_reflink.c | 5 +++-- >> fs/xfs/xfs_rtalloc.c | 2 +- >> 10 files changed, 58 insertions(+), 16 deletions(-) >> >> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c >> index 23523b802539..03a358930d74 100644 >> --- a/fs/xfs/libxfs/xfs_attr.c >> +++ b/fs/xfs/libxfs/xfs_attr.c >> @@ -774,7 +774,8 @@ xfs_attr_set( >> return error; >> >> if (args->value || xfs_inode_hasattr(dp)) { >> - error = xfs_iext_count_may_overflow(dp, XFS_ATTR_FORK, >> + error = xfs_trans_inode_ensure_nextents(&args->trans, dp, >> + XFS_ATTR_FORK, >> XFS_IEXT_ATTR_MANIP_CNT(rmt_blks)); > > hmmmm. > >> if (error) >> goto out_trans_cancel; >> diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c >> index be7f8ebe3cd5..3a3c99ef7f13 100644 >> --- a/fs/xfs/libxfs/xfs_bmap.c >> +++ b/fs/xfs/libxfs/xfs_bmap.c >> @@ -4523,14 +4523,13 @@ xfs_bmapi_convert_delalloc( >> return error; >> >> xfs_ilock(ip, XFS_ILOCK_EXCL); >> + xfs_trans_ijoin(tp, ip, 0); >> >> - error = xfs_iext_count_may_overflow(ip, whichfork, >> + error = xfs_trans_inode_ensure_nextents(&tp, 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) || >> bma.got.br_startoff > offset_fsb) { >> /* >> diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c >> index a3a3b54f9c55..d1d065abeac3 100644 >> --- a/fs/xfs/libxfs/xfs_inode_fork.c >> +++ b/fs/xfs/libxfs/xfs_inode_fork.c >> @@ -757,3 +757,40 @@ xfs_iext_count_may_overflow( >> >> return 0; >> } >> + >> +/* >> + * Ensure that the inode has the ability to add the specified number of >> + * extents. Caller must hold ILOCK_EXCL and have joined the inode to >> + * the transaction. Upon return, the inode will still be in this state >> + * upon return and the transaction will be clean. >> + */ >> +int >> +xfs_trans_inode_ensure_nextents( >> + struct xfs_trans **tpp, >> + struct xfs_inode *ip, >> + int whichfork, >> + int nr_to_add) > > Ok, xfs_trans_inode* is a namespace that belongs to > fs/xfs/xfs_trans_inode.c, not fs/xfs/libxfs/xfs_inode_fork.c. So my > second observation is that the function needs either be renamed or > moved. > > My first observation was that the function name didn't really make > any sense to me when read in context. xfs_iext_count_may_overflow() > makes sense because it's telling me that it's checking that the > extent count hasn't overflowed. xfs_trans_inode_ensure_nextents() > conveys none of that certainty. > > What does it ensure? "ensure" doesn't imply we are goign to change > anything - it could just mean "check and abort if wrong" when read > as "ensure we haven't overflowed". And if we already have nrext64 > and we've overflowed that then it will still fail, meaning we > haven't "ensured" anything. > > This would make much more sense if written as: > > error = xfs_iext_count_may_overflow(); > if (error && error != -EOVERFLOW) > goto out_trans_cancel; > > if (error == -EOVERFLOW) { > error = xfs_inode_upgrade_extent_counts(); > if (error) > goto out_trans_cancel; > } > > Because it splits the logic into a "do we need to do something" > part and a "do an explicit modification" part. > Ok. The above logic is much better than xfs_trans_inode_ensure_nextents(). Also, I will define xfs_inode_upgrade_extent_counts() in libxfs/xfs_inode_fork.c since the function is supposed to operate on inode extent counts. >> +{ >> + int error; >> + >> + error = xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); >> + if (!error) >> + return 0; >> + >> + /* >> + * Try to upgrade if the extent count fields aren't large >> + * enough. >> + */ >> + if (!xfs_has_nrext64(ip->i_mount) || >> + (ip->i_diflags2 & XFS_DIFLAG2_NREXT64)) >> + return error; > > Oh, that's tricky, too. The first check returns if there's no error, > the second check returns the error of the first function. Keeping > the initial overflow check in the caller gets rid of this, too. > >> + >> + ip->i_diflags2 |= XFS_DIFLAG2_NREXT64; >> + xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE); >> + >> + error = xfs_trans_roll(tpp); >> + if (error) >> + return error; > > Why does this need to roll the transaction? We can just log the > inode core and return to the caller which will then commit the > change. Transaction was rolled in order to make sure that we don't overflow log reservations (computed in libxfs/xfs_trans_resv.c). But now I see that any transaction which causes inode's extent count to change would have considered the space required to log an inode in its reservation calculation. Hence, I will remove the above call to xfs_trans_roll(). >> + return xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); > > If the answer is so we don't cancel a dirty transaction here, then > I think this check needs to be more explicit - don't even try to do > the upgrade if the number of extents we are adding will cause an > overflow anyway. > > As it is, wouldn't adding 2^47 - 2^31 extents in a single hit be > indicative of a bug? We can only modify the extent count by a > handful of extents (10, maybe 20?) at most in a single transaction, > so why do we even need this check? Yes, the above call to xfs_iext_count_may_overflow() is not correct. The value of nr_to_add has to be larger than 2^17 (2^32 - 2^15 for attr fork and 2^48 - 2^31 for data fork) for extent count to overflow. Hence, I will remove this call to xfs_iext_count_may_overflow().
On Sat, Mar 05, 2022 at 06:15:15PM +0530, Chandan Babu R wrote: > On 04 Mar 2022 at 13:21, Dave Chinner wrote: > > On Tue, Mar 01, 2022 at 04:09:35PM +0530, Chandan Babu R wrote: > >> This commit upgrades inodes to use 64-bit extent counters when they are read > >> from disk. Inodes are upgraded only when the filesystem instance has > >> XFS_SB_FEAT_INCOMPAT_NREXT64 incompat flag set. > >> > >> Reviewed-by: Darrick J. Wong <djwong@kernel.org> > >> Signed-off-by: Chandan Babu R <chandan.babu@oracle.com> ..... > >> + return xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); > > > > If the answer is so we don't cancel a dirty transaction here, then > > I think this check needs to be more explicit - don't even try to do > > the upgrade if the number of extents we are adding will cause an > > overflow anyway. > > > > As it is, wouldn't adding 2^47 - 2^31 extents in a single hit be > > indicative of a bug? We can only modify the extent count by a > > handful of extents (10, maybe 20?) at most in a single transaction, > > so why do we even need this check? > > Yes, the above call to xfs_iext_count_may_overflow() is not correct. The value > of nr_to_add has to be larger than 2^17 (2^32 - 2^15 for attr fork and 2^48 - > 2^31 for data fork) for extent count to overflow. Hence, I will remove this > call to xfs_iext_count_may_overflow(). Would it be worth putting an assert somewhere with this logic in it? That way we at least capture such bugs in debug settings and protect ourselves from unintentional mistakes. Cheers, Dave.
On 07 Mar 2022 at 10:32, Dave Chinner wrote: > On Sat, Mar 05, 2022 at 06:15:15PM +0530, Chandan Babu R wrote: >> On 04 Mar 2022 at 13:21, Dave Chinner wrote: >> > On Tue, Mar 01, 2022 at 04:09:35PM +0530, Chandan Babu R wrote: >> >> This commit upgrades inodes to use 64-bit extent counters when they are read >> >> from disk. Inodes are upgraded only when the filesystem instance has >> >> XFS_SB_FEAT_INCOMPAT_NREXT64 incompat flag set. >> >> >> >> Reviewed-by: Darrick J. Wong <djwong@kernel.org> >> >> Signed-off-by: Chandan Babu R <chandan.babu@oracle.com> > ..... >> >> + return xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); >> > >> > If the answer is so we don't cancel a dirty transaction here, then >> > I think this check needs to be more explicit - don't even try to do >> > the upgrade if the number of extents we are adding will cause an >> > overflow anyway. >> > >> > As it is, wouldn't adding 2^47 - 2^31 extents in a single hit be >> > indicative of a bug? We can only modify the extent count by a >> > handful of extents (10, maybe 20?) at most in a single transaction, >> > so why do we even need this check? >> >> Yes, the above call to xfs_iext_count_may_overflow() is not correct. The value >> of nr_to_add has to be larger than 2^17 (2^32 - 2^15 for attr fork and 2^48 - >> 2^31 for data fork) for extent count to overflow. Hence, I will remove this >> call to xfs_iext_count_may_overflow(). > > Would it be worth putting an assert somewhere with this logic in it? > That way we at least capture such bugs in debug settings and protect > ourselves from unintentional mistakes. > Sure. I will add an ASSERT() call to check if we ever add more than 2^17 extents in a single modification of an inode's data/attr fork extent count.
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c index 23523b802539..03a358930d74 100644 --- a/fs/xfs/libxfs/xfs_attr.c +++ b/fs/xfs/libxfs/xfs_attr.c @@ -774,7 +774,8 @@ xfs_attr_set( return error; if (args->value || xfs_inode_hasattr(dp)) { - error = xfs_iext_count_may_overflow(dp, XFS_ATTR_FORK, + error = xfs_trans_inode_ensure_nextents(&args->trans, dp, + XFS_ATTR_FORK, XFS_IEXT_ATTR_MANIP_CNT(rmt_blks)); if (error) goto out_trans_cancel; diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c index be7f8ebe3cd5..3a3c99ef7f13 100644 --- a/fs/xfs/libxfs/xfs_bmap.c +++ b/fs/xfs/libxfs/xfs_bmap.c @@ -4523,14 +4523,13 @@ xfs_bmapi_convert_delalloc( return error; xfs_ilock(ip, XFS_ILOCK_EXCL); + xfs_trans_ijoin(tp, ip, 0); - error = xfs_iext_count_may_overflow(ip, whichfork, + error = xfs_trans_inode_ensure_nextents(&tp, 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) || bma.got.br_startoff > offset_fsb) { /* diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c index a3a3b54f9c55..d1d065abeac3 100644 --- a/fs/xfs/libxfs/xfs_inode_fork.c +++ b/fs/xfs/libxfs/xfs_inode_fork.c @@ -757,3 +757,40 @@ xfs_iext_count_may_overflow( return 0; } + +/* + * Ensure that the inode has the ability to add the specified number of + * extents. Caller must hold ILOCK_EXCL and have joined the inode to + * the transaction. Upon return, the inode will still be in this state + * upon return and the transaction will be clean. + */ +int +xfs_trans_inode_ensure_nextents( + struct xfs_trans **tpp, + struct xfs_inode *ip, + int whichfork, + int nr_to_add) +{ + int error; + + error = xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); + if (!error) + return 0; + + /* + * Try to upgrade if the extent count fields aren't large + * enough. + */ + if (!xfs_has_nrext64(ip->i_mount) || + (ip->i_diflags2 & XFS_DIFLAG2_NREXT64)) + return error; + + ip->i_diflags2 |= XFS_DIFLAG2_NREXT64; + xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE); + + error = xfs_trans_roll(tpp); + if (error) + return error; + + return xfs_iext_count_may_overflow(ip, whichfork, nr_to_add); +} diff --git a/fs/xfs/libxfs/xfs_inode_fork.h b/fs/xfs/libxfs/xfs_inode_fork.h index 8e6221e32660..65265ca51b0d 100644 --- a/fs/xfs/libxfs/xfs_inode_fork.h +++ b/fs/xfs/libxfs/xfs_inode_fork.h @@ -286,6 +286,8 @@ 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); +int xfs_trans_inode_ensure_nextents(struct xfs_trans **tpp, + struct xfs_inode *ip, int whichfork, int nr_to_add); /* returns true if the fork has extents but they are not read in yet. */ static inline bool xfs_need_iread_extents(struct xfs_ifork *ifp) diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c index e1f4d7d5a011..27bc16a2b09b 100644 --- a/fs/xfs/xfs_bmap_item.c +++ b/fs/xfs/xfs_bmap_item.c @@ -505,7 +505,8 @@ xfs_bui_item_recover( else iext_delta = XFS_IEXT_PUNCH_HOLE_CNT; - error = xfs_iext_count_may_overflow(ip, whichfork, iext_delta); + error = xfs_trans_inode_ensure_nextents(&tp, ip, whichfork, + iext_delta); if (error) goto err_cancel; diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c index eb2e387ba528..8d86d8d5ad88 100644 --- a/fs/xfs/xfs_bmap_util.c +++ b/fs/xfs/xfs_bmap_util.c @@ -855,7 +855,7 @@ xfs_alloc_file_space( if (error) break; - error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, XFS_IEXT_ADD_NOSPLIT_CNT); if (error) goto error; @@ -910,7 +910,7 @@ xfs_unmap_extent( if (error) return error; - error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, XFS_IEXT_PUNCH_HOLE_CNT); if (error) goto out_trans_cancel; @@ -1191,7 +1191,7 @@ 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, + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, XFS_IEXT_PUNCH_HOLE_CNT); if (error) goto out_trans_cancel; @@ -1418,7 +1418,7 @@ xfs_swap_extent_rmap( trace_xfs_swap_extent_rmap_remap_piece(tip, &uirec); if (xfs_bmap_is_real_extent(&uirec)) { - error = xfs_iext_count_may_overflow(ip, + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, XFS_IEXT_SWAP_RMAP_CNT); if (error) @@ -1426,7 +1426,7 @@ xfs_swap_extent_rmap( } if (xfs_bmap_is_real_extent(&irec)) { - error = xfs_iext_count_may_overflow(tip, + error = xfs_trans_inode_ensure_nextents(&tp, tip, XFS_DATA_FORK, XFS_IEXT_SWAP_RMAP_CNT); if (error) diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c index 5afedcbc78c7..193a2e66efc7 100644 --- a/fs/xfs/xfs_dquot.c +++ b/fs/xfs/xfs_dquot.c @@ -320,7 +320,7 @@ xfs_dquot_disk_alloc( goto err_cancel; } - error = xfs_iext_count_may_overflow(quotip, XFS_DATA_FORK, + error = xfs_trans_inode_ensure_nextents(&tp, quotip, XFS_DATA_FORK, XFS_IEXT_ADD_NOSPLIT_CNT); if (error) goto err_cancel; diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c index e552ce541ec2..4078d5324090 100644 --- a/fs/xfs/xfs_iomap.c +++ b/fs/xfs/xfs_iomap.c @@ -250,7 +250,8 @@ xfs_iomap_write_direct( if (error) return error; - error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, nr_exts); + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, + nr_exts); if (error) goto out_trans_cancel; @@ -553,7 +554,7 @@ xfs_iomap_write_unwritten( if (error) return error; - error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, XFS_IEXT_WRITE_UNWRITTEN_CNT); if (error) goto error_on_bmapi_transaction; diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c index db70060e7bf6..9d4fd2b160ff 100644 --- a/fs/xfs/xfs_reflink.c +++ b/fs/xfs/xfs_reflink.c @@ -615,7 +615,7 @@ 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, + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, XFS_IEXT_REFLINK_END_COW_CNT); if (error) goto out_cancel; @@ -1117,7 +1117,8 @@ xfs_reflink_remap_extent( if (dmap_written) ++iext_delta; - error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, iext_delta); + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, + iext_delta); if (error) goto out_cancel; diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c index a70140b35e8b..6d4a16534b1f 100644 --- a/fs/xfs/xfs_rtalloc.c +++ b/fs/xfs/xfs_rtalloc.c @@ -806,7 +806,7 @@ xfs_growfs_rt_alloc( xfs_trans_ijoin(tp, ip, 0); unlock_inode = true; - error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, + error = xfs_trans_inode_ensure_nextents(&tp, ip, XFS_DATA_FORK, XFS_IEXT_ADD_NOSPLIT_CNT); if (error) goto out_trans_cancel;