reduce sub-block DIO serialisation v3
Subsystems (7)
This takes the approach from Dave, but adds a new flag instead of abusing the nowait one, and keeps a simpler calling convention for iomap_dio_rw.
Changes since v2:
- add another sanity check in __iomap_dio_rw
- rename IOMAP_DIO_UNALIGNED to IOMAP_DIO_OVERWRITE_ONLY
- use more consistent parameter naming
- improve a few comments
- cleanup an if statement
Changes since v1:
- rename the new flags
- add an EOF check for subblock I/O
- minor cleanups
PATCH 1/11 xfs: factor out a xfs_ilock_iocb helper
Add a helper to factor out the nowait locking logical for the read/write helpers.
--- fs/xfs/xfs_file.c | 55 +++++++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 26 deletions(-)
fs/xfs/xfs_file.c +29 -26
@@ -197,6 +197,23 @@ xfs_file_fsync(return error; } +static int +xfs_ilock_iocb ( +struct kiocb *iocb, +unsigned int lock_mode) +{ +struct xfs_inode *ip =XFS_I (file_inode (iocb->ki_filp)); + +if (iocb->ki_flags &IOCB_NOWAIT ) { +if (!xfs_ilock_nowait (ip, lock_mode)) +return -EAGAIN ; + }else { +xfs_ilock (ip, lock_mode); + } + +return 0 ; +} + STATIC ssize_t xfs_file_dio_aio_read( struct kiocb *iocb,
@@ -213,12 +230,9 @@ xfs_file_dio_aio_read(file_accessed (iocb->ki_filp); -if (iocb->ki_flags &IOCB_NOWAIT ) { -if (!xfs_ilock_nowait (ip,XFS_IOLOCK_SHARED )) -return -EAGAIN ; - }else { -xfs_ilock (ip,XFS_IOLOCK_SHARED ); - } + ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED ); +if (ret) +return ret; ret =iomap_dio_rw (iocb, to, &xfs_read_iomap_ops,NULL ,is_sync_kiocb (iocb));xfs_iunlock (ip,XFS_IOLOCK_SHARED );
@@ -240,13 +254,9 @@ xfs_file_dax_read(if (!count)return 0 ;/* skip atime */ -if (iocb->ki_flags &IOCB_NOWAIT ) { -if (!xfs_ilock_nowait (ip,XFS_IOLOCK_SHARED )) -return -EAGAIN ; - }else { -xfs_ilock (ip,XFS_IOLOCK_SHARED ); - } - + ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED ); +if (ret) +return ret; ret =dax_iomap_rw (iocb, to, &xfs_read_iomap_ops);xfs_iunlock (ip,XFS_IOLOCK_SHARED );
@@ -264,12 +274,9 @@ xfs_file_buffered_aio_read(trace_xfs_file_buffered_read (ip,iov_iter_count (to), iocb->ki_pos); -if (iocb->ki_flags &IOCB_NOWAIT ) { -if (!xfs_ilock_nowait (ip,XFS_IOLOCK_SHARED )) -return -EAGAIN ; - }else { -xfs_ilock (ip,XFS_IOLOCK_SHARED ); - } + ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED ); +if (ret) +return ret; ret =generic_file_read_iter (iocb, to);xfs_iunlock (ip,XFS_IOLOCK_SHARED );
@@ -608,13 +615,9 @@ xfs_file_dax_write(size_t count;loff_t pos; -if (iocb->ki_flags &IOCB_NOWAIT ) { -if (!xfs_ilock_nowait (ip, iolock)) -return -EAGAIN ; - }else { -xfs_ilock (ip, iolock); - } - + ret =xfs_ilock_iocb (iocb, iolock); +if (ret) +return ret; ret =xfs_file_aio_write_checks (iocb, from, &iolock);if (ret) goto out;
Signature · 1 line
2.29.2
PATCH 2/11 xfs: make xfs_file_aio_write_checks IOCB_NOWAIT-aware
In reply to Christoph HellwigEnsure we don't block on the iolock, or waiting for I/O in xfs_file_aio_write_checks if the caller asked to avoid that.
--- fs/xfs/xfs_file.c | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-)
fs/xfs/xfs_file.c +21 -4
@@ -335,7 +335,14 @@ xfs_file_aio_write_checks(if (error <=0 )return error; - error =xfs_break_layouts (inode, iolock,BREAK_WRITE ); +if (iocb->ki_flags &IOCB_NOWAIT ) { + error =break_layout (inode, false); +if (error == -EWOULDBLOCK ) + error = -EAGAIN ; + }else { + error =xfs_break_layouts (inode, iolock,BREAK_WRITE ); + } +if (error)return error;
@@ -346,7 +353,11 @@ xfs_file_aio_write_checks(if (*iolock ==XFS_IOLOCK_SHARED && !IS_NOSEC (inode)) {xfs_iunlock (ip, *iolock); *iolock =XFS_IOLOCK_EXCL ; -xfs_ilock (ip, *iolock); + error =xfs_ilock_iocb (iocb, *iolock); +if (error) { + *iolock =0 ; +return error; + } goto restart; }/*
@@ -368,6 +379,10 @@ xfs_file_aio_write_checks( isize =i_size_read (inode);if (iocb->ki_pos > isize) {spin_unlock (&ip->i_flags_lock); + +if (iocb->ki_flags &IOCB_NOWAIT ) +return -EAGAIN ; +if (!drained_dio) {if (*iolock ==XFS_IOLOCK_SHARED ) {xfs_iunlock (ip, *iolock);
@@ -593,7 +608,8 @@ xfs_file_dio_aio_write( &xfs_dio_write_ops, is_sync_kiocb(iocb) || unaligned_io); out: -xfs_iunlock (ip, iolock); +if (iolock) +xfs_iunlock (ip, iolock);/* * No fallback to buffered IO after short writes for XFS, direct I/O
@@ -632,7 +648,8 @@ xfs_file_dax_write( error =xfs_setfilesize (ip, pos, ret); } out: -xfs_iunlock (ip, iolock); +if (iolock) +xfs_iunlock (ip, iolock);if (error)return error;
Signature · 1 line
2.29.2
PATCH 3/11 xfs: cleanup the read/write helper naming
In reply to Christoph HellwigDrop a few pointless aio_ prefixes.
--- fs/xfs/xfs_file.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-)
fs/xfs/xfs_file.c +15 -15
@@ -215,7 +215,7 @@ xfs_ilock_iocb( } STATIC ssize_t -xfs_file_dio_aio_read ( +xfs_file_dio_read (struct kiocb *iocb,struct iov_iter *to) {
@@ -265,7 +265,7 @@ xfs_file_dax_read( } STATIC ssize_t -xfs_file_buffered_aio_read ( +xfs_file_buffered_read (struct kiocb *iocb,struct iov_iter *to) {
@@ -300,9 +300,9 @@ xfs_file_read_iter(if (IS_DAX (inode)) ret =xfs_file_dax_read (iocb, to);else if (iocb->ki_flags &IOCB_DIRECT ) - ret =xfs_file_dio_aio_read (iocb, to); + ret =xfs_file_dio_read (iocb, to);else - ret =xfs_file_buffered_aio_read (iocb, to); + ret =xfs_file_buffered_read (iocb, to);if (ret >0 )XFS_STATS_ADD (mp, xs_read_bytes, ret);
@@ -317,7 +317,7 @@ xfs_file_read_iter(* if called for a direct write beyond i_size. */ STATIC ssize_t -xfs_file_aio_write_checks ( +xfs_file_write_checks (struct kiocb *iocb,struct iov_iter *from,int *iolock)
@@ -502,7 +502,7 @@ static const struct iomap_dio_ops xfs_dio_write_ops = { };/* -* xfs_file_dio_aio_write - handle direct IO writes +* xfs_file_dio_write - handle direct IO writes * * Lock the inode appropriately to prepare for and issue a direct IO write. * By separating it from the buffered write path we remove all the tricky to
@@ -527,7 +527,7 @@ static const struct iomap_dio_ops xfs_dio_write_ops = {* negative return values. */ STATIC ssize_t -xfs_file_dio_aio_write ( +xfs_file_dio_write (struct kiocb *iocb,struct iov_iter *from) {
@@ -549,7 +549,7 @@ xfs_file_dio_aio_write(/* * Don't take the exclusive iolock here unless the I/O is unaligned to * the file system block size. We don't need to consider the EOF -* extension case here because xfs_file_aio_write_checks() will relock +* extension case here because xfs_file_write_checks() will relock * the inode as necessary for EOF zeroing cases and fill out the new * inode size as appropriate. */
@@ -580,7 +580,7 @@ xfs_file_dio_aio_write(xfs_ilock (ip, iolock); } - ret =xfs_file_aio_write_checks (iocb, from, &iolock); + ret =xfs_file_write_checks (iocb, from, &iolock);if (ret) goto out; count =iov_iter_count (from);
@@ -590,7 +590,7 @@ xfs_file_dio_aio_write(* in-flight at the same time or we risk data corruption. Wait for all * other IO to drain before we submit. If the IO is aligned, demote the * iolock if we had to take the exclusive lock in -* xfs_file_aio_write_checks() for other reasons. +* xfs_file_write_checks() for other reasons. */ if (unaligned_io) {inode_dio_wait (inode);
@@ -634,7 +634,7 @@ xfs_file_dax_write( ret =xfs_ilock_iocb (iocb, iolock);if (ret)return ret; - ret =xfs_file_aio_write_checks (iocb, from, &iolock); + ret =xfs_file_write_checks (iocb, from, &iolock);if (ret) goto out;
@@ -663,7 +663,7 @@ xfs_file_dax_write( } STATIC ssize_t -xfs_file_buffered_aio_write ( +xfs_file_buffered_write (struct kiocb *iocb,struct iov_iter *from) {
@@ -682,7 +682,7 @@ xfs_file_buffered_aio_write( iolock =XFS_IOLOCK_EXCL ;xfs_ilock (ip, iolock); - ret =xfs_file_aio_write_checks (iocb, from, &iolock); + ret =xfs_file_write_checks (iocb, from, &iolock);if (ret) goto out;
@@ -769,12 +769,12 @@ xfs_file_write_iter(* CoW. In all other directio scenarios we do not * allow an operation to fall back to buffered mode. */ - ret =xfs_file_dio_aio_write (iocb, from); + ret =xfs_file_dio_write (iocb, from);if (ret != -ENOTBLK )return ret; } -return xfs_file_buffered_aio_write (iocb, from); +return xfs_file_buffered_write (iocb, from); } static void
Signature · 1 line
2.29.2
PATCH 4/11 xfs: remove the buffered I/O fallback assert
In reply to Christoph HellwigThe iomap code has been designed from the start not to do magic fallback, so remove the assert in preparation for further code cleanups.
--- fs/xfs/xfs_file.c | 6 ------ 1 file changed, 6 deletions(-)
fs/xfs/xfs_file.c +0 -6
@@ -610,12 +610,6 @@ xfs_file_dio_write( out:if (iolock)xfs_iunlock (ip, iolock); - -/* -* No fallback to buffered IO after short writes for XFS, direct I/O -* will either complete fully or return an error. -*/ -ASSERT (ret <0 || ret == count);return ret; }
Signature · 1 line
2.29.2
PATCH 5/11 xfs: simplify the read/write tracepoints
In reply to Christoph HellwigPass the iocb and iov_iter to the tracepoints and leave decoding of actual arguments to the code only run when tracing is enabled.
--- fs/xfs/xfs_file.c | 20 ++++++++------------ fs/xfs/xfs_trace.h | 18 +++++++++--------- 2 files changed, 17 insertions(+), 21 deletions(-)
fs/xfs/xfs_file.c +8 -12
@@ -220,12 +220,11 @@ xfs_file_dio_read( struct iov_iter *to) {struct xfs_inode *ip =XFS_I (file_inode (iocb->ki_filp)); -size_t count =iov_iter_count (to);ssize_t ret; -trace_xfs_file_direct_read (ip, count, iocb->ki_pos); +trace_xfs_file_direct_read (iocb, to); -if (!count) +if (!iov_iter_count (to))return 0 ;/* skip atime */ file_accessed (iocb->ki_filp);
@@ -246,12 +245,11 @@ xfs_file_dax_read( struct iov_iter *to) {struct xfs_inode *ip =XFS_I (iocb->ki_filp->f_mapping->host); -size_t count =iov_iter_count (to);ssize_t ret =0 ; -trace_xfs_file_dax_read (ip, count, iocb->ki_pos); +trace_xfs_file_dax_read (iocb, to); -if (!count) +if (!iov_iter_count (to))return 0 ;/* skip atime */ ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED );
@@ -272,7 +270,7 @@ xfs_file_buffered_read(struct xfs_inode *ip =XFS_I (file_inode (iocb->ki_filp));ssize_t ret; -trace_xfs_file_buffered_read (ip,iov_iter_count (to), iocb->ki_pos); +trace_xfs_file_buffered_read (iocb, to); ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED );if (ret)
@@ -599,7 +597,7 @@ xfs_file_dio_write( iolock =XFS_IOLOCK_SHARED ; } -trace_xfs_file_direct_write (ip, count, iocb->ki_pos); +trace_xfs_file_direct_write (iocb, from);/* * If unaligned, this is the only IO in-flight. Wait on it before we * release the iolock to prevent subsequent overlapping IO.
@@ -622,7 +620,6 @@ xfs_file_dax_write(struct xfs_inode *ip =XFS_I (inode);int iolock =XFS_IOLOCK_EXCL ;ssize_t ret, error =0 ; -size_t count;loff_t pos; ret =xfs_ilock_iocb (iocb, iolock);
@@ -633,9 +630,8 @@ xfs_file_dax_write( goto out; pos = iocb->ki_pos; - count =iov_iter_count (from); -trace_xfs_file_dax_write (ip, count, pos); +trace_xfs_file_dax_write (iocb, from); ret =dax_iomap_rw (iocb, from, &xfs_direct_write_iomap_ops);if (ret >0 && iocb->ki_pos >i_size_read (inode)) {i_size_write (inode, iocb->ki_pos);
@@ -683,7 +679,7 @@ xfs_file_buffered_write(/* We can write back this queue in page reclaim */ current->backing_dev_info =inode_to_bdi (inode); -trace_xfs_file_buffered_write (ip,iov_iter_count (from), iocb->ki_pos); +trace_xfs_file_buffered_write (iocb, from); ret =iomap_file_buffered_write (iocb, from, &xfs_buffered_write_iomap_ops);if (likely (ret >=0 ))
fs/xfs/xfs_trace.h +9 -9
@@ -1287,8 +1287,8 @@ TRACE_EVENT(xfs_log_assign_tail_lsn, ) DECLARE_EVENT_CLASS(xfs_file_class, - TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset), - TP_ARGS(ip, count, offset), + TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), + TP_ARGS(iocb, iter), TP_STRUCT__entry( __field(dev_t, dev) __field(xfs_ino_t, ino)
@@ -1297,11 +1297,11 @@ DECLARE_EVENT_CLASS(xfs_file_class,__field (size_t, count) ),TP_fast_assign ( - __entry->dev = VFS_I(ip)->i_sb->s_dev; - __entry->ino = ip->i_ino; - __entry->size = ip->i_d.di_size; - __entry->offset = offset; - __entry->count = count; + __entry->dev = file_inode(iocb->ki_filp)->i_sb->s_dev; + __entry->ino =XFS_I (file_inode (iocb->ki_filp))->i_ino; + __entry->size =XFS_I (file_inode (iocb->ki_filp))->i_d.di_size; + __entry->offset = iocb->ki_pos; + __entry->count =iov_iter_count (iter); ), TP_printk("dev %d:%d ino 0x%llx size 0x%llx offset 0x%llx count 0x%zx", MAJOR(__entry->dev), MINOR(__entry->dev),
@@ -1313,8 +1313,8 @@ DECLARE_EVENT_CLASS(xfs_file_class,#define DEFINE_RW_EVENT (name) \ DEFINE_EVENT(xfs_file_class, name, \ - TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset), \ - TP_ARGS(ip, count, offset)) + TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), \ + TP_ARGS(iocb, iter))DEFINE_RW_EVENT (xfs_file_buffered_read);DEFINE_RW_EVENT (xfs_file_direct_read);DEFINE_RW_EVENT (xfs_file_dax_read);
Signature · 1 line
2.29.2
PATCH 6/11 xfs: improve the reflink_bounce_dio_write tracepoint
In reply to Christoph HellwigUse a more suitable event class.
--- fs/xfs/xfs_file.c | 2 +- fs/xfs/xfs_trace.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)
fs/xfs/xfs_file.c +1 -1
@@ -560,7 +560,7 @@ xfs_file_dio_write(* files yet, as we can't unshare a partial block. */ if (xfs_is_cow_inode (ip)) { -trace_xfs_reflink_bounce_dio_write (ip, iocb->ki_pos, count); +trace_xfs_reflink_bounce_dio_write (iocb, from);return -ENOTBLK ; } iolock =XFS_IOLOCK_EXCL ;
fs/xfs/xfs_trace.h +2 -2
@@ -1321,6 +1321,8 @@ DEFINE_RW_EVENT(xfs_file_dax_read);DEFINE_RW_EVENT (xfs_file_buffered_write);DEFINE_RW_EVENT (xfs_file_direct_write);DEFINE_RW_EVENT (xfs_file_dax_write); +DEFINE_RW_EVENT (xfs_reflink_bounce_dio_write); + DECLARE_EVENT_CLASS(xfs_imap_class, TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count,
@@ -3294,8 +3296,6 @@ DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_found);DEFINE_INODE_IREC_EVENT (xfs_reflink_cow_enospc);DEFINE_INODE_IREC_EVENT (xfs_reflink_convert_cow); -DEFINE_SIMPLE_IO_EVENT (xfs_reflink_bounce_dio_write); -DEFINE_SIMPLE_IO_EVENT (xfs_reflink_cancel_cow_range);DEFINE_SIMPLE_IO_EVENT (xfs_reflink_end_cow);DEFINE_INODE_IREC_EVENT (xfs_reflink_cow_remap);
Signature · 1 line
2.29.2
PATCH 7/11 xfs: split unaligned DIO write code out
In reply to Christoph HellwigFrom: Dave Chinner <[email protected]>
The unaligned DIO write path is more convolted than the normal path, and we are about to make it more complex. Keep the block aligned fast path dio write code trim and simple by splitting out the unaligned DIO code from it.
--- fs/xfs/xfs_file.c | 168 +++++++++++++++++++++++++--------------------- 1 file changed, 92 insertions(+), 76 deletions(-)
fs/xfs/xfs_file.c +92 -76
@@ -500,117 +500,133 @@ static const struct iomap_dio_ops xfs_dio_write_ops = { };/* -* xfs_file_dio_write - handle direct IO writes +* Handle block aligned direct IO writes * * Lock the inode appropriately to prepare for and issue a direct IO write. -* By separating it from the buffered write path we remove all the tricky to -* follow locking changes and looping. * * If there are cached pages or we're extending the file, we need IOLOCK_EXCL * until we're sure the bytes at the new EOF have been zeroed and/or the cached * pages are flushed out. +*/ +static noinline ssize_t +xfs_file_dio_write_aligned ( +struct xfs_inode *ip, +struct kiocb *iocb, +struct iov_iter *from) +{ +int iolock =XFS_IOLOCK_SHARED ; +ssize_t ret; + + ret =xfs_ilock_iocb (iocb, iolock); +if (ret) +return ret; + ret =xfs_file_write_checks (iocb, from, &iolock); +if (ret) + goto out_unlock; + +/* +* We don't need to hold the IOLOCK exclusively across the IO, so demote +* the iolock back to shared if we had to take the exclusive lock in +* xfs_file_write_checks() for other reasons. +*/ +if (iolock ==XFS_IOLOCK_EXCL ) { +xfs_ilock_demote (ip,XFS_IOLOCK_EXCL ); + iolock =XFS_IOLOCK_SHARED ; + } +trace_xfs_file_direct_write (iocb, from); + ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, + &xfs_dio_write_ops,is_sync_kiocb (iocb)); +out_unlock: +if (iolock) +xfs_iunlock (ip, iolock); +return ret; +} + +/* +* Handle block unaligned direct IO writes +* +* In most cases direct IO writes will be done holding IOLOCK_SHARED, allowing +* them to be done in parallel with reads and other direct IO writes. However, +* if the I/O is not aligned to filesystem blocks, the direct I/O layer may +* need to do sub-block zeroing and that requires serialisation against other +* direct I/Os to the same block. In this case we need to serialise the +* submission of the unaligned I/Os so that we don't get racing block zeroing in +* the dio layer. * -* In most cases the direct IO writes will be done holding IOLOCK_SHARED -* allowing them to be done in parallel with reads and other direct IO writes. -* However, if the IO is not aligned to filesystem blocks, the direct IO layer -* needs to do sub-block zeroing and that requires serialisation against other -* direct IOs to the same block. In this case we need to serialise the -* submission of the unaligned IOs so that we don't get racing block zeroing in -* the dio layer. To avoid the problem with aio, we also need to wait for +* To provide the same serialisation for AIO, we also need to wait for * outstanding IOs to complete so that unwritten extent conversion is completed * before we try to map the overlapping block. This is currently implemented by * hitting it with a big hammer (i.e. inode_dio_wait()). * -* Returns with locks held indicated by @iolock and errors indicated by -* negative return values. +* This means that unaligned dio writes always block. There is no "nowait" fast +* path in this code - if IOCB_NOWAIT is set we simply return -EAGAIN up front +* and we don't have to worry about that anymore. */ -STATIC ssize_t -xfs_file_dio_write ( +static noinline ssize_t +xfs_file_dio_write_unaligned ( +struct xfs_inode *ip,struct kiocb *iocb,struct iov_iter *from) { -struct file *file = iocb->ki_filp; -struct address_space *mapping = file->f_mapping; -struct inode *inode = mapping->host; -struct xfs_inode *ip =XFS_I (inode); -struct xfs_mount *mp = ip->i_mount; -ssize_t ret =0 ; -int unaligned_io =0 ; -int iolock; -size_t count =iov_iter_count (from); -struct xfs_buftarg *target =xfs_inode_buftarg (ip); +int iolock =XFS_IOLOCK_EXCL ; +ssize_t ret; -/* DIO must be aligned to device logical sector size */ -if ((iocb->ki_pos | count) & target->bt_logical_sectormask) -return -EINVAL ; +/* unaligned dio always waits, bail */ +if (iocb->ki_flags &IOCB_NOWAIT ) +return -EAGAIN ; +xfs_ilock (ip, iolock);/* -* Don't take the exclusive iolock here unless the I/O is unaligned to -* the file system block size. We don't need to consider the EOF -* extension case here because xfs_file_write_checks() will relock -* the inode as necessary for EOF zeroing cases and fill out the new -* inode size as appropriate. +* We can't properly handle unaligned direct I/O to reflink files yet, +* as we can't unshare a partial block. */ -if ((iocb->ki_pos & mp->m_blockmask) || - ((iocb->ki_pos + count) & mp->m_blockmask)) { - unaligned_io =1 ; - -/* -* We can't properly handle unaligned direct I/O to reflink -* files yet, as we can't unshare a partial block. -*/ -if (xfs_is_cow_inode (ip)) { -trace_xfs_reflink_bounce_dio_write (iocb, from); -return -ENOTBLK ; - } - iolock =XFS_IOLOCK_EXCL ; - }else { - iolock =XFS_IOLOCK_SHARED ; - } - -if (iocb->ki_flags &IOCB_NOWAIT ) { -/* unaligned dio always waits, bail */ -if (unaligned_io) -return -EAGAIN ; -if (!xfs_ilock_nowait (ip, iolock)) -return -EAGAIN ; - }else { -xfs_ilock (ip, iolock); +if (xfs_is_cow_inode (ip)) { +trace_xfs_reflink_bounce_dio_write (iocb, from); + ret = -ENOTBLK ; + goto out_unlock; } ret =xfs_file_write_checks (iocb, from, &iolock);if (ret) - goto out; - count =iov_iter_count (from); + goto out_unlock;/* -* If we are doing unaligned IO, we can't allow any other overlapping IO -* in-flight at the same time or we risk data corruption. Wait for all -* other IO to drain before we submit. If the IO is aligned, demote the -* iolock if we had to take the exclusive lock in -* xfs_file_write_checks() for other reasons. +* If we are doing unaligned I/O, we can't allow any other overlapping +* I/O in-flight at the same time or we risk data corruption. Wait for +* all other I/O to drain before we submit. */ -if (unaligned_io) { -inode_dio_wait (inode); - }else if (iolock ==XFS_IOLOCK_EXCL ) { -xfs_ilock_demote (ip,XFS_IOLOCK_EXCL ); - iolock =XFS_IOLOCK_SHARED ; - } +inode_dio_wait (VFS_I (ip)); -trace_xfs_file_direct_write (iocb, from);/* -* If unaligned, this is the only IO in-flight. Wait on it before we -* release the iolock to prevent subsequent overlapping IO. +* This must be the only I/O in-flight. Wait on it before we release the +* iolock to prevent subsequent overlapping I/O. */ +trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops, -is_sync_kiocb (iocb) || unaligned_io); -out: + &xfs_dio_write_ops, true); +out_unlock:if (iolock)xfs_iunlock (ip, iolock);return ret; } +static ssize_t +xfs_file_dio_write ( +struct kiocb *iocb, +struct iov_iter *from) +{ +struct xfs_inode *ip =XFS_I (file_inode (iocb->ki_filp)); +struct xfs_buftarg *target =xfs_inode_buftarg (ip); +size_t count =iov_iter_count (from); + +/* DIO must be aligned to device logical sector size */ +if ((iocb->ki_pos | count) & target->bt_logical_sectormask) +return -EINVAL ; +if ((iocb->ki_pos | count) & ip->i_mount->m_blockmask) +return xfs_file_dio_write_unaligned (ip, iocb, from); +return xfs_file_dio_write_aligned (ip, iocb, from); +} + static noinline ssize_t xfs_file_dax_write( struct kiocb *iocb,
Signature · 1 line
2.29.2
PATCH 8/11 iomap: rename the flags variable in __iomap_dio_rw
In reply to Christoph HellwigRename flags to iomap_flags to make the usage a little more clear.
--- fs/iomap/direct-io.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
fs/iomap/direct-io.c +4 -4
@@ -427,7 +427,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,size_t count =iov_iter_count (iter);loff_t pos = iocb->ki_pos;loff_t end = iocb->ki_pos + count -1 , ret =0 ; -unsigned int flags =IOMAP_DIRECT ; +unsigned int iomap_flags =IOMAP_DIRECT ;struct blk_plug plug;struct iomap_dio *dio;
@@ -461,7 +461,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,if (iter_is_iovec (iter)) dio->flags |=IOMAP_DIO_DIRTY ; }else { - flags |=IOMAP_WRITE ; + iomap_flags |=IOMAP_WRITE ; dio->flags |=IOMAP_DIO_WRITE ;/* for data sync or sync, we need sync completion processing */
@@ -483,7 +483,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, ret = -EAGAIN ; goto out_free_dio; } - flags |=IOMAP_NOWAIT ; + iomap_flags |=IOMAP_NOWAIT ; } ret =filemap_write_and_wait_range (mapping, pos, end);
@@ -514,7 +514,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,blk_start_plug (&plug); do { - ret = iomap_apply(inode, pos, count, flags, ops, dio, + ret = iomap_apply(inode, pos, count, iomap_flags, ops, dio, iomap_dio_actor); if (ret <= 0) { /* magic error code to fall back to buffered I/O */
Signature · 1 line
2.29.2
PATCH 9/11 iomap: pass a flags argument to iomap_dio_rw
In reply to Christoph HellwigPass a set of flags to iomap_dio_rw instead of the boolean wait_for_completion argument. The IOMAP_DIO_FORCE_WAIT flag replaces the wait_for_completion, but only needs to be passed when the iocb isn't synchronous to start with to simplify the callers.
--- fs/btrfs/file.c | 7 +++---- fs/ext4/file.c | 5 ++--- fs/gfs2/file.c | 7 ++----- fs/iomap/direct-io.c | 11 +++++------ fs/xfs/xfs_file.c | 7 +++---- fs/zonefs/super.c | 4 ++-- include/linux/iomap.h | 10 ++++++++-- 7 files changed, 25 insertions(+), 26 deletions(-)
fs/btrfs/file.c +3 -4
@@ -1949,8 +1949,8 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from) goto buffered; } - dio =__iomap_dio_rw (iocb, from, &btrfs_dio_iomap_ops, - &btrfs_dio_ops,is_sync_kiocb (iocb)); + dio =__iomap_dio_rw (iocb, from, &btrfs_dio_iomap_ops, &btrfs_dio_ops, +0 );btrfs_inode_unlock (inode, ilock_flags);
@@ -3622,8 +3622,7 @@ static ssize_t btrfs_direct_read(struct kiocb *iocb, struct iov_iter *to)return 0 ;btrfs_inode_lock (inode,BTRFS_ILOCK_SHARED ); - ret =iomap_dio_rw (iocb, to, &btrfs_dio_iomap_ops, &btrfs_dio_ops, -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, to, &btrfs_dio_iomap_ops, &btrfs_dio_ops,0 );btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED );return ret; }
fs/ext4/file.c +2 -3
@@ -74,8 +74,7 @@ static ssize_t ext4_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)return generic_file_read_iter (iocb, to); } - ret =iomap_dio_rw (iocb, to, &ext4_iomap_ops,NULL , -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, to, &ext4_iomap_ops,NULL ,0 );inode_unlock_shared (inode);file_accessed (iocb->ki_filp);
@@ -550,7 +549,7 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)if (ilock_shared) iomap_ops = &ext4_iomap_overwrite_ops; ret =iomap_dio_rw (iocb, from, iomap_ops, &ext4_dio_write_ops, -is_sync_kiocb (iocb) || unaligned_io || extend); + (unaligned_io || extend) ?IOMAP_DIO_FORCE_WAIT :0 );if (ret == -ENOTBLK ) ret =0 ;
fs/gfs2/file.c +2 -5
@@ -797,9 +797,7 @@ static ssize_t gfs2_file_direct_read(struct kiocb *iocb, struct iov_iter *to,if (ret) goto out_uninit; - ret =iomap_dio_rw (iocb, to, &gfs2_iomap_ops,NULL , -is_sync_kiocb (iocb)); - + ret =iomap_dio_rw (iocb, to, &gfs2_iomap_ops,NULL ,0 );gfs2_glock_dq (gh); out_uninit:gfs2_holder_uninit (gh);
@@ -833,8 +831,7 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from,if (offset + len >i_size_read (&ip->i_inode)) goto out; - ret =iomap_dio_rw (iocb, from, &gfs2_iomap_ops,NULL , -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, from, &gfs2_iomap_ops,NULL ,0 );if (ret == -ENOTBLK ) ret =0 ; out:
fs/iomap/direct-io.c +5 -6
@@ -420,13 +420,15 @@ iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,struct iomap_dio *__iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion) +unsigned int dio_flags) {struct address_space *mapping = iocb->ki_filp->f_mapping;struct inode *inode =file_inode (iocb->ki_filp);size_t count =iov_iter_count (iter);loff_t pos = iocb->ki_pos;loff_t end = iocb->ki_pos + count -1 , ret =0 ; +bool wait_for_completion = +is_sync_kiocb (iocb) || (dio_flags &IOMAP_DIO_FORCE_WAIT );unsigned int iomap_flags =IOMAP_DIRECT ;struct blk_plug plug;struct iomap_dio *dio;
@@ -434,9 +436,6 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,if (!count)return NULL ; -if (WARN_ON (is_sync_kiocb (iocb) && !wait_for_completion)) -return ERR_PTR (-EIO ); - dio =kmalloc (sizeof (*dio),GFP_KERNEL );if (!dio)return ERR_PTR (-ENOMEM );
@@ -598,11 +597,11 @@ EXPORT_SYMBOL_GPL(__iomap_dio_rw);ssize_t iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion) +unsigned int dio_flags) {struct iomap_dio *dio; - dio =__iomap_dio_rw (iocb, iter, ops, dops, wait_for_completion); + dio =__iomap_dio_rw (iocb, iter, ops, dops, dio_flags);if (IS_ERR_OR_NULL (dio))return PTR_ERR_OR_ZERO (dio);return iomap_dio_complete (dio);
fs/xfs/xfs_file.c +3 -4
@@ -232,8 +232,7 @@ xfs_file_dio_read( ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED );if (ret)return ret; - ret =iomap_dio_rw (iocb, to, &xfs_read_iomap_ops,NULL , -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, to, &xfs_read_iomap_ops,NULL ,0 );xfs_iunlock (ip,XFS_IOLOCK_SHARED );return ret;
@@ -535,7 +534,7 @@ xfs_file_dio_write_aligned( }trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops,is_sync_kiocb (iocb)); + &xfs_dio_write_ops,0 ); out_unlock:if (iolock)xfs_iunlock (ip, iolock);
@@ -603,7 +602,7 @@ xfs_file_dio_write_unaligned(*/ trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops, true); + &xfs_dio_write_ops,IOMAP_DIO_FORCE_WAIT ); out_unlock:if (iolock)xfs_iunlock (ip, iolock);
fs/zonefs/super.c +2 -2
@@ -780,7 +780,7 @@ static ssize_t zonefs_file_dio_write(struct kiocb *iocb, struct iov_iter *from) ret =zonefs_file_dio_append (iocb, from); else ret =iomap_dio_rw (iocb, from, &zonefs_iomap_ops, - &zonefs_write_dio_ops, sync); + &zonefs_write_dio_ops,0 );if (zi->i_ztype ==ZONEFS_ZTYPE_SEQ && (ret >0 || ret == -EIOCBQUEUED )) {if (ret >0 )
@@ -917,7 +917,7 @@ static ssize_t zonefs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) }file_accessed (iocb->ki_filp); ret =iomap_dio_rw (iocb, to, &zonefs_iomap_ops, - &zonefs_read_dio_ops,is_sync_kiocb (iocb)); + &zonefs_read_dio_ops,0 ); }else { ret =generic_file_read_iter (iocb, to);if (ret == -EIO )
include/linux/iomap.h +8 -2
@@ -256,12 +256,18 @@ struct iomap_dio_ops { struct bio *bio, loff_t file_offset); }; +/* +* Wait for the I/O to complete in iomap_dio_rw even if the kiocb is not +* synchronous. +*/ +#define IOMAP_DIO_FORCE_WAIT (1 << 0) +ssize_t iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion); +unsigned int dio_flags);struct iomap_dio *__iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion); +unsigned int dio_flags);ssize_t iomap_dio_complete (struct iomap_dio *dio);int iomap_dio_iopoll (struct kiocb *kiocb,bool spin);
Signature · 1 line
2.29.2
Re: [PATCH 09/11] iomap: pass a flags argument to iomap_dio_rw
Quoted 8 lines · Christoph Hellwig
Pass a set of flags to
iomap_dio_rwinstead of the booleanwait_for_completionargument. TheIOMAP_DIO_FORCE_WAITflag replaces thewait_for_completion, but only needs to be passed when the iocb isn't synchronous to start with to simplify the callers.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Brian Foster <[email protected]>
Quoted 9 lines
--- fs/btrfs/file.c | 7 +++---- fs/ext4/file.c | 5 ++--- fs/gfs2/file.c | 7 ++----- fs/iomap/direct-io.c | 11 +++++------ fs/xfs/xfs_file.c | 7 +++---- fs/zonefs/super.c | 4 ++-- include/linux/iomap.h | 10 ++++++++-- 7 files changed, 25 insertions(+), 26 deletions(-)
Looks good.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 09/11] iomap: pass a flags argument to iomap_dio_rw
In reply to Christoph HellwigQuoted 8 lines · Christoph Hellwig
Pass a set of flags to
iomap_dio_rwinstead of the booleanwait_for_completionargument. TheIOMAP_DIO_FORCE_WAITflag replaces thewait_for_completion, but only needs to be passed when the iocb isn't synchronous to start with to simplify the callers.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Brian Foster <[email protected]>
--D
Quoted 210 lines
--- fs/btrfs/file.c | 7 +++---- fs/ext4/file.c | 5 ++--- fs/gfs2/file.c | 7 ++----- fs/iomap/direct-io.c | 11 +++++------ fs/xfs/xfs_file.c | 7 +++---- fs/zonefs/super.c | 4 ++-- include/linux/iomap.h | 10 ++++++++-- 7 files changed, 25 insertions(+), 26 deletions(-)fs/btrfs/file.c +3
-4@@ -1949,8 +1949,8 @@ static ssize_t btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from) goto buffered; } - dio =__iomap_dio_rw (iocb, from, &btrfs_dio_iomap_ops, - &btrfs_dio_ops,is_sync_kiocb (iocb)); + dio =__iomap_dio_rw (iocb, from, &btrfs_dio_iomap_ops, &btrfs_dio_ops, +0 );btrfs_inode_unlock (inode, ilock_flags);@@ -3622,8 +3622,7 @@ static ssize_t btrfs_direct_read(struct kiocb *iocb, struct iov_iter *to)return 0 ;btrfs_inode_lock (inode,BTRFS_ILOCK_SHARED ); - ret =iomap_dio_rw (iocb, to, &btrfs_dio_iomap_ops, &btrfs_dio_ops, -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, to, &btrfs_dio_iomap_ops, &btrfs_dio_ops,0 );btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED );return ret; }fs/ext4/file.c +2
-3@@ -74,8 +74,7 @@ static ssize_t ext4_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)return generic_file_read_iter (iocb, to); } - ret =iomap_dio_rw (iocb, to, &ext4_iomap_ops,NULL , -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, to, &ext4_iomap_ops,NULL ,0 );inode_unlock_shared (inode);file_accessed (iocb->ki_filp);@@ -550,7 +549,7 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)if (ilock_shared) iomap_ops = &ext4_iomap_overwrite_ops; ret =iomap_dio_rw (iocb, from, iomap_ops, &ext4_dio_write_ops, -is_sync_kiocb (iocb) || unaligned_io || extend); + (unaligned_io || extend) ?IOMAP_DIO_FORCE_WAIT :0 );if (ret == -ENOTBLK ) ret =0 ;fs/gfs2/file.c +2
-5@@ -797,9 +797,7 @@ static ssize_t gfs2_file_direct_read(struct kiocb *iocb, struct iov_iter *to,if (ret) goto out_uninit; - ret =iomap_dio_rw (iocb, to, &gfs2_iomap_ops,NULL , -is_sync_kiocb (iocb)); - + ret =iomap_dio_rw (iocb, to, &gfs2_iomap_ops,NULL ,0 );gfs2_glock_dq (gh); out_uninit:gfs2_holder_uninit (gh);@@ -833,8 +831,7 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from,if (offset + len >i_size_read (&ip->i_inode)) goto out; - ret =iomap_dio_rw (iocb, from, &gfs2_iomap_ops,NULL , -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, from, &gfs2_iomap_ops,NULL ,0 );if (ret == -ENOTBLK ) ret =0 ; out:fs/iomap/direct-io.c +5
-6@@ -420,13 +420,15 @@ iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,struct iomap_dio *__iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion) +unsigned int dio_flags) {struct address_space *mapping = iocb->ki_filp->f_mapping;struct inode *inode =file_inode (iocb->ki_filp);size_t count =iov_iter_count (iter);loff_t pos = iocb->ki_pos;loff_t end = iocb->ki_pos + count -1 , ret =0 ; +bool wait_for_completion = +is_sync_kiocb (iocb) || (dio_flags &IOMAP_DIO_FORCE_WAIT );unsigned int iomap_flags =IOMAP_DIRECT ;struct blk_plug plug;struct iomap_dio *dio;@@ -434,9 +436,6 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,if (!count)return NULL ; -if (WARN_ON (is_sync_kiocb (iocb) && !wait_for_completion)) -return ERR_PTR (-EIO ); - dio =kmalloc (sizeof (*dio),GFP_KERNEL );if (!dio)return ERR_PTR (-ENOMEM );@@ -598,11 +597,11 @@ EXPORT_SYMBOL_GPL(__iomap_dio_rw);ssize_t iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion) +unsigned int dio_flags) {struct iomap_dio *dio; - dio =__iomap_dio_rw (iocb, iter, ops, dops, wait_for_completion); + dio =__iomap_dio_rw (iocb, iter, ops, dops, dio_flags);if (IS_ERR_OR_NULL (dio))return PTR_ERR_OR_ZERO (dio);return iomap_dio_complete (dio);fs/xfs/xfs_file.c +3
-4@@ -232,8 +232,7 @@ xfs_file_dio_read( ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED );if (ret)return ret; - ret =iomap_dio_rw (iocb, to, &xfs_read_iomap_ops,NULL , -is_sync_kiocb (iocb)); + ret =iomap_dio_rw (iocb, to, &xfs_read_iomap_ops,NULL ,0 );xfs_iunlock (ip,XFS_IOLOCK_SHARED );return ret;@@ -535,7 +534,7 @@ xfs_file_dio_write_aligned( }trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops,is_sync_kiocb (iocb)); + &xfs_dio_write_ops,0 ); out_unlock:if (iolock)xfs_iunlock (ip, iolock);@@ -603,7 +602,7 @@ xfs_file_dio_write_unaligned(*/ trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops, true); + &xfs_dio_write_ops,IOMAP_DIO_FORCE_WAIT ); out_unlock:if (iolock)xfs_iunlock (ip, iolock);fs/zonefs/super.c +2
-2@@ -780,7 +780,7 @@ static ssize_t zonefs_file_dio_write(struct kiocb *iocb, struct iov_iter *from) ret =zonefs_file_dio_append (iocb, from); else ret =iomap_dio_rw (iocb, from, &zonefs_iomap_ops, - &zonefs_write_dio_ops, sync); + &zonefs_write_dio_ops,0 );if (zi->i_ztype ==ZONEFS_ZTYPE_SEQ && (ret >0 || ret == -EIOCBQUEUED )) {if (ret >0 )@@ -917,7 +917,7 @@ static ssize_t zonefs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) }file_accessed (iocb->ki_filp); ret =iomap_dio_rw (iocb, to, &zonefs_iomap_ops, - &zonefs_read_dio_ops,is_sync_kiocb (iocb)); + &zonefs_read_dio_ops,0 ); }else { ret =generic_file_read_iter (iocb, to);if (ret == -EIO )include/linux/iomap.h +8
-2@@ -256,12 +256,18 @@ struct iomap_dio_ops { struct bio *bio, loff_t file_offset); }; +/* +* Wait for the I/O to complete in iomap_dio_rw even if the kiocb is not +* synchronous. +*/ +#define IOMAP_DIO_FORCE_WAIT (1 << 0) +ssize_t iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion); +unsigned int dio_flags);struct iomap_dio *__iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops, -bool wait_for_completion); +unsigned int dio_flags);ssize_t iomap_dio_complete (struct iomap_dio *dio);int iomap_dio_iopoll (struct kiocb *kiocb,bool spin);Signature · 1 line
2.29.2
PATCH 10/11 iomap: add a IOMAP_DIO_OVERWRITE_ONLY flag
In reply to Christoph HellwigAdd a flag to signal an only pure overwrites are allowed.
--- fs/iomap/direct-io.c | 7 +++++++ include/linux/iomap.h | 8 ++++++++ 2 files changed, 15 insertions(+)
fs/iomap/direct-io.c +7 -0
@@ -485,6 +485,13 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, iomap_flags |=IOMAP_NOWAIT ; } +if (dio_flags &IOMAP_DIO_OVERWRITE_ONLY ) { + ret = -EAGAIN ; +if (pos >= dio->i_size || pos + count > dio->i_size) + goto out_free_dio; + iomap_flags |=IOMAP_OVERWRITE_ONLY ; + } + ret =filemap_write_and_wait_range (mapping, pos, end);if (ret) goto out_free_dio;
include/linux/iomap.h +8 -0
@@ -122,6 +122,7 @@ struct iomap_page_ops {#define IOMAP_FAULT (1 << 3)/* mapping for page fault */ #define IOMAP_DIRECT (1 << 4)/* direct I/O */ #define IOMAP_NOWAIT (1 << 5)/* do not block */ +#define IOMAP_OVERWRITE_ONLY (1 << 6)/* purely overwrites allowed */ struct iomap_ops {/*
@@ -262,6 +263,13 @@ struct iomap_dio_ops {*/ #define IOMAP_DIO_FORCE_WAIT (1 << 0) +/* +* Do not allocate blocks or zero partial blocks, but instead fall back to +* the caller by returning -EAGAIN. Used to optimize direct I/O writes that +* are not aligned to the file system block size. +*/ +#define IOMAP_DIO_OVERWRITE_ONLY (1 << 1) +ssize_t iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops,unsigned int dio_flags);
Signature · 1 line
2.29.2
Re: [PATCH 10/11] iomap: add a IOMAP_DIO_OVERWRITE_ONLY flag
Quoted 7 lines · Christoph Hellwig
Add a flag to signal an only pure overwrites are allowed.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/iomap/direct-io.c | 7 +++++++ include/linux/iomap.h | 8 ++++++++ 2 files changed, 15 insertions(+)
IOMAP_DIO_OVERWRITE_ONLY is a much better name compared to all the other alternatives that were suggested. :)
Quoted 23 lines
fs/iomap/direct-io.c +7
-0@@ -485,6 +485,13 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, iomap_flags |=IOMAP_NOWAIT ; } +if (dio_flags &IOMAP_DIO_OVERWRITE_ONLY ) { + ret = -EAGAIN ; +if (pos >= dio->i_size || pos + count > dio->i_size) + goto out_free_dio; + iomap_flags |=IOMAP_OVERWRITE_ONLY ; + } + ret =filemap_write_and_wait_range (mapping, pos, end);if (ret) goto out_free_dio;include/linux/iomap.h +0
-0
include/linux/iomap.h struct iomap_page_ops { · line 125
Quoted 4 lines
include/linux/iomap.h +1
-0@@ -122,6 +122,7 @@ struct iomap_page_ops {#define IOMAP_FAULT (1 << 3)/* mapping for page fault */ #define IOMAP_DIRECT (1 << 4)/* direct I/O */ #define IOMAP_NOWAIT (1 << 5)/* do not block */ +#define IOMAP_OVERWRITE_ONLY (1 << 6)/* purely overwrites allowed */
Nit: s/purely/pure/
But otherwise good.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 10/11] iomap: add a IOMAP_DIO_OVERWRITE_ONLY flag
In reply to Christoph HellwigQuoted 4 lines · Christoph Hellwig
Add a flag to signal an only pure overwrites are allowed.
Signed-off-by Christoph Hellwig <[email protected]>---
Agreed that the explicit flag name is much more clear:
Quoted 51 lines
fs/iomap/direct-io.c | 7 +++++++ include/linux/iomap.h | 8 ++++++++ 2 files changed, 15 insertions(+)fs/iomap/direct-io.c +7
-0@@ -485,6 +485,13 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, iomap_flags |=IOMAP_NOWAIT ; } +if (dio_flags &IOMAP_DIO_OVERWRITE_ONLY ) { + ret = -EAGAIN ; +if (pos >= dio->i_size || pos + count > dio->i_size) + goto out_free_dio; + iomap_flags |=IOMAP_OVERWRITE_ONLY ; + } + ret =filemap_write_and_wait_range (mapping, pos, end);if (ret) goto out_free_dio;include/linux/iomap.h +8
-0@@ -122,6 +122,7 @@ struct iomap_page_ops {#define IOMAP_FAULT (1 << 3)/* mapping for page fault */ #define IOMAP_DIRECT (1 << 4)/* direct I/O */ #define IOMAP_NOWAIT (1 << 5)/* do not block */ +#define IOMAP_OVERWRITE_ONLY (1 << 6)/* purely overwrites allowed */ struct iomap_ops {/* @@ -262,6 +263,13 @@ struct iomap_dio_ops {*/ #define IOMAP_DIO_FORCE_WAIT (1 << 0) +/* +* Do not allocate blocks or zero partial blocks, but instead fall back to +* the caller by returning -EAGAIN. Used to optimize direct I/O writes that +* are not aligned to the file system block size. +*/ +#define IOMAP_DIO_OVERWRITE_ONLY (1 << 1) +ssize_t iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops,unsigned int dio_flags);Signature · 1 line
2.29.2
Re: [PATCH 10/11] iomap: add a IOMAP_DIO_OVERWRITE_ONLY flag
In reply to Christoph HellwigQuoted 31 lines · Christoph Hellwig
Add a flag to signal an only pure overwrites are allowed.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/iomap/direct-io.c | 7 +++++++ include/linux/iomap.h | 8 ++++++++ 2 files changed, 15 insertions(+)fs/iomap/direct-io.c +7
-0@@ -485,6 +485,13 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, iomap_flags |=IOMAP_NOWAIT ; } +if (dio_flags &IOMAP_DIO_OVERWRITE_ONLY ) { + ret = -EAGAIN ; +if (pos >= dio->i_size || pos + count > dio->i_size) + goto out_free_dio; + iomap_flags |=IOMAP_OVERWRITE_ONLY ; + } + ret =filemap_write_and_wait_range (mapping, pos, end);if (ret) goto out_free_dio;include/linux/iomap.h +0
-0
include/linux/iomap.h struct iomap_page_ops { · line 125
Quoted 4 lines
include/linux/iomap.h +1
-0@@ -122,6 +122,7 @@ struct iomap_page_ops {#define IOMAP_FAULT (1 << 3)/* mapping for page fault */ #define IOMAP_DIRECT (1 << 4)/* direct I/O */ #define IOMAP_NOWAIT (1 << 5)/* do not block */ +#define IOMAP_OVERWRITE_ONLY (1 << 6)/* purely overwrites allowed */
"only pure overwrites allowed" ?
With that fixed,
--D
Quoted 20 lines
include/linux/iomap.h +7
-0struct iomap_ops {/* @@ -262,6 +263,13 @@ struct iomap_dio_ops {*/ #define IOMAP_DIO_FORCE_WAIT (1 << 0) +/* +* Do not allocate blocks or zero partial blocks, but instead fall back to +* the caller by returning -EAGAIN. Used to optimize direct I/O writes that +* are not aligned to the file system block size. +*/ +#define IOMAP_DIO_OVERWRITE_ONLY (1 << 1) +ssize_t iomap_dio_rw (struct kiocb *iocb,struct iov_iter *iter,const struct iomap_ops *ops,const struct iomap_dio_ops *dops,unsigned int dio_flags);Signature · 1 line
2.29.2
PATCH 11/11 xfs: reduce exclusive locking on unaligned dio
In reply to Christoph HellwigFrom: Dave Chinner <[email protected]>
Attempt shared locking for unaligned DIO, but only if the the underlying extent is already allocated and in written state. On failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of 32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msec
Patched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msec
WRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msec
WRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block AIO+DIO writes with this patch.
--- fs/xfs/xfs_file.c | 87 ++++++++++++++++++++++++++++++++-------------- fs/xfs/xfs_iomap.c | 30 +++++++++++----- 2 files changed, 83 insertions(+), 34 deletions(-)
fs/xfs/xfs_file.c +61 -26
@@ -544,22 +544,35 @@ xfs_file_dio_write_aligned(/* * Handle block unaligned direct IO writes * -* In most cases direct IO writes will be done holding IOLOCK_SHARED, allowing -* them to be done in parallel with reads and other direct IO writes. However, -* if the I/O is not aligned to filesystem blocks, the direct I/O layer may -* need to do sub-block zeroing and that requires serialisation against other -* direct I/Os to the same block. In this case we need to serialise the -* submission of the unaligned I/Os so that we don't get racing block zeroing in -* the dio layer. +* In most cases direct IO writes will be done holding IOLOCK_SHARED +* allowing them to be done in parallel with reads and other direct IO writes. +* However, if the IO is not aligned to filesystem blocks, the direct IO layer +* may need to do sub-block zeroing and that requires serialisation against other +* direct IOs to the same block. In the case where sub-block zeroing is not +* required, we can do concurrent sub-block dios to the same block successfully. * -* To provide the same serialisation for AIO, we also need to wait for +* Hence we have two cases here - the shared, optimisitic fast path for written +* extents, and everything else that needs exclusive IO path access across the +* entire IO. +* +* For the first case, we do all the checks we need at the mapping layer in the +* DIO code as part of the existing NOWAIT infrastructure. Hence all we need to +* do to support concurrent subblock dio is first try a non-blocking submission. +* If that returns -EAGAIN, then we simply repeat the IO submission with full +* IO exclusivity guaranteed so that we avoid racing sub-block zeroing. +* +* The only wrinkle in this case is that the iomap DIO code always does +* partial tail sub-block zeroing for post-EOF writes. Hence for any IO that +* _ends_ past the current EOF we need to run with full exclusivity. Note that +* we also check for the start of IO being beyond EOF because then zeroing +* between the old EOF and the start of the IO is required and that also +* requires exclusivity. Hence we avoid lock cycles and blocking under +* IOCB_NOWAIT for this situation, too. +* +* To provide the exclusivity required when using AIO, we also need to wait for * outstanding IOs to complete so that unwritten extent conversion is completed * before we try to map the overlapping block. This is currently implemented by * hitting it with a big hammer (i.e. inode_dio_wait()). -* -* This means that unaligned dio writes always block. There is no "nowait" fast -* path in this code - if IOCB_NOWAIT is set we simply return -EAGAIN up front -* and we don't have to worry about that anymore. */ static noinline ssize_t xfs_file_dio_write_unaligned(
@@ -567,13 +580,27 @@ xfs_file_dio_write_unaligned(struct kiocb *iocb, struct iov_iter *from) { - int iolock = XFS_IOLOCK_EXCL; + size_t isize = i_size_read(VFS_I(ip)); +size_t count =iov_iter_count (from); +int iolock =XFS_IOLOCK_SHARED ; +unsigned int flags =IOMAP_DIO_OVERWRITE_ONLY ;ssize_t ret; -/* unaligned dio always waits, bail */ -if (iocb->ki_flags &IOCB_NOWAIT ) -return -EAGAIN ; -xfs_ilock (ip, iolock); +/* +* Extending writes need exclusivity because of the sub-block zeroing +* that the DIO code always does for partial tail blocks beyond EOF. +*/ +if (iocb->ki_pos > isize || iocb->ki_pos + count >= isize) { +retry_exclusive: +if (iocb->ki_flags &IOCB_NOWAIT ) +return -EAGAIN ; + iolock =XFS_IOLOCK_EXCL ; + flags =IOMAP_DIO_FORCE_WAIT ; + } + + ret =xfs_ilock_iocb (iocb, iolock); +if (ret) +return ret;/* * We can't properly handle unaligned direct I/O to reflink files yet,
@@ -590,19 +617,27 @@ xfs_file_dio_write_unaligned( goto out_unlock;/* -* If we are doing unaligned I/O, we can't allow any other overlapping -* I/O in-flight at the same time or we risk data corruption. Wait for -* all other I/O to drain before we submit. +* If we are doing exclusive unaligned IO, we can't allow any other +* overlapping IO in-flight at the same time or we risk data corruption. +* Wait for all other IO to drain before we submit. */ -inode_dio_wait (VFS_I (ip)); +if (flags &IOMAP_DIO_FORCE_WAIT ) +inode_dio_wait (VFS_I (ip)); -/* -* This must be the only I/O in-flight. Wait on it before we release the -* iolock to prevent subsequent overlapping I/O. -*/ trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops,IOMAP_DIO_FORCE_WAIT ); + &xfs_dio_write_ops, flags); +/* +* Retry unaligned IO with exclusive blocking semantics if the DIO +* layer rejected it for mapping or locking reasons. If we are doing +* nonblocking user IO, propagate the error. +*/ +if (ret == -EAGAIN && !(iocb->ki_flags &IOCB_NOWAIT )) { +ASSERT (flags &IOMAP_DIO_OVERWRITE_ONLY ); +xfs_iunlock (ip, iolock); + goto retry_exclusive; + } + out_unlock:if (iolock)xfs_iunlock (ip, iolock);
fs/xfs/xfs_iomap.c +22 -8
@@ -784,15 +784,29 @@ xfs_direct_write_iomap_begin( goto allocate_blocks;/* -* NOWAIT IO needs to span the entire requested IO with a single map so -* that we avoid partial IO failures due to the rest of the IO range not -* covered by this map triggering an EAGAIN condition when it is -* subsequently mapped and aborting the IO. +* NOWAIT and OVERWRITE needs to span the entire requested IO with a +* single map so that we avoid partial IO failures due to the rest of +* the IO range not covered by this map triggering an EAGAIN condition +* when it is subsequently mapped and aborting the IO. */ -if ((flags &IOMAP_NOWAIT ) && - !imap_spans_range (&imap, offset_fsb, end_fsb)) { +if (flags & (IOMAP_NOWAIT |IOMAP_OVERWRITE_ONLY )) { error = -EAGAIN ; - goto out_unlock; +if (!imap_spans_range (&imap, offset_fsb, end_fsb)) + goto out_unlock; + } + +/* +* For overwrite only I/O, we cannot convert unwritten extents without +* requiring sub-block zeroing. This can only be done under an +* exclusive IOLOCK, hence return -EAGAIN if this is not a written +* extent to tell the caller to try again. +*/ +if (flags &IOMAP_OVERWRITE_ONLY ) { + error = -EAGAIN ; +if (imap.br_state !=XFS_EXT_NORM && + ((offset & mp->m_blockmask) || + ((offset + length) & mp->m_blockmask))) + goto out_unlock; }xfs_iunlock (ip, lockmode);
@@ -801,7 +815,7 @@ xfs_direct_write_iomap_begin( allocate_blocks: error = -EAGAIN ; -if (flags &IOMAP_NOWAIT ) +if (flags & (IOMAP_NOWAIT |IOMAP_OVERWRITE_ONLY )) goto out_unlock;/*
Signature · 1 line
2.29.2
Re: [PATCH 11/11] xfs: reduce exclusive locking on unaligned dio
Quoted 24 lines · Christoph Hellwig
From: Dave Chinner <[email protected]>
Attempt shared locking for unaligned DIO, but only if the the underlying extent is already allocated and in written state. On failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of 32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msecPatched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msecWRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msec
Quoted 8 lines
WRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block AIO+DIO writes with this patch.
Signed-off-by Dave Chinner <[email protected]>[hch: rebased, split unaligned from nowait]Signed-off-by Christoph Hellwig <[email protected]>
Looks good, minor nit:
fs/xfs/xfs_iomap.c xfs_direct_write_iomap_begin( · line 809
Quoted 12 lines
fs/xfs/xfs_iomap.c +12
-0+/* +* For overwrite only I/O, we cannot convert unwritten extents without +* requiring sub-block zeroing. This can only be done under an +* exclusive IOLOCK, hence return -EAGAIN if this is not a written +* extent to tell the caller to try again. +*/ +if (flags &IOMAP_OVERWRITE_ONLY ) { + error = -EAGAIN ; +if (imap.br_state !=XFS_EXT_NORM && + ((offset & mp->m_blockmask) || + ((offset + length) & mp->m_blockmask))) + goto out_unlock;
Why not use the ((offset | length) & mp->blockmask) form of alignment checking here?
Other than that,
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 11/11] xfs: reduce exclusive locking on unaligned dio
Quoted 2 lines · Dave Chinner
Why not use the ((offset | length) &
mp->blockmask) form of alignment checking here?
Sure. I'ĺl switch to that.
Quoted 1 line
Reviewed-by Dave Chinner <[email protected]>
Given that the original patch and thus credit is yours this doesn't make sense to add, though.
Re: [PATCH 11/11] xfs: reduce exclusive locking on unaligned dio
In reply to Christoph HellwigQuoted 60 lines · Christoph Hellwig
From: Dave Chinner <[email protected]>
Attempt shared locking for unaligned DIO, but only if the the underlying extent is already allocated and in written state. On failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of 32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msecPatched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msecWRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msecWRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block AIO+DIO writes with this patch.
Signed-off-by Dave Chinner <[email protected]>[hch: rebased, split unaligned from nowait]Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_file.c | 87 ++++++++++++++++++++++++++++++++-------------- fs/xfs/xfs_iomap.c | 30 +++++++++++----- 2 files changed, 83 insertions(+), 34 deletions(-)fs/xfs/xfs_file.c +6
-8@@ -544,22 +544,35 @@ xfs_file_dio_write_aligned(/* * Handle block unaligned direct IO writes * -* In most cases direct IO writes will be done holding IOLOCK_SHARED, allowing -* them to be done in parallel with reads and other direct IO writes. However, -* if the I/O is not aligned to filesystem blocks, the direct I/O layer may -* need to do sub-block zeroing and that requires serialisation against other -* direct I/Os to the same block. In this case we need to serialise the -* submission of the unaligned I/Os so that we don't get racing block zeroing in -* the dio layer. +* In most cases direct IO writes will be done holding IOLOCK_SHARED +* allowing them to be done in parallel with reads and other direct IO writes. +* However, if the IO is not aligned to filesystem blocks, the direct IO layer +* may need to do sub-block zeroing and that requires serialisation against other +* direct IOs to the same block. In the case where sub-block zeroing is not +* required, we can do concurrent sub-block dios to the same block successfully. * -* To provide the same serialisation for AIO, we also need to wait for
fs/xfs/xfs_file.c xfs_file_dio_write_aligned( · line 563
Quoted 10 lines
fs/xfs/xfs_file.c +10
-0+* Hence we have two cases here - the shared, optimisitic fast path for written +* extents, and everything else that needs exclusive IO path access across the +* entire IO. +* +* For the first case, we do all the checks we need at the mapping layer in the +* DIO code as part of the existing NOWAIT infrastructure. Hence all we need to +* do to support concurrent subblock dio is first try a non-blocking submission. +* If that returns -EAGAIN, then we simply repeat the IO submission with full +* IO exclusivity guaranteed so that we avoid racing sub-block zeroing. +*
The above paragraph still implicitly refers to the original NOWAIT based implementation. I'd suggest to tweak it to something like:
"The mapping layer of the dio code performs all the checks required to distinguish between the shared (overwrite) and exclusive cases. Hence to support concurrent unaligned dio, first submit the request in overwrite only mode. If that returns -EAGAIN, sub-block zeroing is required. Repeat the submission with full IO exclusivity to avoid races."
That aside, I still find the single mapping requirement a bit unfortunate, but otherwise the code LGTM:
Quoted 142 lines
fs/xfs/xfs_file.c +45
-18+* The only wrinkle in this case is that the iomap DIO code always does +* partial tail sub-block zeroing for post-EOF writes. Hence for any IO that +* _ends_ past the current EOF we need to run with full exclusivity. Note that +* we also check for the start of IO being beyond EOF because then zeroing +* between the old EOF and the start of the IO is required and that also +* requires exclusivity. Hence we avoid lock cycles and blocking under +* IOCB_NOWAIT for this situation, too. +* +* To provide the exclusivity required when using AIO, we also need to wait for * outstanding IOs to complete so that unwritten extent conversion is completed * before we try to map the overlapping block. This is currently implemented by * hitting it with a big hammer (i.e. inode_dio_wait()). -* -* This means that unaligned dio writes always block. There is no "nowait" fast -* path in this code - if IOCB_NOWAIT is set we simply return -EAGAIN up front -* and we don't have to worry about that anymore. */ static noinline ssize_t xfs_file_dio_write_unaligned(@@ -567,13 +580,27 @@ xfs_file_dio_write_unaligned(struct kiocb *iocb, struct iov_iter *from) { - int iolock = XFS_IOLOCK_EXCL; + size_t isize = i_size_read(VFS_I(ip)); +size_t count =iov_iter_count (from); +int iolock =XFS_IOLOCK_SHARED ; +unsigned int flags =IOMAP_DIO_OVERWRITE_ONLY ;ssize_t ret; -/* unaligned dio always waits, bail */ -if (iocb->ki_flags &IOCB_NOWAIT ) -return -EAGAIN ; -xfs_ilock (ip, iolock); +/* +* Extending writes need exclusivity because of the sub-block zeroing +* that the DIO code always does for partial tail blocks beyond EOF. +*/ +if (iocb->ki_pos > isize || iocb->ki_pos + count >= isize) { +retry_exclusive: +if (iocb->ki_flags &IOCB_NOWAIT ) +return -EAGAIN ; + iolock =XFS_IOLOCK_EXCL ; + flags =IOMAP_DIO_FORCE_WAIT ; + } + + ret =xfs_ilock_iocb (iocb, iolock); +if (ret) +return ret;/* * We can't properly handle unaligned direct I/O to reflink files yet, @@ -590,19 +617,27 @@ xfs_file_dio_write_unaligned( goto out_unlock;/* -* If we are doing unaligned I/O, we can't allow any other overlapping -* I/O in-flight at the same time or we risk data corruption. Wait for -* all other I/O to drain before we submit. +* If we are doing exclusive unaligned IO, we can't allow any other +* overlapping IO in-flight at the same time or we risk data corruption. +* Wait for all other IO to drain before we submit. */ -inode_dio_wait (VFS_I (ip)); +if (flags &IOMAP_DIO_FORCE_WAIT ) +inode_dio_wait (VFS_I (ip)); -/* -* This must be the only I/O in-flight. Wait on it before we release the -* iolock to prevent subsequent overlapping I/O. -*/ trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops,IOMAP_DIO_FORCE_WAIT ); + &xfs_dio_write_ops, flags); +/* +* Retry unaligned IO with exclusive blocking semantics if the DIO +* layer rejected it for mapping or locking reasons. If we are doing +* nonblocking user IO, propagate the error. +*/ +if (ret == -EAGAIN && !(iocb->ki_flags &IOCB_NOWAIT )) { +ASSERT (flags &IOMAP_DIO_OVERWRITE_ONLY ); +xfs_iunlock (ip, iolock); + goto retry_exclusive; + } + out_unlock:if (iolock)xfs_iunlock (ip, iolock);fs/xfs/xfs_iomap.c +22
-8@@ -784,15 +784,29 @@ xfs_direct_write_iomap_begin( goto allocate_blocks;/* -* NOWAIT IO needs to span the entire requested IO with a single map so -* that we avoid partial IO failures due to the rest of the IO range not -* covered by this map triggering an EAGAIN condition when it is -* subsequently mapped and aborting the IO. +* NOWAIT and OVERWRITE needs to span the entire requested IO with a +* single map so that we avoid partial IO failures due to the rest of +* the IO range not covered by this map triggering an EAGAIN condition +* when it is subsequently mapped and aborting the IO. */ -if ((flags &IOMAP_NOWAIT ) && - !imap_spans_range (&imap, offset_fsb, end_fsb)) { +if (flags & (IOMAP_NOWAIT |IOMAP_OVERWRITE_ONLY )) { error = -EAGAIN ; - goto out_unlock; +if (!imap_spans_range (&imap, offset_fsb, end_fsb)) + goto out_unlock; + } + +/* +* For overwrite only I/O, we cannot convert unwritten extents without +* requiring sub-block zeroing. This can only be done under an +* exclusive IOLOCK, hence return -EAGAIN if this is not a written +* extent to tell the caller to try again. +*/ +if (flags &IOMAP_OVERWRITE_ONLY ) { + error = -EAGAIN ; +if (imap.br_state !=XFS_EXT_NORM && + ((offset & mp->m_blockmask) || + ((offset + length) & mp->m_blockmask))) + goto out_unlock; }xfs_iunlock (ip, lockmode);@@ -801,7 +815,7 @@ xfs_direct_write_iomap_begin( allocate_blocks: error = -EAGAIN ; -if (flags &IOMAP_NOWAIT ) +if (flags & (IOMAP_NOWAIT |IOMAP_OVERWRITE_ONLY )) goto out_unlock;/* Signature · 1 line
2.29.2
Re: [PATCH 11/11] xfs: reduce exclusive locking on unaligned dio
Quoted 54 lines · Brian Foster
Quoted 53 lines · Christoph Hellwig
From: Dave Chinner <[email protected]>
Attempt shared locking for unaligned DIO, but only if the the underlying extent is already allocated and in written state. On failure, retry with the existing exclusive locking.
Test case is fio randrw of 512 byte IOs using AIO and an iodepth of 32 IOs.
Vanilla:
READ: bw=4560KiB/s (4670kB/s), 4560KiB/s-4560KiB/s (4670kB/s-4670kB/s), io=134MiB (140MB), run=30001-30001msec
WRITE: bw=4567KiB/s (4676kB/s), 4567KiB/s-4567KiB/s (4676kB/s-4676kB/s), io=134MiB (140MB), run=30001-30001msecPatched:
READ: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1127MiB (1182MB), run=30002-30002msecWRITE: bw=37.6MiB/s (39.4MB/s), 37.6MiB/s-37.6MiB/s (39.4MB/s-39.4MB/s), io=1128MiB (1183MB), run=30002-30002msec
That's an improvement from ~18k IOPS to a ~150k IOPS, which is about the IOPS limit of the VM block device setup I'm testing on.
4kB block IO comparison:
READ: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8868MiB (9299MB), run=30002-30002msecWRITE: bw=296MiB/s (310MB/s), 296MiB/s-296MiB/s (310MB/s-310MB/s), io=8878MiB (9309MB), run=30002-30002msec
Which is ~150k IOPS, same as what the test gets for sub-block AIO+DIO writes with this patch.
Signed-off-by Dave Chinner <[email protected]>[hch: rebased, split unaligned from nowait]Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_file.c | 87 ++++++++++++++++++++++++++++++++-------------- fs/xfs/xfs_iomap.c | 30 +++++++++++----- 2 files changed, 83 insertions(+), 34 deletions(-)fs/xfs/xfs_file.c +1
-7@@ -544,22 +544,35 @@ xfs_file_dio_write_aligned(/* * Handle block unaligned direct IO writes * -* In most cases direct IO writes will be done holding IOLOCK_SHARED, allowing -* them to be done in parallel with reads and other direct IO writes. However, -* if the I/O is not aligned to filesystem blocks, the direct I/O layer may -* need to do sub-block zeroing and that requires serialisation against other -* direct I/Os to the same block. In this case we need to serialise the -* submission of the unaligned I/Os so that we don't get racing block zeroing in -* the dio layer. +* In most cases direct IO writes will be done holding IOLOCK_SHARED
Quoted 8 lines
fs/xfs/xfs_file.c xfs_file_dio_write_aligned( · line 554
Quoted 8 lines
fs/xfs/xfs_file.c +6
-1+* allowing them to be done in parallel with reads and other direct IO writes. +* However, if the IO is not aligned to filesystem blocks, the direct IO layer +* may need to do sub-block zeroing and that requires serialisation against other +* direct IOs to the same block. In the case where sub-block zeroing is not +* required, we can do concurrent sub-block dios to the same block successfully. * -* To provide the same serialisation for AIO, we also need to wait for +* Hence we have two cases here - the shared, optimisitic fast path for written
"optimistic"
Quoted 10 lines
fs/xfs/xfs_file.c xfs_file_dio_write_aligned( · line 563
Quoted 9 lines
fs/xfs/xfs_file.c +9
-0+* extents, and everything else that needs exclusive IO path access across the +* entire IO. +* +* For the first case, we do all the checks we need at the mapping layer in the +* DIO code as part of the existing NOWAIT infrastructure. Hence all we need to +* do to support concurrent subblock dio is first try a non-blocking submission. +* If that returns -EAGAIN, then we simply repeat the IO submission with full +* IO exclusivity guaranteed so that we avoid racing sub-block zeroing. +*
Quoted 8 lines
The above paragraph still implicitly refers to the original NOWAIT based implementation. I'd suggest to tweak it to something like:
"The mapping layer of the dio code performs all the checks required to distinguish between the shared (overwrite) and exclusive cases. Hence to support concurrent unaligned dio, first submit the request in overwrite only mode. If that returns
-EAGAIN, sub-block zeroing is required. Repeat the submission with full IO exclusivity to avoid races."
FWIW I like this version better, because the fact that we reuse the existing 'nowait' switching to handle unaligned direct writes is a minor implementation detail here.
I think I'm about ready to RVB this, but there are enough small loose ends that I'll wait for the next version. :)
--D
Quoted 148 lines
That aside, I still find the single mapping requirement a bit unfortunate, but otherwise the code LGTM:
Reviewed-by Brian Foster <[email protected]>Quoted 142 lines
fs/xfs/xfs_file.c +45
-18+* The only wrinkle in this case is that the iomap DIO code always does +* partial tail sub-block zeroing for post-EOF writes. Hence for any IO that +* _ends_ past the current EOF we need to run with full exclusivity. Note that +* we also check for the start of IO being beyond EOF because then zeroing +* between the old EOF and the start of the IO is required and that also +* requires exclusivity. Hence we avoid lock cycles and blocking under +* IOCB_NOWAIT for this situation, too. +* +* To provide the exclusivity required when using AIO, we also need to wait for * outstanding IOs to complete so that unwritten extent conversion is completed * before we try to map the overlapping block. This is currently implemented by * hitting it with a big hammer (i.e. inode_dio_wait()). -* -* This means that unaligned dio writes always block. There is no "nowait" fast -* path in this code - if IOCB_NOWAIT is set we simply return -EAGAIN up front -* and we don't have to worry about that anymore. */ static noinline ssize_t xfs_file_dio_write_unaligned(@@ -567,13 +580,27 @@ xfs_file_dio_write_unaligned(struct kiocb *iocb, struct iov_iter *from) { - int iolock = XFS_IOLOCK_EXCL; + size_t isize = i_size_read(VFS_I(ip)); +size_t count =iov_iter_count (from); +int iolock =XFS_IOLOCK_SHARED ; +unsigned int flags =IOMAP_DIO_OVERWRITE_ONLY ;ssize_t ret; -/* unaligned dio always waits, bail */ -if (iocb->ki_flags &IOCB_NOWAIT ) -return -EAGAIN ; -xfs_ilock (ip, iolock); +/* +* Extending writes need exclusivity because of the sub-block zeroing +* that the DIO code always does for partial tail blocks beyond EOF. +*/ +if (iocb->ki_pos > isize || iocb->ki_pos + count >= isize) { +retry_exclusive: +if (iocb->ki_flags &IOCB_NOWAIT ) +return -EAGAIN ; + iolock =XFS_IOLOCK_EXCL ; + flags =IOMAP_DIO_FORCE_WAIT ; + } + + ret =xfs_ilock_iocb (iocb, iolock); +if (ret) +return ret;/* * We can't properly handle unaligned direct I/O to reflink files yet, @@ -590,19 +617,27 @@ xfs_file_dio_write_unaligned( goto out_unlock;/* -* If we are doing unaligned I/O, we can't allow any other overlapping -* I/O in-flight at the same time or we risk data corruption. Wait for -* all other I/O to drain before we submit. +* If we are doing exclusive unaligned IO, we can't allow any other +* overlapping IO in-flight at the same time or we risk data corruption. +* Wait for all other IO to drain before we submit. */ -inode_dio_wait (VFS_I (ip)); +if (flags &IOMAP_DIO_FORCE_WAIT ) +inode_dio_wait (VFS_I (ip)); -/* -* This must be the only I/O in-flight. Wait on it before we release the -* iolock to prevent subsequent overlapping I/O. -*/ trace_xfs_file_direct_write (iocb, from); ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops,IOMAP_DIO_FORCE_WAIT ); + &xfs_dio_write_ops, flags); +/* +* Retry unaligned IO with exclusive blocking semantics if the DIO +* layer rejected it for mapping or locking reasons. If we are doing +* nonblocking user IO, propagate the error. +*/ +if (ret == -EAGAIN && !(iocb->ki_flags &IOCB_NOWAIT )) { +ASSERT (flags &IOMAP_DIO_OVERWRITE_ONLY ); +xfs_iunlock (ip, iolock); + goto retry_exclusive; + } + out_unlock:if (iolock)xfs_iunlock (ip, iolock);fs/xfs/xfs_iomap.c +22
-8@@ -784,15 +784,29 @@ xfs_direct_write_iomap_begin( goto allocate_blocks;/* -* NOWAIT IO needs to span the entire requested IO with a single map so -* that we avoid partial IO failures due to the rest of the IO range not -* covered by this map triggering an EAGAIN condition when it is -* subsequently mapped and aborting the IO. +* NOWAIT and OVERWRITE needs to span the entire requested IO with a +* single map so that we avoid partial IO failures due to the rest of +* the IO range not covered by this map triggering an EAGAIN condition +* when it is subsequently mapped and aborting the IO. */ -if ((flags &IOMAP_NOWAIT ) && - !imap_spans_range (&imap, offset_fsb, end_fsb)) { +if (flags & (IOMAP_NOWAIT |IOMAP_OVERWRITE_ONLY )) { error = -EAGAIN ; - goto out_unlock; +if (!imap_spans_range (&imap, offset_fsb, end_fsb)) + goto out_unlock; + } + +/* +* For overwrite only I/O, we cannot convert unwritten extents without +* requiring sub-block zeroing. This can only be done under an +* exclusive IOLOCK, hence return -EAGAIN if this is not a written +* extent to tell the caller to try again. +*/ +if (flags &IOMAP_OVERWRITE_ONLY ) { + error = -EAGAIN ; +if (imap.br_state !=XFS_EXT_NORM && + ((offset & mp->m_blockmask) || + ((offset + length) & mp->m_blockmask))) + goto out_unlock; }xfs_iunlock (ip, lockmode);@@ -801,7 +815,7 @@ xfs_direct_write_iomap_begin( allocate_blocks: error = -EAGAIN ; -if (flags &IOMAP_NOWAIT ) +if (flags & (IOMAP_NOWAIT |IOMAP_OVERWRITE_ONLY )) goto out_unlock;/* Signature · 1 line
2.29.2