zoned xfs updates
Hi Carlos,
this series as a bunch of zones fixes, and a trivial code movement to move the ioend code into it's own file.
Andrey just sent a basically identical version of the third patch, but I'm including here as this is the series I tested. Feel free to take his version and take my indendent reimplementation as a reviewed-by.
Diffstat:
Makefile | 1 xfs_aops.c | 188 ------------------------------------------------------- xfs_aops.h | 1 xfs_file.c | 2 xfs_ioend.c | 184 +++++++++++++++++++++++++++++++++++++++++++++++++++++ xfs_ioend.h | 16 ++++ xfs_iomap.c | 7 -- xfs_iomap.h | 14 ++++ xfs_zone_alloc.c | 56 ++++++++++++---- 9 files changed, 263 insertions(+), 206 deletions(-)
PATCH 1/5 xfs: handle NULL open_zone for merged ioends in xfs_ioend_put_open_zones
In theory we could fail multiple ioends before an open zoned was assigned to them, and the iomap code could merge them. Check for NULL not only for the main ioend but also all merged ones on ->io_list to handle this case.
--- fs/xfs/xfs_aops.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/xfs/xfs_aops.c +4 -2
@@ -89,8 +89,10 @@ xfs_ioend_put_open_zones(/* * Put the open zone for all ioends merged into this one (if any). */ -list_for_each_entry (tmp, &ioend->io_list, io_list) -xfs_open_zone_put (tmp->io_private); +list_for_each_entry (tmp, &ioend->io_list, io_list) { +if (tmp->io_private) +xfs_open_zone_put (tmp->io_private); + }/* * The main ioend might not have an open zone if the submission failed
Signature · 1 line
2.53.0
Re: [PATCH 1/5] xfs: handle NULL open_zone for merged ioends in xfs_ioend_put_open_zones
Quoted 1 line · Christoph Hellwig
In theory we could fail multiple ioends before an open zoned was assigned
...an open zone...
Quoted 6 lines
to them, and the iomap code could merge them. Check for NULL not only for the main ioend but also all merged ones on ->io_list to handle this case.
Fixes 058dd70c65ab ("xfs: implement buffered writes to zoned RT devices")Signed-off-by Christoph Hellwig <[email protected]>
Seems reasonable to me.
--D
Quoted 25 lines
--- fs/xfs/xfs_aops.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)fs/xfs/xfs_aops.c +4
-2@@ -89,8 +89,10 @@ xfs_ioend_put_open_zones(/* * Put the open zone for all ioends merged into this one (if any). */ -list_for_each_entry (tmp, &ioend->io_list, io_list) -xfs_open_zone_put (tmp->io_private); +list_for_each_entry (tmp, &ioend->io_list, io_list) { +if (tmp->io_private) +xfs_open_zone_put (tmp->io_private); + }/* * The main ioend might not have an open zone if the submission failed Signature · 1 line
2.53.0
PATCH 2/5 xfs: fix racy open zone caching
In reply to Christoph HellwigWhen testing on very fast storage devices, I've observed writers using io_uring creating many open zones with just a few kiB written to it, which then don't get used. I tracked this down to multiple io_uring helper threads finding a full zone in i_private, and then going on to select a one, with the final one winning the race and leaving it in i_private.
Fix this by dropping full zones from i_private as soon we find them, checking cached for a cached zoned when a single writes needs a new zone, and by keeping an existing cached zone in xfs_set_cached_zone when it still has space available, dropping the newly found/allocated one instead. This uses i_flags_lock as a low-level spinlock for short hold times to avoid interactions with the ilock, which is used for completions.
--- fs/xfs/xfs_zone_alloc.c | 56 +++++++++++++++++++++++++++++++---------- 1 file changed, 43 insertions(+), 13 deletions(-)
fs/xfs/xfs_zone_alloc.c +43 -13
@@ -793,17 +793,35 @@ xfs_get_cached_zone(rcu_read_lock (); oz =VFS_I (ip)->i_private; -if (oz) { -/* -* GC only steals open zones at mount time, so no GC zones -* should end up in the cache. -*/ -ASSERT (!oz->oz_is_gc); -if (!atomic_inc_not_zero (&oz->oz_ref)) +if (!oz) + goto out_unlock; + +/* +* GC only steals open zones at mount time, so no GC zones should end up +* in the cache. +*/ +ASSERT (!oz->oz_is_gc); + +/* +* Drop the old cached open zone if it is full. +*/ +if (oz->oz_allocated ==rtg_blocks (oz->oz_rtg)) { +spin_lock (&ip->i_flags_lock); + oz =VFS_I (ip)->i_private; +if (oz && oz->oz_allocated ==rtg_blocks (oz->oz_rtg)) { +VFS_I (ip)->i_private =NULL ; +spin_unlock (&ip->i_flags_lock); +xfs_open_zone_put (oz); oz =NULL ; + goto out_unlock; + } +spin_unlock (&ip->i_flags_lock); } -rcu_read_unlock (); +if (oz && !atomic_inc_not_zero (&oz->oz_ref)) + oz =NULL ; +out_unlock: +rcu_read_unlock ();return oz; }
@@ -819,17 +837,30 @@ xfs_get_cached_zone(* lookup. Because the open_zone is clearly marked as full when all data * in the underlying RTG was written, the caching is always safe. */ -static void +static struct xfs_open_zone *xfs_set_cached_zone (struct xfs_inode *ip,struct xfs_open_zone *oz) {struct xfs_open_zone *old_oz; +/* +* If the open zone cached in the inode still has free space, use that +* instead of the inode we just selected. This can happen when multiple +* threads race to perform zone selection for an inode. io_uring worker +* threads seem to be good at triggering this. +*/ +spin_lock (&ip->i_flags_lock); + old_oz =VFS_I (ip)->i_private; +if (old_oz && old_oz->oz_allocated <rtg_blocks (old_oz->oz_rtg)) +swap (oz, old_oz);atomic_inc (&oz->oz_ref); - old_oz =xchg (&VFS_I (ip)->i_private, oz); +VFS_I (ip)->i_private = oz; +spin_unlock (&ip->i_flags_lock); +if (old_oz)xfs_open_zone_put (old_oz); +return oz; } static void
@@ -873,14 +904,13 @@ xfs_zone_alloc_and_submit(* the inode is still associated with a zone and use that if so. */ if (!*oz) +select_zone: *oz =xfs_get_cached_zone (ip); -if (!*oz) { -select_zone: *oz =xfs_select_zone (mp, write_hint, pack_tight);if (!*oz) goto out_error; -xfs_set_cached_zone (ip, *oz); + *oz =xfs_set_cached_zone (ip, *oz); } alloc_len = xfs_zone_alloc_blocks(*oz, XFS_B_TO_FSB(mp, ioend->io_size),
Signature · 1 line
2.53.0
Re: [PATCH 2/5] xfs: fix racy open zone caching
Quoted 53 lines · Christoph Hellwig
When testing on very fast storage devices, I've observed writers using
io_uringcreating many open zones with just a few kiB written to it, which then don't get used. I tracked this down to multipleio_uringhelper threads finding a full zone ini_private, and then going on to select a one, with the final one winning the race and leaving it ini_private.Fix this by dropping full zones from
i_privateas soon we find them, checking cached for a cached zoned when a single writes needs a new zone, and by keeping an existing cached zone inxfs_set_cached_zonewhen it still has space available, dropping the newly found/allocated one instead. This usesi_flags_lockas a low-level spinlock for short hold times to avoid interactions with the ilock, which is used for completions.Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_zone_alloc.c | 56 +++++++++++++++++++++++++++++++---------- 1 file changed, 43 insertions(+), 13 deletions(-)fs/xfs/xfs_zone_alloc.c +18
-7@@ -793,17 +793,35 @@ xfs_get_cached_zone(rcu_read_lock (); oz =VFS_I (ip)->i_private; -if (oz) { -/* -* GC only steals open zones at mount time, so no GC zones -* should end up in the cache. -*/ -ASSERT (!oz->oz_is_gc); -if (!atomic_inc_not_zero (&oz->oz_ref)) +if (!oz) + goto out_unlock; + +/* +* GC only steals open zones at mount time, so no GC zones should end up +* in the cache. +*/ +ASSERT (!oz->oz_is_gc); + +/* +* Drop the old cached open zone if it is full. +*/ +if (oz->oz_allocated ==rtg_blocks (oz->oz_rtg)) { +spin_lock (&ip->i_flags_lock); + oz =VFS_I (ip)->i_private; +if (oz && oz->oz_allocated ==rtg_blocks (oz->oz_rtg)) { +VFS_I (ip)->i_private =NULL ; +spin_unlock (&ip->i_flags_lock);
fs/xfs/xfs_zone_alloc.c xfs_get_cached_zone( · line 822
Quoted 10 lines
fs/xfs/xfs_zone_alloc.c +6
-1+xfs_open_zone_put (oz); oz =NULL ; + goto out_unlock; + } +spin_unlock (&ip->i_flags_lock); } -rcu_read_unlock (); +if (oz && !atomic_inc_not_zero (&oz->oz_ref)) + oz =NULL ;
Do we still need to test oz for null-ness here? AFAICT we've already handled those cases here.
Quoted 18 lines
fs/xfs/xfs_zone_alloc.c +4
-1+out_unlock: +rcu_read_unlock ();return oz; }@@ -819,17 +837,30 @@ xfs_get_cached_zone(* lookup. Because the open_zone is clearly marked as full when all data * in the underlying RTG was written, the caching is always safe. */ -static void +static struct xfs_open_zone *xfs_set_cached_zone (struct xfs_inode *ip,struct xfs_open_zone *oz) {struct xfs_open_zone *old_oz; +/*
fs/xfs/xfs_zone_alloc.c xfs_get_cached_zone( · line 857
Quoted 10 lines
fs/xfs/xfs_zone_alloc.c +9
-0+* If the open zone cached in the inode still has free space, use that +* instead of the inode we just selected. This can happen when multiple +* threads race to perform zone selection for an inode. io_uring worker +* threads seem to be good at triggering this. +*/ +spin_lock (&ip->i_flags_lock); + old_oz =VFS_I (ip)->i_private; +if (old_oz && old_oz->oz_allocated <rtg_blocks (old_oz->oz_rtg)) +swap (oz, old_oz);atomic_inc (&oz->oz_ref);
Hmm, I'm confused about oz_ref handling here.
If old_oz still has space, we swap oz and old_oz, after which oz alias i_private and old_oz is the zone that the caller passed in. The above line then increments oz->oz_ref and puts the zone that the caller passed in.
Doesn't that cause oz->oz_ref to be too high? We already had a ref via i_private, and now we have another one.
--D
Quoted 31 lines
fs/xfs/xfs_zone_alloc.c +6
-4- old_oz =xchg (&VFS_I (ip)->i_private, oz); +VFS_I (ip)->i_private = oz; +spin_unlock (&ip->i_flags_lock); +if (old_oz)xfs_open_zone_put (old_oz); +return oz; } static void@@ -873,14 +904,13 @@ xfs_zone_alloc_and_submit(* the inode is still associated with a zone and use that if so. */ if (!*oz) +select_zone: *oz =xfs_get_cached_zone (ip); -if (!*oz) { -select_zone: *oz =xfs_select_zone (mp, write_hint, pack_tight);if (!*oz) goto out_error; -xfs_set_cached_zone (ip, *oz); + *oz =xfs_set_cached_zone (ip, *oz); } alloc_len = xfs_zone_alloc_blocks(*oz, XFS_B_TO_FSB(mp, ioend->io_size),Signature · 1 line
2.53.0
Re: [PATCH 2/5] xfs: fix racy open zone caching
Quoted 5 lines · Darrick J. Wong
fs/xfs/xfs_zone_alloc.c xfs_get_cached_zone( · line 822
Quoted 2 lines
fs/xfs/xfs_zone_alloc.c +2
-0+if (oz && !atomic_inc_not_zero (&oz->oz_ref)) + oz =NULL ;Do we still need to test oz for null-ness here? AFAICT we've already handled those cases here.
Yeah, that can go away.
Quoted 8 lines
fs/xfs/xfs_zone_alloc.c xfs_get_cached_zone( · line 857
Quoted 5 lines
fs/xfs/xfs_zone_alloc.c +4
-0+spin_lock (&ip->i_flags_lock); + old_oz =VFS_I (ip)->i_private; +if (old_oz && old_oz->oz_allocated <rtg_blocks (old_oz->oz_rtg)) +swap (oz, old_oz);atomic_inc (&oz->oz_ref);Hmm, I'm confused about
oz_refhandling here.
Quoted 7 lines
If
old_ozstill has space, we swap oz andold_oz, after which oz aliasi_privateandold_ozis the zone that the caller passed in. The above line then incrementsoz->oz_refand puts the zone that the caller passed in.Doesn't that cause
oz->oz_refto be too high? We already had a ref viai_private, and now we have another one.
The caller needs a reference, and i_private needs a reference. But this is a bit to oclever to understand, we probably should be doing atomic_inc_not_zero for the i_private case as well. I'll rework this to be a bit more clear.
PATCH 3/5 xfs: fix zoned write iomap flags assignments
In reply to Christoph HellwigDon't overwrite IOMAP_F_DIRTY with IOMAP_F_ANON_WRITE, but ensure both flags are set instead.
Note that in practice this is harmless as all zoned writes force a metadata transaction anyway, but incorrectly assigned flags are still a landmine that will cause problems at some point.
--- fs/xfs/xfs_aops.c | 3 +-- fs/xfs/xfs_iomap.c | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-)
fs/xfs/xfs_aops.c +1 -2
@@ -634,11 +634,10 @@ xfs_zoned_map_blocks(xfs_iunlock (ip,XFS_ILOCK_EXCL ); wpc->iomap.type =IOMAP_MAPPED ; - wpc->iomap.flags =IOMAP_F_DIRTY ; wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; wpc->iomap.offset = offset; wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); - wpc->iomap.flags =IOMAP_F_ANON_WRITE ; + wpc->iomap.flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ;trace_xfs_zoned_map_blocks (ip, offset, wpc->iomap.length);return 0 ;
fs/xfs/xfs_iomap.c +1 -2
@@ -1081,11 +1081,10 @@ xfs_zoned_direct_write_iomap_begin( } iomap->type =IOMAP_MAPPED ; - iomap->flags =IOMAP_F_DIRTY ; iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev; iomap->offset = offset; iomap->length = length; - iomap->flags =IOMAP_F_ANON_WRITE ; + iomap->flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ;return 0 ; }
Signature · 1 line
2.53.0
Re: [PATCH 3/5] xfs: fix zoned write iomap flags assignments
Quoted 10 lines · Christoph Hellwig
Don't overwrite
IOMAP_F_DIRTYwithIOMAP_F_ANON_WRITE, but ensure both flags are set instead.Note that in practice this is harmless as all zoned writes force a metadata transaction anyway, but incorrectly assigned flags are still a landmine that will cause problems at some point.
Fixes 058dd70c65ab ("xfs: implement buffered writes to zoned RT devices")Fixes 2e2383405824 ("xfs: implement direct writes to zoned RT devices")Signed-off-by Christoph Hellwig <[email protected]>
Looks good to me
Quoted 10 lines
--- fs/xfs/xfs_aops.c | 3 +-- fs/xfs/xfs_iomap.c | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-)fs/xfs/xfs_aops.c +0
-0
fs/xfs/xfs_aops.c xfs_zoned_map_blocks( · line 640
Quoted 9 lines
fs/xfs/xfs_aops.c +1
-2@@ -634,11 +634,10 @@ xfs_zoned_map_blocks(xfs_iunlock (ip,XFS_ILOCK_EXCL ); wpc->iomap.type =IOMAP_MAPPED ; - wpc->iomap.flags =IOMAP_F_DIRTY ; wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; wpc->iomap.offset = offset; wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); - wpc->iomap.flags =IOMAP_F_ANON_WRITE ; + wpc->iomap.flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ;
Does it make sense to set IOMAP_F_DIRTY here? I haven't found how it could be used
Signature · 1 line
- Andrey
Re: [PATCH 3/5] xfs: fix zoned write iomap flags assignments
Quoted 7 lines · Andrey Albershteyn
Quoted 7 lines
fs/xfs/xfs_aops.c +0
-0@@ -634,11 +634,10 @@ xfs_zoned_map_blocks(xfs_iunlock (ip,XFS_ILOCK_EXCL );
Quoted 10 lines
fs/xfs/xfs_aops.c xfs_zoned_map_blocks( · line 640
Quoted 7 lines
fs/xfs/xfs_aops.c +1
-2wpc->iomap.type =IOMAP_MAPPED ; - wpc->iomap.flags =IOMAP_F_DIRTY ; wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; wpc->iomap.offset = offset; wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); - wpc->iomap.flags =IOMAP_F_ANON_WRITE ; + wpc->iomap.flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ;Does it make sense to set
IOMAP_F_DIRTYhere? I haven't found how it could be used
Well, by the protocol of the flag we should set it as the update requires a transaction to be persisted. But you are right in the sense that nothing actually looks at it for zoned right now.
Re: [PATCH 3/5] xfs: fix zoned write iomap flags assignments
In reply to Christoph HellwigQuoted 10 lines · Christoph Hellwig
Don't overwrite
IOMAP_F_DIRTYwithIOMAP_F_ANON_WRITE, but ensure both flags are set instead.Note that in practice this is harmless as all zoned writes force a metadata transaction anyway, but incorrectly assigned flags are still a landmine that will cause problems at some point.
Fixes 058dd70c65ab ("xfs: implement buffered writes to zoned RT devices")Fixes 2e2383405824 ("xfs: implement direct writes to zoned RT devices")Signed-off-by Christoph Hellwig <[email protected]>
Looks good,
--D
Quoted 43 lines
--- fs/xfs/xfs_aops.c | 3 +-- fs/xfs/xfs_iomap.c | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-)fs/xfs/xfs_aops.c +1
-2@@ -634,11 +634,10 @@ xfs_zoned_map_blocks(xfs_iunlock (ip,XFS_ILOCK_EXCL ); wpc->iomap.type =IOMAP_MAPPED ; - wpc->iomap.flags =IOMAP_F_DIRTY ; wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; wpc->iomap.offset = offset; wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); - wpc->iomap.flags =IOMAP_F_ANON_WRITE ; + wpc->iomap.flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ;trace_xfs_zoned_map_blocks (ip, offset, wpc->iomap.length);return 0 ;fs/xfs/xfs_iomap.c +1
-2@@ -1081,11 +1081,10 @@ xfs_zoned_direct_write_iomap_begin( } iomap->type =IOMAP_MAPPED ; - iomap->flags =IOMAP_F_DIRTY ; iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev; iomap->offset = offset; iomap->length = length; - iomap->flags =IOMAP_F_ANON_WRITE ; + iomap->flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ;return 0 ; }Signature · 1 line
2.53.0
PATCH 4/5 xfs: factor out a xfs_iomap_set_anon_write helper
In reply to Christoph HellwigDe-duplicate the iomap setup for zoned writes.
--- fs/xfs/xfs_aops.c | 8 ++------ fs/xfs/xfs_iomap.c | 6 +----- fs/xfs/xfs_iomap.h | 14 ++++++++++++++ 3 files changed, 17 insertions(+), 11 deletions(-)
fs/xfs/xfs_aops.c +2 -6
@@ -633,12 +633,8 @@ xfs_zoned_map_blocks( XFS_BMAPI_REMAP);xfs_iunlock (ip,XFS_ILOCK_EXCL ); - wpc->iomap.type =IOMAP_MAPPED ; - wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; - wpc->iomap.offset = offset; - wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); - wpc->iomap.flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ; - +xfs_iomap_set_anon_write (ip, &wpc->iomap, offset, +XFS_FSB_TO_B (mp, count_fsb));trace_xfs_zoned_map_blocks (ip, offset, wpc->iomap.length);return 0 ; }
fs/xfs/xfs_iomap.c +1 -5
@@ -1080,11 +1080,7 @@ xfs_zoned_direct_write_iomap_begin(return error; } - iomap->type =IOMAP_MAPPED ; - iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev; - iomap->offset = offset; - iomap->length = length; - iomap->flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ; +xfs_iomap_set_anon_write (ip, iomap, offset, length);return 0 ; }
fs/xfs/xfs_iomap.h +14 -0
@@ -29,6 +29,20 @@ int xfs_zero_range(struct xfs_inode *ip, loff_t pos, loff_t len,int xfs_truncate_page (struct xfs_inode *ip,loff_t pos,struct xfs_zone_alloc_ctx *ac,bool *did_zero); +static inline void +xfs_iomap_set_anon_write ( +struct xfs_inode *ip, +struct iomap *iomap, +loff_t offset, +loff_t length) +{ + iomap->type =IOMAP_MAPPED ; + iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev; + iomap->offset = offset; + iomap->length = length; + iomap->flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ; +} + static inline xfs_filblks_t xfs_aligned_fsb_count( xfs_fileoff_t offset_fsb,
Signature · 1 line
2.53.0
Re: [PATCH 4/5] xfs: factor out a xfs_iomap_set_anon_write helper
Quoted 52 lines · Christoph Hellwig
De-duplicate the iomap setup for zoned writes.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_aops.c | 8 ++------ fs/xfs/xfs_iomap.c | 6 +----- fs/xfs/xfs_iomap.h | 14 ++++++++++++++ 3 files changed, 17 insertions(+), 11 deletions(-)fs/xfs/xfs_aops.c +2
-6@@ -633,12 +633,8 @@ xfs_zoned_map_blocks( XFS_BMAPI_REMAP);xfs_iunlock (ip,XFS_ILOCK_EXCL ); - wpc->iomap.type =IOMAP_MAPPED ; - wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; - wpc->iomap.offset = offset; - wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); - wpc->iomap.flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ; - +xfs_iomap_set_anon_write (ip, &wpc->iomap, offset, +XFS_FSB_TO_B (mp, count_fsb));trace_xfs_zoned_map_blocks (ip, offset, wpc->iomap.length);return 0 ; }fs/xfs/xfs_iomap.c +1
-5@@ -1080,11 +1080,7 @@ xfs_zoned_direct_write_iomap_begin(return error; } - iomap->type =IOMAP_MAPPED ; - iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev; - iomap->offset = offset; - iomap->length = length; - iomap->flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ; +xfs_iomap_set_anon_write (ip, iomap, offset, length);return 0 ; }fs/xfs/xfs_iomap.h +0
-0@@ -29,6 +29,20 @@ int xfs_zero_range(struct xfs_inode *ip, loff_t pos, loff_t len,int xfs_truncate_page (struct xfs_inode *ip,loff_t pos,struct xfs_zone_alloc_ctx *ac,bool *did_zero);
fs/xfs/xfs_iomap.h int xfs_zero_range(struct xfs_inode *ip, loff_t pos, loff_t len, · line 40
Quoted 10 lines
fs/xfs/xfs_iomap.h +9
-0+static inline void +xfs_iomap_set_anon_write ( +struct xfs_inode *ip, +struct iomap *iomap, +loff_t offset, +loff_t length) +{ + iomap->type =IOMAP_MAPPED ; + iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev;
/me wonders if this should use xfs_inode_buftarg() to avoid some logic bomb, but that's sorta overkill since we can't ever do anonymous writes to the data device.
As a straight hoist this is 100% correct so
--D
Quoted 12 lines
fs/xfs/xfs_iomap.h +5
-0+ iomap->offset = offset; + iomap->length = length; + iomap->flags =IOMAP_F_ANON_WRITE |IOMAP_F_DIRTY ; +} + static inline xfs_filblks_t xfs_aligned_fsb_count( xfs_fileoff_t offset_fsb,Signature · 1 line
2.53.0
PATCH 5/5 xfs: split ioend handling into a separate source file
In reply to Christoph HellwigThe ioend handling used to be only for buffered writeback, but has been extended to direct I/O and reads. Split it into a new source file.
--- fs/xfs/Makefile | 1 + fs/xfs/xfs_aops.c | 181 +------------------------------------------- fs/xfs/xfs_aops.h | 1 - fs/xfs/xfs_file.c | 2 +- fs/xfs/xfs_ioend.c | 184 +++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_ioend.h | 16 ++++ 6 files changed, 203 insertions(+), 182 deletions(-) create mode 100644 fs/xfs/xfs_ioend.c create mode 100644 fs/xfs/xfs_ioend.h
fs/xfs/Makefile +1 -0
@@ -91,6 +91,7 @@ xfs-y += xfs_aops.o \ xfs_healthmon.o \ xfs_icache.o \ xfs_ioctl.o \ + xfs_ioend.o \ xfs_iomap.o \ xfs_iops.o \ xfs_inode.o \
fs/xfs/xfs_aops.c +1 -180
199 lines not on this page · raw message
fs/xfs/xfs_aops.h +0 -1
@@ -10,6 +10,5 @@ extern const struct address_space_operations xfs_address_space_operations;extern const struct address_space_operations xfs_dax_aops;int xfs_setfilesize (struct xfs_inode *ip,xfs_off_t offset,size_t size); -void xfs_end_bio (struct bio *bio);#endif /* __XFS_AOPS_H__ */
fs/xfs/xfs_file.c +1 -1
@@ -25,7 +25,7 @@#include "xfs_iomap.h" #include "xfs_reflink.h" #include "xfs_file.h" -#include "xfs_aops.h" +#include "xfs_ioend.h" #include "xfs_zone_alloc.h" #include "xfs_error.h" #include "xfs_errortag.h"
fs/xfs/xfs_ioend.c new file +184 -0
184 lines not on this page · raw message
fs/xfs/xfs_ioend.h new file +16 -0
@@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __XFS_IOEND_H +#define __XFS_IOEND_H + +/* +* Fast and loose check if this write could update the on-disk inode size. +*/ +static inline bool xfs_ioend_is_append (struct iomap_ioend *ioend) +{ +return ioend->io_offset + ioend->io_size > +XFS_I (ioend->io_inode)->i_disk_size; +} + +void xfs_end_bio (struct bio *bio); + +#endif /* __XFS_IOEND_H */
Signature · 1 line
2.53.0