* Re: [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-21 18:31 ` [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures Christoph Hellwig
@ 2020-07-21 20:37 ` Darrick J. Wong
2020-07-22 6:18 ` Christoph Hellwig
2020-07-22 12:19 ` [Cluster-devel] " Bob Peterson
2020-07-21 23:01 ` Damien Le Moal
` (3 subsequent siblings)
4 siblings, 2 replies; 14+ messages in thread
From: Darrick J. Wong @ 2020-07-21 20:37 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Dave Chinner, Goldwyn Rodrigues, Damien Le Moal, Naohiro Aota,
Johannes Thumshirn, Matthew Wilcox, linux-btrfs, linux-fsdevel,
cluster-devel, linux-ext4, linux-xfs, Dave Chinner,
Goldwyn Rodrigues
On Tue, Jul 21, 2020 at 08:31:57PM +0200, Christoph Hellwig wrote:
> Failing to invalid the page cache means data in incoherent, which is
> a very bad state for the system. Always fall back to buffered I/O
> through the page cache if we can't invalidate mappings.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Acked-by: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
For the iomap and xfs parts,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
But I'd still like acks from Ted, Andreas, and Damien for ext4, gfs2,
and zonefs, respectively.
(Particularly if anyone was harboring ideas about trying to get this in
before 5.10, though I've not yet heard anyone say that explicitly...)
--D
> ---
> fs/ext4/file.c | 2 ++
> fs/gfs2/file.c | 3 ++-
> fs/iomap/direct-io.c | 16 +++++++++++-----
> fs/iomap/trace.h | 1 +
> fs/xfs/xfs_file.c | 4 ++--
> fs/zonefs/super.c | 7 +++++--
> 6 files changed, 23 insertions(+), 10 deletions(-)
>
> diff --git a/fs/ext4/file.c b/fs/ext4/file.c
> index 2a01e31a032c4c..129cc1dd6b7952 100644
> --- a/fs/ext4/file.c
> +++ b/fs/ext4/file.c
> @@ -544,6 +544,8 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
> 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);
> + if (ret == -ENOTBLK)
> + ret = 0;
>
> if (extend)
> ret = ext4_handle_inode_extension(inode, offset, ret, count);
> diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
> index bebde537ac8cf2..b085a3bea4f0fd 100644
> --- a/fs/gfs2/file.c
> +++ b/fs/gfs2/file.c
> @@ -835,7 +835,8 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
>
> ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
> is_sync_kiocb(iocb));
> -
> + if (ret == -ENOTBLK)
> + ret = 0;
> out:
> gfs2_glock_dq(&gh);
> out_uninit:
> diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
> index 190967e87b69e4..c1aafb2ab99072 100644
> --- a/fs/iomap/direct-io.c
> +++ b/fs/iomap/direct-io.c
> @@ -10,6 +10,7 @@
> #include <linux/backing-dev.h>
> #include <linux/uio.h>
> #include <linux/task_io_accounting_ops.h>
> +#include "trace.h"
>
> #include "../internal.h"
>
> @@ -401,6 +402,9 @@ iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,
> * can be mapped into multiple disjoint IOs and only a subset of the IOs issued
> * may be pure data writes. In that case, we still need to do a full data sync
> * completion.
> + *
> + * Returns -ENOTBLK In case of a page invalidation invalidation failure for
> + * writes. The callers needs to fall back to buffered I/O in this case.
> */
> ssize_t
> iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> @@ -478,13 +482,15 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> if (iov_iter_rw(iter) == WRITE) {
> /*
> * Try to invalidate cache pages for the range we are writing.
> - * If this invalidation fails, tough, the write will still work,
> - * but racing two incompatible write paths is a pretty crazy
> - * thing to do, so we don't support it 100%.
> + * If this invalidation fails, let the caller fall back to
> + * buffered I/O.
> */
> if (invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
> - end >> PAGE_SHIFT))
> - dio_warn_stale_pagecache(iocb->ki_filp);
> + end >> PAGE_SHIFT)) {
> + trace_iomap_dio_invalidate_fail(inode, pos, count);
> + ret = -ENOTBLK;
> + goto out_free_dio;
> + }
>
> if (!wait_for_completion && !inode->i_sb->s_dio_done_wq) {
> ret = sb_init_dio_done_wq(inode->i_sb);
> diff --git a/fs/iomap/trace.h b/fs/iomap/trace.h
> index 5693a39d52fb63..fdc7ae388476f5 100644
> --- a/fs/iomap/trace.h
> +++ b/fs/iomap/trace.h
> @@ -74,6 +74,7 @@ DEFINE_EVENT(iomap_range_class, name, \
> DEFINE_RANGE_EVENT(iomap_writepage);
> DEFINE_RANGE_EVENT(iomap_releasepage);
> DEFINE_RANGE_EVENT(iomap_invalidatepage);
> +DEFINE_RANGE_EVENT(iomap_dio_invalidate_fail);
>
> #define IOMAP_TYPE_STRINGS \
> { IOMAP_HOLE, "HOLE" }, \
> diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
> index a6ef90457abf97..1b4517fc55f1b9 100644
> --- a/fs/xfs/xfs_file.c
> +++ b/fs/xfs/xfs_file.c
> @@ -553,8 +553,8 @@ xfs_file_dio_aio_write(
> xfs_iunlock(ip, iolock);
>
> /*
> - * No fallback to buffered IO on errors for XFS, direct IO will either
> - * complete fully or fail.
> + * 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;
> diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
> index 07bc42d62673ce..d0a04528a7e18e 100644
> --- a/fs/zonefs/super.c
> +++ b/fs/zonefs/super.c
> @@ -786,8 +786,11 @@ static ssize_t zonefs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> if (iocb->ki_pos >= ZONEFS_I(inode)->i_max_size)
> return -EFBIG;
>
> - if (iocb->ki_flags & IOCB_DIRECT)
> - return zonefs_file_dio_write(iocb, from);
> + if (iocb->ki_flags & IOCB_DIRECT) {
> + ssize_t ret = zonefs_file_dio_write(iocb, from);
> + if (ret != -ENOTBLK)
> + return ret;
> + }
>
> return zonefs_file_buffered_write(iocb, from);
> }
> --
> 2.27.0
>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-21 20:37 ` Darrick J. Wong
@ 2020-07-22 6:18 ` Christoph Hellwig
2020-07-22 16:15 ` Darrick J. Wong
2020-07-22 12:19 ` [Cluster-devel] " Bob Peterson
1 sibling, 1 reply; 14+ messages in thread
From: Christoph Hellwig @ 2020-07-22 6:18 UTC (permalink / raw)
To: Darrick J. Wong
Cc: Christoph Hellwig, Dave Chinner, Goldwyn Rodrigues,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
linux-btrfs, linux-fsdevel, cluster-devel, linux-ext4, linux-xfs,
Dave Chinner, Goldwyn Rodrigues
On Tue, Jul 21, 2020 at 01:37:49PM -0700, Darrick J. Wong wrote:
> On Tue, Jul 21, 2020 at 08:31:57PM +0200, Christoph Hellwig wrote:
> > Failing to invalid the page cache means data in incoherent, which is
> > a very bad state for the system. Always fall back to buffered I/O
> > through the page cache if we can't invalidate mappings.
> >
> > Signed-off-by: Christoph Hellwig <hch@lst.de>
> > Acked-by: Dave Chinner <dchinner@redhat.com>
> > Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
>
> For the iomap and xfs parts,
> Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
>
> But I'd still like acks from Ted, Andreas, and Damien for ext4, gfs2,
> and zonefs, respectively.
>
> (Particularly if anyone was harboring ideas about trying to get this in
> before 5.10, though I've not yet heard anyone say that explicitly...)
Why would we want to wait another whole merge window?
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-22 6:18 ` Christoph Hellwig
@ 2020-07-22 16:15 ` Darrick J. Wong
0 siblings, 0 replies; 14+ messages in thread
From: Darrick J. Wong @ 2020-07-22 16:15 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Dave Chinner, Goldwyn Rodrigues, Damien Le Moal, Naohiro Aota,
Johannes Thumshirn, Matthew Wilcox, linux-btrfs, linux-fsdevel,
cluster-devel, linux-ext4, linux-xfs, Dave Chinner,
Goldwyn Rodrigues
On Wed, Jul 22, 2020 at 08:18:50AM +0200, Christoph Hellwig wrote:
> On Tue, Jul 21, 2020 at 01:37:49PM -0700, Darrick J. Wong wrote:
> > On Tue, Jul 21, 2020 at 08:31:57PM +0200, Christoph Hellwig wrote:
> > > Failing to invalid the page cache means data in incoherent, which is
> > > a very bad state for the system. Always fall back to buffered I/O
> > > through the page cache if we can't invalidate mappings.
> > >
> > > Signed-off-by: Christoph Hellwig <hch@lst.de>
> > > Acked-by: Dave Chinner <dchinner@redhat.com>
> > > Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
> >
> > For the iomap and xfs parts,
> > Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
> >
> > But I'd still like acks from Ted, Andreas, and Damien for ext4, gfs2,
> > and zonefs, respectively.
> >
> > (Particularly if anyone was harboring ideas about trying to get this in
> > before 5.10, though I've not yet heard anyone say that explicitly...)
>
> Why would we want to wait another whole merge window?
Well it /is/ past -rc6, which is a tad late...
OTOH we've been talking about this for 2 months now and most of the
actual behavior change is in xfs land so maybe it's fine. :)
--D
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Cluster-devel] [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-21 20:37 ` Darrick J. Wong
2020-07-22 6:18 ` Christoph Hellwig
@ 2020-07-22 12:19 ` Bob Peterson
1 sibling, 0 replies; 14+ messages in thread
From: Bob Peterson @ 2020-07-22 12:19 UTC (permalink / raw)
To: Darrick J. Wong
Cc: Christoph Hellwig, Naohiro Aota, linux-xfs, Damien Le Moal,
linux-ext4, Goldwyn Rodrigues, Dave Chinner, Matthew Wilcox,
cluster-devel, Goldwyn Rodrigues, linux-fsdevel,
Johannes Thumshirn, linux-btrfs
----- Original Message -----
> On Tue, Jul 21, 2020 at 08:31:57PM +0200, Christoph Hellwig wrote:
> > Failing to invalid the page cache means data in incoherent, which is
> > a very bad state for the system. Always fall back to buffered I/O
> > through the page cache if we can't invalidate mappings.
> >
> > Signed-off-by: Christoph Hellwig <hch@lst.de>
> > Acked-by: Dave Chinner <dchinner@redhat.com>
> > Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
>
> For the iomap and xfs parts,
> Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
>
> But I'd still like acks from Ted, Andreas, and Damien for ext4, gfs2,
> and zonefs, respectively.
>
> (Particularly if anyone was harboring ideas about trying to get this in
> before 5.10, though I've not yet heard anyone say that explicitly...)
>
> --D
>
> > ---
> > fs/ext4/file.c | 2 ++
> > fs/gfs2/file.c | 3 ++-
> > fs/iomap/direct-io.c | 16 +++++++++++-----
> > fs/iomap/trace.h | 1 +
> > fs/xfs/xfs_file.c | 4 ++--
> > fs/zonefs/super.c | 7 +++++--
> > 6 files changed, 23 insertions(+), 10 deletions(-)
Hi,
I think Andreas is on holiday this week, but the gfs2 portion looks good to me:
For the gfs2 portion:
Acked-by: Bob Peterson <rpeterso@redhat.com>
Regards,
Bob Peterson
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-21 18:31 ` [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures Christoph Hellwig
2020-07-21 20:37 ` Darrick J. Wong
@ 2020-07-21 23:01 ` Damien Le Moal
2020-07-22 23:13 ` Darrick J. Wong
` (2 subsequent siblings)
4 siblings, 0 replies; 14+ messages in thread
From: Damien Le Moal @ 2020-07-21 23:01 UTC (permalink / raw)
To: Christoph Hellwig, Dave Chinner, Goldwyn Rodrigues
Cc: Naohiro Aota, Johannes Thumshirn, Matthew Wilcox, linux-btrfs,
linux-fsdevel, cluster-devel, linux-ext4, linux-xfs,
Dave Chinner, Goldwyn Rodrigues
On 2020/07/22 3:32, Christoph Hellwig wrote:
> Failing to invalid the page cache means data in incoherent, which is
> a very bad state for the system. Always fall back to buffered I/O
> through the page cache if we can't invalidate mappings.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Acked-by: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
> ---
> fs/ext4/file.c | 2 ++
> fs/gfs2/file.c | 3 ++-
> fs/iomap/direct-io.c | 16 +++++++++++-----
> fs/iomap/trace.h | 1 +
> fs/xfs/xfs_file.c | 4 ++--
> fs/zonefs/super.c | 7 +++++--
> 6 files changed, 23 insertions(+), 10 deletions(-)
>
> diff --git a/fs/ext4/file.c b/fs/ext4/file.c
> index 2a01e31a032c4c..129cc1dd6b7952 100644
> --- a/fs/ext4/file.c
> +++ b/fs/ext4/file.c
> @@ -544,6 +544,8 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
> 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);
> + if (ret == -ENOTBLK)
> + ret = 0;
>
> if (extend)
> ret = ext4_handle_inode_extension(inode, offset, ret, count);
> diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
> index bebde537ac8cf2..b085a3bea4f0fd 100644
> --- a/fs/gfs2/file.c
> +++ b/fs/gfs2/file.c
> @@ -835,7 +835,8 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
>
> ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
> is_sync_kiocb(iocb));
> -
> + if (ret == -ENOTBLK)
> + ret = 0;
> out:
> gfs2_glock_dq(&gh);
> out_uninit:
> diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
> index 190967e87b69e4..c1aafb2ab99072 100644
> --- a/fs/iomap/direct-io.c
> +++ b/fs/iomap/direct-io.c
> @@ -10,6 +10,7 @@
> #include <linux/backing-dev.h>
> #include <linux/uio.h>
> #include <linux/task_io_accounting_ops.h>
> +#include "trace.h"
>
> #include "../internal.h"
>
> @@ -401,6 +402,9 @@ iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,
> * can be mapped into multiple disjoint IOs and only a subset of the IOs issued
> * may be pure data writes. In that case, we still need to do a full data sync
> * completion.
> + *
> + * Returns -ENOTBLK In case of a page invalidation invalidation failure for
> + * writes. The callers needs to fall back to buffered I/O in this case.
> */
> ssize_t
> iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> @@ -478,13 +482,15 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> if (iov_iter_rw(iter) == WRITE) {
> /*
> * Try to invalidate cache pages for the range we are writing.
> - * If this invalidation fails, tough, the write will still work,
> - * but racing two incompatible write paths is a pretty crazy
> - * thing to do, so we don't support it 100%.
> + * If this invalidation fails, let the caller fall back to
> + * buffered I/O.
> */
> if (invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
> - end >> PAGE_SHIFT))
> - dio_warn_stale_pagecache(iocb->ki_filp);
> + end >> PAGE_SHIFT)) {
> + trace_iomap_dio_invalidate_fail(inode, pos, count);
> + ret = -ENOTBLK;
> + goto out_free_dio;
> + }
>
> if (!wait_for_completion && !inode->i_sb->s_dio_done_wq) {
> ret = sb_init_dio_done_wq(inode->i_sb);
> diff --git a/fs/iomap/trace.h b/fs/iomap/trace.h
> index 5693a39d52fb63..fdc7ae388476f5 100644
> --- a/fs/iomap/trace.h
> +++ b/fs/iomap/trace.h
> @@ -74,6 +74,7 @@ DEFINE_EVENT(iomap_range_class, name, \
> DEFINE_RANGE_EVENT(iomap_writepage);
> DEFINE_RANGE_EVENT(iomap_releasepage);
> DEFINE_RANGE_EVENT(iomap_invalidatepage);
> +DEFINE_RANGE_EVENT(iomap_dio_invalidate_fail);
>
> #define IOMAP_TYPE_STRINGS \
> { IOMAP_HOLE, "HOLE" }, \
> diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
> index a6ef90457abf97..1b4517fc55f1b9 100644
> --- a/fs/xfs/xfs_file.c
> +++ b/fs/xfs/xfs_file.c
> @@ -553,8 +553,8 @@ xfs_file_dio_aio_write(
> xfs_iunlock(ip, iolock);
>
> /*
> - * No fallback to buffered IO on errors for XFS, direct IO will either
> - * complete fully or fail.
> + * 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;
> diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
> index 07bc42d62673ce..d0a04528a7e18e 100644
> --- a/fs/zonefs/super.c
> +++ b/fs/zonefs/super.c
> @@ -786,8 +786,11 @@ static ssize_t zonefs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> if (iocb->ki_pos >= ZONEFS_I(inode)->i_max_size)
> return -EFBIG;
>
> - if (iocb->ki_flags & IOCB_DIRECT)
> - return zonefs_file_dio_write(iocb, from);
> + if (iocb->ki_flags & IOCB_DIRECT) {
> + ssize_t ret = zonefs_file_dio_write(iocb, from);
> + if (ret != -ENOTBLK)
> + return ret;
> + }
>
> return zonefs_file_buffered_write(iocb, from);
> }
>
Looks fine. For zonefs:
Acked-by: Damien Le Moal <damien.lemoal@wdc.com>
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-21 18:31 ` [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures Christoph Hellwig
2020-07-21 20:37 ` Darrick J. Wong
2020-07-21 23:01 ` Damien Le Moal
@ 2020-07-22 23:13 ` Darrick J. Wong
2020-07-30 4:00 ` tytso
2020-07-31 7:01 ` Ritesh Harjani
2020-07-31 14:03 ` [Cluster-devel] " Andreas Gruenbacher
4 siblings, 1 reply; 14+ messages in thread
From: Darrick J. Wong @ 2020-07-22 23:13 UTC (permalink / raw)
To: Theodore Ts'o
Cc: Dave Chinner, Goldwyn Rodrigues, Damien Le Moal, Naohiro Aota,
Johannes Thumshirn, Matthew Wilcox, linux-btrfs, linux-fsdevel,
cluster-devel, linux-ext4, linux-xfs, Dave Chinner,
Goldwyn Rodrigues, Christoph Hellwig
Hey Ted,
Could you please review the fs/ext4/ part of this patch (it's the
follow-on to the directio discussion I had with you last week) so that I
can get this moving for 5.9? Thx,
--D
On Tue, Jul 21, 2020 at 08:31:57PM +0200, Christoph Hellwig wrote:
> Failing to invalid the page cache means data in incoherent, which is
> a very bad state for the system. Always fall back to buffered I/O
> through the page cache if we can't invalidate mappings.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Acked-by: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
> ---
> fs/ext4/file.c | 2 ++
> fs/gfs2/file.c | 3 ++-
> fs/iomap/direct-io.c | 16 +++++++++++-----
> fs/iomap/trace.h | 1 +
> fs/xfs/xfs_file.c | 4 ++--
> fs/zonefs/super.c | 7 +++++--
> 6 files changed, 23 insertions(+), 10 deletions(-)
>
> diff --git a/fs/ext4/file.c b/fs/ext4/file.c
> index 2a01e31a032c4c..129cc1dd6b7952 100644
> --- a/fs/ext4/file.c
> +++ b/fs/ext4/file.c
> @@ -544,6 +544,8 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
> 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);
> + if (ret == -ENOTBLK)
> + ret = 0;
>
> if (extend)
> ret = ext4_handle_inode_extension(inode, offset, ret, count);
> diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
> index bebde537ac8cf2..b085a3bea4f0fd 100644
> --- a/fs/gfs2/file.c
> +++ b/fs/gfs2/file.c
> @@ -835,7 +835,8 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
>
> ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
> is_sync_kiocb(iocb));
> -
> + if (ret == -ENOTBLK)
> + ret = 0;
> out:
> gfs2_glock_dq(&gh);
> out_uninit:
> diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
> index 190967e87b69e4..c1aafb2ab99072 100644
> --- a/fs/iomap/direct-io.c
> +++ b/fs/iomap/direct-io.c
> @@ -10,6 +10,7 @@
> #include <linux/backing-dev.h>
> #include <linux/uio.h>
> #include <linux/task_io_accounting_ops.h>
> +#include "trace.h"
>
> #include "../internal.h"
>
> @@ -401,6 +402,9 @@ iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,
> * can be mapped into multiple disjoint IOs and only a subset of the IOs issued
> * may be pure data writes. In that case, we still need to do a full data sync
> * completion.
> + *
> + * Returns -ENOTBLK In case of a page invalidation invalidation failure for
> + * writes. The callers needs to fall back to buffered I/O in this case.
> */
> ssize_t
> iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> @@ -478,13 +482,15 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> if (iov_iter_rw(iter) == WRITE) {
> /*
> * Try to invalidate cache pages for the range we are writing.
> - * If this invalidation fails, tough, the write will still work,
> - * but racing two incompatible write paths is a pretty crazy
> - * thing to do, so we don't support it 100%.
> + * If this invalidation fails, let the caller fall back to
> + * buffered I/O.
> */
> if (invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
> - end >> PAGE_SHIFT))
> - dio_warn_stale_pagecache(iocb->ki_filp);
> + end >> PAGE_SHIFT)) {
> + trace_iomap_dio_invalidate_fail(inode, pos, count);
> + ret = -ENOTBLK;
> + goto out_free_dio;
> + }
>
> if (!wait_for_completion && !inode->i_sb->s_dio_done_wq) {
> ret = sb_init_dio_done_wq(inode->i_sb);
> diff --git a/fs/iomap/trace.h b/fs/iomap/trace.h
> index 5693a39d52fb63..fdc7ae388476f5 100644
> --- a/fs/iomap/trace.h
> +++ b/fs/iomap/trace.h
> @@ -74,6 +74,7 @@ DEFINE_EVENT(iomap_range_class, name, \
> DEFINE_RANGE_EVENT(iomap_writepage);
> DEFINE_RANGE_EVENT(iomap_releasepage);
> DEFINE_RANGE_EVENT(iomap_invalidatepage);
> +DEFINE_RANGE_EVENT(iomap_dio_invalidate_fail);
>
> #define IOMAP_TYPE_STRINGS \
> { IOMAP_HOLE, "HOLE" }, \
> diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
> index a6ef90457abf97..1b4517fc55f1b9 100644
> --- a/fs/xfs/xfs_file.c
> +++ b/fs/xfs/xfs_file.c
> @@ -553,8 +553,8 @@ xfs_file_dio_aio_write(
> xfs_iunlock(ip, iolock);
>
> /*
> - * No fallback to buffered IO on errors for XFS, direct IO will either
> - * complete fully or fail.
> + * 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;
> diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
> index 07bc42d62673ce..d0a04528a7e18e 100644
> --- a/fs/zonefs/super.c
> +++ b/fs/zonefs/super.c
> @@ -786,8 +786,11 @@ static ssize_t zonefs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> if (iocb->ki_pos >= ZONEFS_I(inode)->i_max_size)
> return -EFBIG;
>
> - if (iocb->ki_flags & IOCB_DIRECT)
> - return zonefs_file_dio_write(iocb, from);
> + if (iocb->ki_flags & IOCB_DIRECT) {
> + ssize_t ret = zonefs_file_dio_write(iocb, from);
> + if (ret != -ENOTBLK)
> + return ret;
> + }
>
> return zonefs_file_buffered_write(iocb, from);
> }
> --
> 2.27.0
>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-22 23:13 ` Darrick J. Wong
@ 2020-07-30 4:00 ` tytso
0 siblings, 0 replies; 14+ messages in thread
From: tytso @ 2020-07-30 4:00 UTC (permalink / raw)
To: Darrick J. Wong
Cc: Dave Chinner, Goldwyn Rodrigues, Damien Le Moal, Naohiro Aota,
Johannes Thumshirn, Matthew Wilcox, linux-btrfs, linux-fsdevel,
cluster-devel, linux-ext4, linux-xfs, Dave Chinner,
Goldwyn Rodrigues, Christoph Hellwig
On Wed, Jul 22, 2020 at 04:13:52PM -0700, Darrick J. Wong wrote:
> Hey Ted,
>
> Could you please review the fs/ext4/ part of this patch (it's the
> follow-on to the directio discussion I had with you last week) so that I
> can get this moving for 5.9? Thx,
Reviewed-by: Theodore Ts'o <tytso@mit.edu> # for ext4
- Ted
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-21 18:31 ` [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures Christoph Hellwig
` (2 preceding siblings ...)
2020-07-22 23:13 ` Darrick J. Wong
@ 2020-07-31 7:01 ` Ritesh Harjani
2020-07-31 14:03 ` [Cluster-devel] " Andreas Gruenbacher
4 siblings, 0 replies; 14+ messages in thread
From: Ritesh Harjani @ 2020-07-31 7:01 UTC (permalink / raw)
To: Christoph Hellwig, Dave Chinner, Goldwyn Rodrigues
Cc: Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
linux-btrfs, linux-fsdevel, cluster-devel, linux-ext4, linux-xfs,
Dave Chinner, Goldwyn Rodrigues
On 7/22/20 12:01 AM, Christoph Hellwig wrote:
> Failing to invalid the page cache means data in incoherent, which is
> a very bad state for the system. Always fall back to buffered I/O
> through the page cache if we can't invalidate mappings.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Acked-by: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Reviewed-by: Ritesh Harjani <riteshh@linux.ibm.com>
mainly for ext4 part.
> ---
> fs/ext4/file.c | 2 ++
> fs/gfs2/file.c | 3 ++-
> fs/iomap/direct-io.c | 16 +++++++++++-----
> fs/iomap/trace.h | 1 +
> fs/xfs/xfs_file.c | 4 ++--
> fs/zonefs/super.c | 7 +++++--
> 6 files changed, 23 insertions(+), 10 deletions(-)
>
> diff --git a/fs/ext4/file.c b/fs/ext4/file.c
> index 2a01e31a032c4c..129cc1dd6b7952 100644
> --- a/fs/ext4/file.c
> +++ b/fs/ext4/file.c
> @@ -544,6 +544,8 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
> 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);
> + if (ret == -ENOTBLK)
> + ret = 0;
>
> if (extend)
> ret = ext4_handle_inode_extension(inode, offset, ret, count);
> diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
> index bebde537ac8cf2..b085a3bea4f0fd 100644
> --- a/fs/gfs2/file.c
> +++ b/fs/gfs2/file.c
> @@ -835,7 +835,8 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
>
> ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
> is_sync_kiocb(iocb));
> -
> + if (ret == -ENOTBLK)
> + ret = 0;
> out:
> gfs2_glock_dq(&gh);
> out_uninit:
> diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
> index 190967e87b69e4..c1aafb2ab99072 100644
> --- a/fs/iomap/direct-io.c
> +++ b/fs/iomap/direct-io.c
> @@ -10,6 +10,7 @@
> #include <linux/backing-dev.h>
> #include <linux/uio.h>
> #include <linux/task_io_accounting_ops.h>
> +#include "trace.h"
>
> #include "../internal.h"
>
> @@ -401,6 +402,9 @@ iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,
> * can be mapped into multiple disjoint IOs and only a subset of the IOs issued
> * may be pure data writes. In that case, we still need to do a full data sync
> * completion.
> + *
> + * Returns -ENOTBLK In case of a page invalidation invalidation failure for
> + * writes. The callers needs to fall back to buffered I/O in this case.
> */
> ssize_t
> iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> @@ -478,13 +482,15 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> if (iov_iter_rw(iter) == WRITE) {
> /*
> * Try to invalidate cache pages for the range we are writing.
> - * If this invalidation fails, tough, the write will still work,
> - * but racing two incompatible write paths is a pretty crazy
> - * thing to do, so we don't support it 100%.
> + * If this invalidation fails, let the caller fall back to
> + * buffered I/O.
> */
> if (invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
> - end >> PAGE_SHIFT))
> - dio_warn_stale_pagecache(iocb->ki_filp);
> + end >> PAGE_SHIFT)) {
> + trace_iomap_dio_invalidate_fail(inode, pos, count);
> + ret = -ENOTBLK;
> + goto out_free_dio;
> + }
>
> if (!wait_for_completion && !inode->i_sb->s_dio_done_wq) {
> ret = sb_init_dio_done_wq(inode->i_sb);
Just as a note. So if the driver returns -ENOTBLK (from ->iomap_end)then
iomap considers it as a magic value to fall back to buffered-io and it
changes ret=0 And now with this patch, iomap could also return
-ENOTBLK if it gets an error while doing above operation and so the
driver is free to consider this as a fallback mechanism to buffered-io.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [Cluster-devel] [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures
2020-07-21 18:31 ` [PATCH 3/3] iomap: fall back to buffered writes for invalidation failures Christoph Hellwig
` (3 preceding siblings ...)
2020-07-31 7:01 ` Ritesh Harjani
@ 2020-07-31 14:03 ` Andreas Gruenbacher
4 siblings, 0 replies; 14+ messages in thread
From: Andreas Gruenbacher @ 2020-07-31 14:03 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Dave Chinner, Goldwyn Rodrigues, Naohiro Aota, linux-xfs,
Damien Le Moal, linux-ext4, Matthew Wilcox, cluster-devel,
Goldwyn Rodrigues, linux-fsdevel, Johannes Thumshirn,
linux-btrfs
On Tue, Jul 21, 2020 at 8:55 PM Christoph Hellwig <hch@lst.de> wrote:
> Failing to invalid the page cache means data in incoherent, which is
> a very bad state for the system. Always fall back to buffered I/O
> through the page cache if we can't invalidate mappings.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Acked-by: Dave Chinner <dchinner@redhat.com>
> Reviewed-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
> ---
> fs/ext4/file.c | 2 ++
> fs/gfs2/file.c | 3 ++-
> fs/iomap/direct-io.c | 16 +++++++++++-----
> fs/iomap/trace.h | 1 +
> fs/xfs/xfs_file.c | 4 ++--
> fs/zonefs/super.c | 7 +++++--
> 6 files changed, 23 insertions(+), 10 deletions(-)
>
> diff --git a/fs/ext4/file.c b/fs/ext4/file.c
> index 2a01e31a032c4c..129cc1dd6b7952 100644
> --- a/fs/ext4/file.c
> +++ b/fs/ext4/file.c
> @@ -544,6 +544,8 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
> 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);
> + if (ret == -ENOTBLK)
> + ret = 0;
>
> if (extend)
> ret = ext4_handle_inode_extension(inode, offset, ret, count);
> diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
> index bebde537ac8cf2..b085a3bea4f0fd 100644
> --- a/fs/gfs2/file.c
> +++ b/fs/gfs2/file.c
> @@ -835,7 +835,8 @@ static ssize_t gfs2_file_direct_write(struct kiocb *iocb, struct iov_iter *from)
>
> ret = iomap_dio_rw(iocb, from, &gfs2_iomap_ops, NULL,
> is_sync_kiocb(iocb));
> -
> + if (ret == -ENOTBLK)
> + ret = 0;
> out:
> gfs2_glock_dq(&gh);
> out_uninit:
> diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
> index 190967e87b69e4..c1aafb2ab99072 100644
> --- a/fs/iomap/direct-io.c
> +++ b/fs/iomap/direct-io.c
> @@ -10,6 +10,7 @@
> #include <linux/backing-dev.h>
> #include <linux/uio.h>
> #include <linux/task_io_accounting_ops.h>
> +#include "trace.h"
>
> #include "../internal.h"
>
> @@ -401,6 +402,9 @@ iomap_dio_actor(struct inode *inode, loff_t pos, loff_t length,
> * can be mapped into multiple disjoint IOs and only a subset of the IOs issued
> * may be pure data writes. In that case, we still need to do a full data sync
> * completion.
> + *
> + * Returns -ENOTBLK In case of a page invalidation invalidation failure for
> + * writes. The callers needs to fall back to buffered I/O in this case.
> */
> ssize_t
> iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> @@ -478,13 +482,15 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
> if (iov_iter_rw(iter) == WRITE) {
> /*
> * Try to invalidate cache pages for the range we are writing.
> - * If this invalidation fails, tough, the write will still work,
> - * but racing two incompatible write paths is a pretty crazy
> - * thing to do, so we don't support it 100%.
> + * If this invalidation fails, let the caller fall back to
> + * buffered I/O.
> */
> if (invalidate_inode_pages2_range(mapping, pos >> PAGE_SHIFT,
> - end >> PAGE_SHIFT))
> - dio_warn_stale_pagecache(iocb->ki_filp);
> + end >> PAGE_SHIFT)) {
> + trace_iomap_dio_invalidate_fail(inode, pos, count);
> + ret = -ENOTBLK;
> + goto out_free_dio;
> + }
>
> if (!wait_for_completion && !inode->i_sb->s_dio_done_wq) {
> ret = sb_init_dio_done_wq(inode->i_sb);
> diff --git a/fs/iomap/trace.h b/fs/iomap/trace.h
> index 5693a39d52fb63..fdc7ae388476f5 100644
> --- a/fs/iomap/trace.h
> +++ b/fs/iomap/trace.h
> @@ -74,6 +74,7 @@ DEFINE_EVENT(iomap_range_class, name, \
> DEFINE_RANGE_EVENT(iomap_writepage);
> DEFINE_RANGE_EVENT(iomap_releasepage);
> DEFINE_RANGE_EVENT(iomap_invalidatepage);
> +DEFINE_RANGE_EVENT(iomap_dio_invalidate_fail);
>
> #define IOMAP_TYPE_STRINGS \
> { IOMAP_HOLE, "HOLE" }, \
> diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
> index a6ef90457abf97..1b4517fc55f1b9 100644
> --- a/fs/xfs/xfs_file.c
> +++ b/fs/xfs/xfs_file.c
> @@ -553,8 +553,8 @@ xfs_file_dio_aio_write(
> xfs_iunlock(ip, iolock);
>
> /*
> - * No fallback to buffered IO on errors for XFS, direct IO will either
> - * complete fully or fail.
> + * 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;
> diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
> index 07bc42d62673ce..d0a04528a7e18e 100644
> --- a/fs/zonefs/super.c
> +++ b/fs/zonefs/super.c
> @@ -786,8 +786,11 @@ static ssize_t zonefs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
> if (iocb->ki_pos >= ZONEFS_I(inode)->i_max_size)
> return -EFBIG;
>
> - if (iocb->ki_flags & IOCB_DIRECT)
> - return zonefs_file_dio_write(iocb, from);
> + if (iocb->ki_flags & IOCB_DIRECT) {
> + ssize_t ret = zonefs_file_dio_write(iocb, from);
> + if (ret != -ENOTBLK)
> + return ret;
> + }
>
> return zonefs_file_buffered_write(iocb, from);
> }
> --
> 2.27.0
>
Reviewed-by: Andreas Gruenbacher <agruenba@redhat.com> # for gfs2
Thanks,
Andreas
^ permalink raw reply [flat|nested] 14+ messages in thread