| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20251021070353.96705-6-mngyadam@amazon.de>
Date: Tue, 21 Oct 2025 09:03:39 +0200
From: Mahmoud Adam <mngyadam@...zon.de>
To: <stable@...r.kernel.org>
CC: <gregkh@...uxfoundation.org>, <nagy@...aternagy.com>, Christoph Hellwig
<hch@....de>, Damien Le Moal <dlemoal@...nel.org>, Miklos Szeredi
<mszeredi@...hat.com>, "Darrick J. Wong" <djwong@...nel.org>, Al Viro
<viro@...iv.linux.org.uk>, Andreas Gruenbacher <agruenba@...hat.com>, "Anna
Schumaker" <anna@...nel.org>, Chao Yu <chao@...nel.org>, Christian Brauner
<brauner@...nel.org>, Hannes Reinecke <hare@...e.de>, Ilya Dryomov
<idryomov@...il.com>, Jaegeuk Kim <jaegeuk@...nel.org>, Jens Axboe
<axboe@...nel.dk>, Johannes Thumshirn <johannes.thumshirn@....com>, "Matthew
Wilcox" <willy@...radead.org>, Miklos Szeredi <miklos@...redi.hu>, "Theodore
Ts'o" <tytso@....edu>, Trond Myklebust <trond.myklebust@...merspace.com>,
Xiubo Li <xiubli@...hat.com>, Andrew Morton <akpm@...ux-foundation.org>,
"Jeff Layton" <jlayton@...nel.org>, Andreas Dilger
<adilger.kernel@...ger.ca>, Christoph Hellwig <hch@...radead.org>, Ryusuke
Konishi <konishi.ryusuke@...il.com>, Luis Chamberlain <mcgrof@...nel.org>,
<linux-block@...r.kernel.org>, <linux-kernel@...r.kernel.org>,
<ceph-devel@...r.kernel.org>, <linux-fsdevel@...r.kernel.org>,
<linux-ext4@...r.kernel.org>, <linux-f2fs-devel@...ts.sourceforge.net>,
<linux-xfs@...r.kernel.org>, <linux-nfs@...r.kernel.org>,
<linux-nilfs@...r.kernel.org>, <linux-mm@...ck.org>
Subject: [PATCH 6.1 4/8] fs: factor out a direct_write_fallback helper
From: Christoph Hellwig <hch@....de>
commit 44fff0fa08ec5a6d9d5fb05443a36d854d0ece4d upstream.
Add a helper dealing with handling the syncing of a buffered write
fallback for direct I/O.
Link: https://lkml.kernel.org/r/20230601145904.1385409-10-hch@lst.de
Signed-off-by: Christoph Hellwig <hch@....de>
Reviewed-by: Damien Le Moal <dlemoal@...nel.org>
Reviewed-by: Miklos Szeredi <mszeredi@...hat.com>
Reviewed-by: Darrick J. Wong <djwong@...nel.org>
Cc: Al Viro <viro@...iv.linux.org.uk>
Cc: Andreas Gruenbacher <agruenba@...hat.com>
Cc: Anna Schumaker <anna@...nel.org>
Cc: Chao Yu <chao@...nel.org>
Cc: Christian Brauner <brauner@...nel.org>
Cc: Hannes Reinecke <hare@...e.de>
Cc: Ilya Dryomov <idryomov@...il.com>
Cc: Jaegeuk Kim <jaegeuk@...nel.org>
Cc: Jens Axboe <axboe@...nel.dk>
Cc: Johannes Thumshirn <johannes.thumshirn@....com>
Cc: Matthew Wilcox <willy@...radead.org>
Cc: Miklos Szeredi <miklos@...redi.hu>
Cc: Theodore Ts'o <tytso@....edu>
Cc: Trond Myklebust <trond.myklebust@...merspace.com>
Cc: Xiubo Li <xiubli@...hat.com>
Signed-off-by: Andrew Morton <akpm@...ux-foundation.org>
[backing_dev_info still being used here. do small changes to the patch
to keep the out label. Which means replacing all returns to goto out.]
Signed-off-by: Mahmoud Adam <mngyadam@...zon.de>
---
fs/libfs.c | 41 +++++++++++++++++++++++++++++++
include/linux/fs.h | 2 ++
mm/filemap.c | 61 +++++++++++-----------------------------------
3 files changed, 57 insertions(+), 47 deletions(-)
diff --git a/fs/libfs.c b/fs/libfs.c
index cbd42d76fbd018..a5bbe8e31d6616 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -1582,3 +1582,44 @@ bool inode_maybe_inc_iversion(struct inode *inode, bool force)
return true;
}
EXPORT_SYMBOL(inode_maybe_inc_iversion);
+
+ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,
+ ssize_t direct_written, ssize_t buffered_written)
+{
+ struct address_space *mapping = iocb->ki_filp->f_mapping;
+ loff_t pos = iocb->ki_pos - buffered_written;
+ loff_t end = iocb->ki_pos - 1;
+ int err;
+
+ /*
+ * If the buffered write fallback returned an error, we want to return
+ * the number of bytes which were written by direct I/O, or the error
+ * code if that was zero.
+ *
+ * Note that this differs from normal direct-io semantics, which will
+ * return -EFOO even if some bytes were written.
+ */
+ if (unlikely(buffered_written < 0)) {
+ if (direct_written)
+ return direct_written;
+ return buffered_written;
+ }
+
+ /*
+ * We need to ensure that the page cache pages are written to disk and
+ * invalidated to preserve the expected O_DIRECT semantics.
+ */
+ err = filemap_write_and_wait_range(mapping, pos, end);
+ if (err < 0) {
+ /*
+ * We don't know how much we wrote, so just return the number of
+ * bytes which were direct-written
+ */
+ if (direct_written)
+ return direct_written;
+ return err;
+ }
+ invalidate_mapping_pages(mapping, pos >> PAGE_SHIFT, end >> PAGE_SHIFT);
+ return direct_written + buffered_written;
+}
+EXPORT_SYMBOL_GPL(direct_write_fallback);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 4e8a3e4f894c0f..02c83cd07d4f20 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -3278,6 +3278,8 @@ extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
ssize_t generic_perform_write(struct kiocb *, struct iov_iter *);
+ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,
+ ssize_t direct_written, ssize_t buffered_written);
ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
rwf_t flags);
diff --git a/mm/filemap.c b/mm/filemap.c
index e2045266d2f2c9..b77f534dfad35a 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -3923,25 +3923,21 @@ ssize_t __generic_file_write_iter(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;
- ssize_t written = 0;
- ssize_t err;
- ssize_t status;
+ struct inode *inode = mapping->host;
+ ssize_t ret;
/* We can write back this queue in page reclaim */
current->backing_dev_info = inode_to_bdi(inode);
- err = file_remove_privs(file);
- if (err)
+ ret = file_remove_privs(file);
+ if (ret)
goto out;
- err = file_update_time(file);
- if (err)
+ ret = file_update_time(file);
+ if (ret)
goto out;
if (iocb->ki_flags & IOCB_DIRECT) {
- loff_t pos, endbyte;
-
- written = generic_file_direct_write(iocb, from);
+ ret = generic_file_direct_write(iocb, from);
/*
* If the write stopped short of completing, fall back to
* buffered writes. Some filesystems do this for writes to
@@ -3949,46 +3945,17 @@ ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
* not succeed (even if it did, DAX does not handle dirty
* page-cache pages correctly).
*/
- if (written < 0 || !iov_iter_count(from) || IS_DAX(inode))
+ if (ret < 0 || !iov_iter_count(from) || IS_DAX(inode))
goto out;
-
- pos = iocb->ki_pos;
- status = generic_perform_write(iocb, from);
- /*
- * If generic_perform_write() returned a synchronous error
- * then we want to return the number of bytes which were
- * direct-written, or the error code if that was zero. Note
- * that this differs from normal direct-io semantics, which
- * will return -EFOO even if some bytes were written.
- */
- if (unlikely(status < 0)) {
- err = status;
- goto out;
- }
- /*
- * We need to ensure that the page cache pages are written to
- * disk and invalidated to preserve the expected O_DIRECT
- * semantics.
- */
- endbyte = pos + status - 1;
- err = filemap_write_and_wait_range(mapping, pos, endbyte);
- if (err == 0) {
- written += status;
- invalidate_mapping_pages(mapping,
- pos >> PAGE_SHIFT,
- endbyte >> PAGE_SHIFT);
- } else {
- /*
- * We don't know how much we wrote, so just return
- * the number of bytes which were direct-written
- */
- }
- } else {
- written = generic_perform_write(iocb, from);
+ ret = direct_write_fallback(iocb, from, ret,
+ generic_perform_write(iocb, from));
+ goto out;
}
+
+ ret = generic_perform_write(iocb, from);
out:
current->backing_dev_info = NULL;
- return written ? written : err;
+ return ret;
}
EXPORT_SYMBOL(__generic_file_write_iter);
--
2.47.3
Amazon Web Services Development Center Germany GmbH
Tamara-Danz-Str. 13
10243 Berlin
Geschaeftsfuehrung: Christian Schlaeger
Eingetragen am Amtsgericht Charlottenburg unter HRB 257764 B
Sitz: Berlin
Ust-ID: DE 365 538 597
Powered by blists - more mailing lists