fs: change write_begin/write_end interface to take struct kiocb *

Change the address_space_operations callbacks write_begin() and
write_end() to take struct kiocb * as the first argument instead of
struct file *.

Update all affected function prototypes, implementations, call sites,
and related documentation across VFS, filesystems, and block layer.

Part of a series refactoring address_space_operations write_begin and
write_end callbacks to use struct kiocb for passing write context and
flags.

Signed-off-by: Taotao Chen <chentaotao@didiglobal.com>
Link: https://lore.kernel.org/20250716093559.217344-4-chentaotao@didiglobal.com
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/Documentation/filesystems/locking.rst b/Documentation/filesystems/locking.rst
index 2e567e341c3bde5b583bed7ec2e4c6264c44c048..580581281ed7a2a3cef946f0f0c80cc9821ae5e8 100644 (file)
--- a/Documentation/filesystems/locking.rst
+++ b/Documentation/filesystems/locking.rst
@@ -253,10 +253,10 @@ prototypes::
        int (*writepages)(struct address_space *, struct writeback_control *);
        bool (*dirty_folio)(struct address_space *, struct folio *folio);
        void (*readahead)(struct readahead_control *);
-       int (*write_begin)(struct file *, struct address_space *mapping,
+       int (*write_begin)(const struct kiocb *, struct address_space *mapping,
                                loff_t pos, unsigned len,
                                struct folio **foliop, void **fsdata);
-       int (*write_end)(struct file *, struct address_space *mapping,
+       int (*write_end)(const struct kiocb *, struct address_space *mapping,
                                loff_t pos, unsigned len, unsigned copied,
                                struct folio *folio, void *fsdata);
        sector_t (*bmap)(struct address_space *, sector_t);

diff --git a/Documentation/filesystems/vfs.rst b/Documentation/filesystems/vfs.rst
index dd9da7e04a9936cf1eab54bcf06614ee86036666..57604b07bdc99c801fb6915bd9a37dee6b1d110e 100644 (file)
--- a/Documentation/filesystems/vfs.rst
+++ b/Documentation/filesystems/vfs.rst
@@ -823,10 +823,10 @@ cache in your filesystem.  The following members are defined:
                int (*writepages)(struct address_space *, struct writeback_control *);
                bool (*dirty_folio)(struct address_space *, struct folio *);
                void (*readahead)(struct readahead_control *);
-               int (*write_begin)(struct file *, struct address_space *mapping,
+               int (*write_begin)(const struct kiocb *, struct address_space *mapping,
                                   loff_t pos, unsigned len,
-                               struct page **pagep, void **fsdata);
-               int (*write_end)(struct file *, struct address_space *mapping,
+                                  struct page **pagep, void **fsdata);
+               int (*write_end)(const struct kiocb *, struct address_space *mapping,
                                 loff_t pos, unsigned len, unsigned copied,
                                 struct folio *folio, void *fsdata);
                sector_t (*bmap)(struct address_space *, sector_t);

diff --git a/block/fops.c b/block/fops.c
index 35cea0cb304d03d988ab9c0f8a285da45728f783..f34e7315c83cd014aff96387f72b324b5ef3ed1c 100644 (file)
--- a/block/fops.c
+++ b/block/fops.c
@@ -496,15 +496,18 @@ static void blkdev_readahead(struct readahead_control *rac)
        mpage_readahead(rac, blkdev_get_block);
 }
 
-static int blkdev_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, struct folio **foliop, void **fsdata)
+static int blkdev_write_begin(const struct kiocb *iocb,
+                             struct address_space *mapping, loff_t pos,
+                             unsigned len, struct folio **foliop,
+                             void **fsdata)
 {
        return block_write_begin(mapping, pos, len, foliop, blkdev_get_block);
 }
 
-static int blkdev_write_end(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, unsigned copied, struct folio *folio,
-               void *fsdata)
+static int blkdev_write_end(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len, unsigned copied,
+                           struct folio *folio, void *fsdata)
 {
        int ret;
        ret = block_write_end(pos, len, copied, folio);

diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index 21527189e43072a21ae337976f025b4c59176896..6830f8bc8d4ebd018f4933c009ba7eee138f6379 100644 (file)
--- a/fs/adfs/inode.c
+++ b/fs/adfs/inode.c
@@ -53,13 +53,14 @@ static void adfs_write_failed(struct address_space *mapping, loff_t to)
                truncate_pagecache(inode, inode->i_size);
 }
 
-static int adfs_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int adfs_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len,
+                           struct folio **foliop, void **fsdata)
 {
        int ret;
 
-       ret = cont_write_begin(file, mapping, pos, len, foliop, fsdata,
+       ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
                                adfs_get_block,
                                &ADFS_I(mapping->host)->mmu_private);
        if (unlikely(ret))

diff --git a/fs/affs/file.c b/fs/affs/file.c
index 7a71018e3f6758d410b09bc4453cd760bf20427c..219ea035390604b0f62ef5085532af1154bd3768 100644 (file)
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -415,13 +415,14 @@ affs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
        return ret;
 }
 
-static int affs_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int affs_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len,
+                           struct folio **foliop, void **fsdata)
 {
        int ret;
 
-       ret = cont_write_begin(file, mapping, pos, len, foliop, fsdata,
+       ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
                                affs_get_block,
                                &AFFS_I(mapping->host)->mmu_private);
        if (unlikely(ret))
@@ -430,14 +431,15 @@ static int affs_write_begin(struct file *file, struct address_space *mapping,
        return ret;
 }
 
-static int affs_write_end(struct file *file, struct address_space *mapping,
-                         loff_t pos, unsigned int len, unsigned int copied,
+static int affs_write_end(const struct kiocb *iocb,
+                         struct address_space *mapping, loff_t pos,
+                         unsigned int len, unsigned int copied,
                          struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
        int ret;
 
-       ret = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
+       ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);
 
        /* Clear Archived bit on file writes, as AmigaOS would do */
        if (AFFS_I(inode)->i_protect & FIBF_ARCHIVED) {
@@ -645,7 +647,8 @@ static int affs_read_folio_ofs(struct file *file, struct folio *folio)
        return err;
 }
 
-static int affs_write_begin_ofs(struct file *file, struct address_space *mapping,
+static int affs_write_begin_ofs(const struct kiocb *iocb,
+                               struct address_space *mapping,
                                loff_t pos, unsigned len,
                                struct folio **foliop, void **fsdata)
 {
@@ -684,9 +687,10 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
        return err;
 }
 
-static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
-                               loff_t pos, unsigned len, unsigned copied,
-                               struct folio *folio, void *fsdata)
+static int affs_write_end_ofs(const struct kiocb *iocb,
+                             struct address_space *mapping,
+                             loff_t pos, unsigned len, unsigned copied,
+                             struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
        struct super_block *sb = inode->i_sb;

diff --git a/fs/bcachefs/fs-io-buffered.c b/fs/bcachefs/fs-io-buffered.c
index 66bacdd49f789b97c4805f9c3c383ab86cd3a92d..1c54b9b5bd695354d11e9afd62990310b430000a 100644 (file)
--- a/fs/bcachefs/fs-io-buffered.c
+++ b/fs/bcachefs/fs-io-buffered.c
@@ -674,7 +674,7 @@ int bch2_writepages(struct address_space *mapping, struct writeback_control *wbc
 
 /* buffered writes: */
 
-int bch2_write_begin(struct file *file, struct address_space *mapping,
+int bch2_write_begin(const struct kiocb *iocb, struct address_space *mapping,
                     loff_t pos, unsigned len,
                     struct folio **foliop, void **fsdata)
 {
@@ -757,7 +757,7 @@ err_unlock:
        return bch2_err_class(ret);
 }
 
-int bch2_write_end(struct file *file, struct address_space *mapping,
+int bch2_write_end(const struct kiocb *iocb, struct address_space *mapping,
                   loff_t pos, unsigned len, unsigned copied,
                   struct folio *folio, void *fsdata)
 {

diff --git a/fs/bcachefs/fs-io-buffered.h b/fs/bcachefs/fs-io-buffered.h
index 3207ebbb4ab43a667397b4387f30fd8ff2be319a..14de91c27656077bd8a7f58d6dd2fee16a451ffa 100644 (file)
--- a/fs/bcachefs/fs-io-buffered.h
+++ b/fs/bcachefs/fs-io-buffered.h
@@ -10,9 +10,9 @@ int bch2_read_folio(struct file *, struct folio *);
 int bch2_writepages(struct address_space *, struct writeback_control *);
 void bch2_readahead(struct readahead_control *);
 
-int bch2_write_begin(struct file *, struct address_space *, loff_t pos,
+int bch2_write_begin(const struct kiocb *, struct address_space *, loff_t pos,
                     unsigned len, struct folio **, void **);
-int bch2_write_end(struct file *, struct address_space *, loff_t,
+int bch2_write_end(const struct kiocb *, struct address_space *, loff_t,
                   unsigned len, unsigned copied, struct folio *, void *);
 
 ssize_t bch2_write_iter(struct kiocb *, struct iov_iter *);

diff --git a/fs/bfs/file.c b/fs/bfs/file.c
index fa66a09e496a815c265cdf07b1ed981983cbc596..10dc0151ea550e540dae8fc787f49b842edc0105 100644 (file)
--- a/fs/bfs/file.c
+++ b/fs/bfs/file.c
@@ -170,9 +170,10 @@ static void bfs_write_failed(struct address_space *mapping, loff_t to)
                truncate_pagecache(inode, inode->i_size);
 }
 
-static int bfs_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int bfs_write_begin(const struct kiocb *iocb,
+                          struct address_space *mapping,
+                          loff_t pos, unsigned len,
+                          struct folio **foliop, void **fsdata)
 {
        int ret;
 

diff --git a/fs/buffer.c b/fs/buffer.c
index 565fe88773c2d0a0da35c2926a487d9c66c900be..ead4dc85debdd60190b456a29d521ad26426cfeb 100644 (file)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2297,9 +2297,9 @@ int block_write_end(loff_t pos, unsigned len, unsigned copied,
 }
 EXPORT_SYMBOL(block_write_end);
 
-int generic_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+int generic_write_end(const struct kiocb *iocb, struct address_space *mapping,
+                     loff_t pos, unsigned len, unsigned copied,
+                     struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
        loff_t old_size = inode->i_size;
@@ -2494,7 +2494,8 @@ out:
 }
 EXPORT_SYMBOL(generic_cont_expand_simple);
 
-static int cont_expand_zero(struct file *file, struct address_space *mapping,
+static int cont_expand_zero(const struct kiocb *iocb,
+                           struct address_space *mapping,
                            loff_t pos, loff_t *bytes)
 {
        struct inode *inode = mapping->host;
@@ -2518,12 +2519,12 @@ static int cont_expand_zero(struct file *file, struct address_space *mapping,
                }
                len = PAGE_SIZE - zerofrom;
 
-               err = aops->write_begin(file, mapping, curpos, len,
+               err = aops->write_begin(iocb, mapping, curpos, len,
                                            &folio, &fsdata);
                if (err)
                        goto out;
                folio_zero_range(folio, offset_in_folio(folio, curpos), len);
-               err = aops->write_end(file, mapping, curpos, len, len,
+               err = aops->write_end(iocb, mapping, curpos, len, len,
                                                folio, fsdata);
                if (err < 0)
                        goto out;
@@ -2551,12 +2552,12 @@ static int cont_expand_zero(struct file *file, struct address_space *mapping,
                }
                len = offset - zerofrom;
 
-               err = aops->write_begin(file, mapping, curpos, len,
+               err = aops->write_begin(iocb, mapping, curpos, len,
                                            &folio, &fsdata);
                if (err)
                        goto out;
                folio_zero_range(folio, offset_in_folio(folio, curpos), len);
-               err = aops->write_end(file, mapping, curpos, len, len,
+               err = aops->write_end(iocb, mapping, curpos, len, len,
                                                folio, fsdata);
                if (err < 0)
                        goto out;
@@ -2571,17 +2572,16 @@ out:
  * For moronic filesystems that do not allow holes in file.
  * We may have to extend the file.
  */
-int cont_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata,
-                       get_block_t *get_block, loff_t *bytes)
+int cont_write_begin(const struct kiocb *iocb, struct address_space *mapping,
+                    loff_t pos, unsigned len, struct folio **foliop,
+                    void **fsdata, get_block_t *get_block, loff_t *bytes)
 {
        struct inode *inode = mapping->host;
        unsigned int blocksize = i_blocksize(inode);
        unsigned int zerofrom;
        int err;
 
-       err = cont_expand_zero(file, mapping, pos, bytes);
+       err = cont_expand_zero(iocb, mapping, pos, bytes);
        if (err)
                return err;
 

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 60a621b00c656dbcc4aa637a25c87a1a94c330ab..02468c848cce23aba16c2419a4ea19184c0747ed 100644 (file)
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -1864,10 +1864,12 @@ static int ceph_netfs_check_write_begin(struct file *file, loff_t pos, unsigned
  * We are only allowed to write into/dirty the page if the page is
  * clean, or already dirty within the same snap context.
  */
-static int ceph_write_begin(struct file *file, struct address_space *mapping,
+static int ceph_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
                            loff_t pos, unsigned len,
                            struct folio **foliop, void **fsdata)
 {
+       struct file *file = iocb->ki_filp;
        struct inode *inode = file_inode(file);
        struct ceph_inode_info *ci = ceph_inode(inode);
        int r;
@@ -1885,10 +1887,12 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping,
  * we don't do anything in here that simple_write_end doesn't do
  * except adjust dirty page accounting
  */
-static int ceph_write_end(struct file *file, struct address_space *mapping,
-                         loff_t pos, unsigned len, unsigned copied,
+static int ceph_write_end(const struct kiocb *iocb,
+                         struct address_space *mapping, loff_t pos,
+                         unsigned len, unsigned copied,
                          struct folio *folio, void *fsdata)
 {
+       struct file *file = iocb->ki_filp;
        struct inode *inode = file_inode(file);
        struct ceph_client *cl = ceph_inode_to_client(inode);
        bool check_cap = false;

diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 60f0ac8744b50fb047963d9d322f4278ec11abcb..2c2b12fedeaec2a2ae3b60c99a2a58efe22568dd 100644 (file)
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -228,7 +228,7 @@ out:
 
 /**
  * ecryptfs_write_begin
- * @file: The eCryptfs file
+ * @iocb: I/O control block for the eCryptfs file
  * @mapping: The eCryptfs object
  * @pos: The file offset at which to start writing
  * @len: Length of the write
@@ -239,7 +239,7 @@ out:
  *
  * Returns zero on success; non-zero otherwise
  */
-static int ecryptfs_write_begin(struct file *file,
+static int ecryptfs_write_begin(const struct kiocb *iocb,
                        struct address_space *mapping,
                        loff_t pos, unsigned len,
                        struct folio **foliop, void **fsdata)
@@ -322,7 +322,7 @@ static int ecryptfs_write_begin(struct file *file,
         * Note, this will increase i_size. */
        if (index != 0) {
                if (prev_page_end_size > i_size_read(mapping->host)) {
-                       rc = ecryptfs_truncate(file->f_path.dentry,
+                       rc = ecryptfs_truncate(iocb->ki_filp->f_path.dentry,
                                               prev_page_end_size);
                        if (rc) {
                                printk(KERN_ERR "%s: Error on attempt to "
@@ -429,7 +429,7 @@ int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode)
 
 /**
  * ecryptfs_write_end
- * @file: The eCryptfs file object
+ * @iocb: I/O control block for the eCryptfs file
  * @mapping: The eCryptfs object
  * @pos: The file position
  * @len: The length of the data (unused)
@@ -437,7 +437,7 @@ int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode)
  * @folio: The eCryptfs folio
  * @fsdata: The fsdata (unused)
  */
-static int ecryptfs_write_end(struct file *file,
+static int ecryptfs_write_end(const struct kiocb *iocb,
                        struct address_space *mapping,
                        loff_t pos, unsigned len, unsigned copied,
                        struct folio *folio, void *fsdata)

diff --git a/fs/exfat/file.c b/fs/exfat/file.c
index 841a5b18e3dfdb3566ec28ca7096a28713b17ffa..70f53edd0a1041561193e4dfc33192c3cd3b094d 100644 (file)
--- a/fs/exfat/file.c
+++ b/fs/exfat/file.c
@@ -532,11 +532,10 @@ int exfat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
        return blkdev_issue_flush(inode->i_sb->s_bdev);
 }
 
-static int exfat_extend_valid_size(struct file *file, loff_t new_valid_size)
+static int exfat_extend_valid_size(struct inode *inode, loff_t new_valid_size)
 {
        int err;
        loff_t pos;
-       struct inode *inode = file_inode(file);
        struct exfat_inode_info *ei = EXFAT_I(inode);
        struct address_space *mapping = inode->i_mapping;
        const struct address_space_operations *ops = mapping->a_ops;
@@ -551,14 +550,14 @@ static int exfat_extend_valid_size(struct file *file, loff_t new_valid_size)
                if (pos + len > new_valid_size)
                        len = new_valid_size - pos;
 
-               err = ops->write_begin(file, mapping, pos, len, &folio, NULL);
+               err = ops->write_begin(NULL, mapping, pos, len, &folio, NULL);
                if (err)
                        goto out;
 
                off = offset_in_folio(folio, pos);
                folio_zero_new_buffers(folio, off, off + len);
 
-               err = ops->write_end(file, mapping, pos, len, len, folio, NULL);
+               err = ops->write_end(NULL, mapping, pos, len, len, folio, NULL);
                if (err < 0)
                        goto out;
                pos += len;
@@ -604,7 +603,7 @@ static ssize_t exfat_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
        }
 
        if (pos > valid_size) {
-               ret = exfat_extend_valid_size(file, pos);
+               ret = exfat_extend_valid_size(inode, pos);
                if (ret < 0 && ret != -ENOSPC) {
                        exfat_err(inode->i_sb,
                                "write: fail to zero from %llu to %llu(%zd)",
@@ -665,7 +664,7 @@ static vm_fault_t exfat_page_mkwrite(struct vm_fault *vmf)
                        start + vma->vm_end - vma->vm_start);
 
        if (ei->valid_size < end) {
-               err = exfat_extend_valid_size(file, end);
+               err = exfat_extend_valid_size(inode, end);
                if (err < 0) {
                        inode_unlock(inode);
                        return vmf_fs_error(err);

diff --git a/fs/exfat/inode.c b/fs/exfat/inode.c
index b22c02d6000f79d6157bdd21fdc71176dda80d67..c10844e1e16c34ab42f9b68046021313d1d9e48c 100644 (file)
--- a/fs/exfat/inode.c
+++ b/fs/exfat/inode.c
@@ -446,9 +446,10 @@ static void exfat_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-static int exfat_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned int len,
-               struct folio **foliop, void **fsdata)
+static int exfat_write_begin(const struct kiocb *iocb,
+                            struct address_space *mapping,
+                            loff_t pos, unsigned int len,
+                            struct folio **foliop, void **fsdata)
 {
        int ret;
 
@@ -463,15 +464,16 @@ static int exfat_write_begin(struct file *file, struct address_space *mapping,
        return ret;
 }
 
-static int exfat_write_end(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned int len, unsigned int copied,
-               struct folio *folio, void *fsdata)
+static int exfat_write_end(const struct kiocb *iocb,
+                          struct address_space *mapping,
+                          loff_t pos, unsigned int len, unsigned int copied,
+                          struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
        struct exfat_inode_info *ei = EXFAT_I(inode);
        int err;
 
-       err = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
+       err = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);
        if (err < len)
                exfat_write_failed(mapping, pos+len);
 

diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 30f8201c155f408fe6a971d7a20ff3b0d3e853a9..d35ca26eee3cef55888ec24436d519bcd1037ca4 100644 (file)
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -915,7 +915,7 @@ static void ext2_readahead(struct readahead_control *rac)
 }
 
 static int
-ext2_write_begin(struct file *file, struct address_space *mapping,
+ext2_write_begin(const struct kiocb *iocb, struct address_space *mapping,
                loff_t pos, unsigned len, struct folio **foliop, void **fsdata)
 {
        int ret;
@@ -926,13 +926,14 @@ ext2_write_begin(struct file *file, struct address_space *mapping,
        return ret;
 }
 
-static int ext2_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+static int ext2_write_end(const struct kiocb *iocb,
+                         struct address_space *mapping,
+                         loff_t pos, unsigned len, unsigned copied,
+                         struct folio *folio, void *fsdata)
 {
        int ret;
 
-       ret = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
+       ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);
        if (ret < len)
                ext2_write_failed(mapping, pos + len);
        return ret;

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index e6aa7ca6d8420880c29396976d4fa5150fa95885..9a16efd072bb8608d45e02f6b00c0de39c38483a 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1252,7 +1252,8 @@ int ext4_block_write_begin(handle_t *handle, struct folio *folio,
  * and the ext4_write_end().  So doing the jbd2_journal_start at the start of
  * ext4_write_begin() is the right place.
  */
-static int ext4_write_begin(struct file *file, struct address_space *mapping,
+static int ext4_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
                            loff_t pos, unsigned len,
                            struct folio **foliop, void **fsdata)
 {
@@ -1400,12 +1401,12 @@ static int write_end_fn(handle_t *handle, struct inode *inode,
 
 /*
  * We need to pick up the new inode size which generic_commit_write gave us
- * `file' can be NULL - eg, when called from page_symlink().
+ * `iocb` can be NULL - eg, when called from page_symlink().
  *
  * ext4 never places buffers on inode->i_mapping->i_private_list.  metadata
  * buffers are managed internally.
  */
-static int ext4_write_end(struct file *file,
+static int ext4_write_end(const struct kiocb *iocb,
                          struct address_space *mapping,
                          loff_t pos, unsigned len, unsigned copied,
                          struct folio *folio, void *fsdata)
@@ -1510,7 +1511,7 @@ static void ext4_journalled_zero_new_buffers(handle_t *handle,
        } while (bh != head);
 }
 
-static int ext4_journalled_write_end(struct file *file,
+static int ext4_journalled_write_end(const struct kiocb *iocb,
                                     struct address_space *mapping,
                                     loff_t pos, unsigned len, unsigned copied,
                                     struct folio *folio, void *fsdata)
@@ -3036,7 +3037,8 @@ static int ext4_nonda_switch(struct super_block *sb)
        return 0;
 }
 
-static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
+static int ext4_da_write_begin(const struct kiocb *iocb,
+                              struct address_space *mapping,
                               loff_t pos, unsigned len,
                               struct folio **foliop, void **fsdata)
 {
@@ -3054,7 +3056,7 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
 
        if (ext4_nonda_switch(inode->i_sb) || ext4_verity_in_progress(inode)) {
                *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
-               return ext4_write_begin(file, mapping, pos,
+               return ext4_write_begin(iocb, mapping, pos,
                                        len, foliop, fsdata);
        }
        *fsdata = (void *)0;
@@ -3195,7 +3197,7 @@ static int ext4_da_do_write_end(struct address_space *mapping,
        return copied;
 }
 
-static int ext4_da_write_end(struct file *file,
+static int ext4_da_write_end(const struct kiocb *iocb,
                             struct address_space *mapping,
                             loff_t pos, unsigned len, unsigned copied,
                             struct folio *folio, void *fsdata)
@@ -3204,7 +3206,7 @@ static int ext4_da_write_end(struct file *file,
        int write_mode = (int)(unsigned long)fsdata;
 
        if (write_mode == FALL_BACK_TO_NONDELALLOC)
-               return ext4_write_end(file, mapping, pos,
+               return ext4_write_end(iocb, mapping, pos,
                                      len, copied, folio, fsdata);
 
        trace_ext4_da_write_end(inode, pos, len, copied);

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 31e892842625928d5731a02670f7d137cb902a4a..711ad80b38d05bbad723a2f31d2b5c2c2595d673 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -3519,8 +3519,10 @@ reserve_block:
        return 0;
 }
 
-static int f2fs_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, struct folio **foliop, void **fsdata)
+static int f2fs_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len, struct folio **foliop,
+                           void **fsdata)
 {
        struct inode *inode = mapping->host;
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
@@ -3656,7 +3658,7 @@ fail:
        return err;
 }
 
-static int f2fs_write_end(struct file *file,
+static int f2fs_write_end(const struct kiocb *iocb,
                        struct address_space *mapping,
                        loff_t pos, unsigned len, unsigned copied,
                        struct folio *folio, void *fsdata)

diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 3852bb66358cc141bd2ba4d5d5b5f3516c753f23..9648ed09781683723d39ae08e6c024855769a584 100644 (file)
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -219,13 +219,14 @@ static void fat_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-static int fat_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int fat_write_begin(const struct kiocb *iocb,
+                          struct address_space *mapping,
+                          loff_t pos, unsigned len,
+                          struct folio **foliop, void **fsdata)
 {
        int err;
 
-       err = cont_write_begin(file, mapping, pos, len,
+       err = cont_write_begin(iocb, mapping, pos, len,
                                foliop, fsdata, fat_get_block,
                                &MSDOS_I(mapping->host)->mmu_private);
        if (err < 0)
@@ -233,13 +234,14 @@ static int fat_write_begin(struct file *file, struct address_space *mapping,
        return err;
 }
 
-static int fat_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+static int fat_write_end(const struct kiocb *iocb,
+                        struct address_space *mapping,
+                        loff_t pos, unsigned len, unsigned copied,
+                        struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
        int err;
-       err = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
+       err = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);
        if (err < len)
                fat_write_failed(mapping, pos + len);
        if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) {

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index f102afc03359b232738a2f1b656f9318b1af8207..21c6f8654bfe68faa35273e9e52240914523399a 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -2213,10 +2213,13 @@ out:
  * It's worthy to make sure that space is reserved on disk for the write,
  * but how to implement it without killing performance need more thinking.
  */
-static int fuse_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, struct folio **foliop, void **fsdata)
+static int fuse_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len, struct folio **foliop,
+                           void **fsdata)
 {
        pgoff_t index = pos >> PAGE_SHIFT;
+       struct file *file = iocb->ki_filp;
        struct fuse_conn *fc = get_fuse_conn(file_inode(file));
        struct folio *folio;
        loff_t fsize;
@@ -2256,9 +2259,10 @@ error:
        return err;
 }
 
-static int fuse_write_end(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, unsigned copied,
-               struct folio *folio, void *fsdata)
+static int fuse_write_end(const struct kiocb *iocb,
+                         struct address_space *mapping,
+                         loff_t pos, unsigned len, unsigned copied,
+                         struct folio *folio, void *fsdata)
 {
        struct inode *inode = folio->mapping->host;
 

diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index a0c7cb0f79fcc9ac6a188012c7485be936cb68de..c3fd3172fdd60c89b6bd52992f9686ad1aefa00d 100644 (file)
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -201,7 +201,7 @@ extern int hfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern const struct address_space_operations hfs_aops;
 extern const struct address_space_operations hfs_btree_aops;
 
-int hfs_write_begin(struct file *file, struct address_space *mapping,
+int hfs_write_begin(const struct kiocb *iocb, struct address_space *mapping,
                loff_t pos, unsigned len, struct folio **foliop, void **fsdata);
 extern struct inode *hfs_new_inode(struct inode *, const struct qstr *, umode_t);
 extern void hfs_inode_write_fork(struct inode *, struct hfs_extent *, __be32 *, __be32 *);

diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index a81ce7a740b918e505632d32b6efc35e9bd68362..096f338134f937615cceac43c0793dc306f2e4ec 100644 (file)
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -44,12 +44,12 @@ static void hfs_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-int hfs_write_begin(struct file *file, struct address_space *mapping,
+int hfs_write_begin(const struct kiocb *iocb, struct address_space *mapping,
                loff_t pos, unsigned len, struct folio **foliop, void **fsdata)
 {
        int ret;
 
-       ret = cont_write_begin(file, mapping, pos, len, foliop, fsdata,
+       ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
                                hfs_get_block,
                                &HFS_I(mapping->host)->phys_size);
        if (unlikely(ret))

diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 2f089bff0095c0003b482c4c680adb1c005ca79a..3d5c65aef3b231f4bda3a1685b3405549d09e5aa 100644 (file)
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -473,8 +473,10 @@ extern const struct address_space_operations hfsplus_aops;
 extern const struct address_space_operations hfsplus_btree_aops;
 extern const struct dentry_operations hfsplus_dentry_operations;
 
-int hfsplus_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, struct folio **foliop, void **fsdata);
+int hfsplus_write_begin(const struct kiocb *iocb,
+                       struct address_space *mapping,
+                       loff_t pos, unsigned len, struct folio **foliop,
+                       void **fsdata);
 struct inode *hfsplus_new_inode(struct super_block *sb, struct inode *dir,
                                umode_t mode);
 void hfsplus_delete_inode(struct inode *inode);

diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index f331e957421783819edaae4796d0b9babe9ede22..97d75bb2c388ea949c24451fb13e862b422b7f12 100644 (file)
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -38,12 +38,14 @@ static void hfsplus_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-int hfsplus_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, struct folio **foliop, void **fsdata)
+int hfsplus_write_begin(const struct kiocb *iocb,
+                       struct address_space *mapping, loff_t pos,
+                       unsigned len, struct folio **foliop,
+                       void **fsdata)
 {
        int ret;
 
-       ret = cont_write_begin(file, mapping, pos, len, foliop, fsdata,
+       ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
                                hfsplus_get_block,
                                &HFSPLUS_I(mapping->host)->phys_size);
        if (unlikely(ret))

diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 702c41317589a82c2e03ff474b4303c6dd336f52..6c2cf0cdf3d60e655f36fab1b1576874967fd9c0 100644 (file)
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -445,7 +445,8 @@ static int hostfs_read_folio(struct file *file, struct folio *folio)
        return ret;
 }
 
-static int hostfs_write_begin(struct file *file, struct address_space *mapping,
+static int hostfs_write_begin(const struct kiocb *iocb,
+                             struct address_space *mapping,
                              loff_t pos, unsigned len,
                              struct folio **foliop, void **fsdata)
 {
@@ -458,7 +459,8 @@ static int hostfs_write_begin(struct file *file, struct address_space *mapping,
        return 0;
 }
 
-static int hostfs_write_end(struct file *file, struct address_space *mapping,
+static int hostfs_write_end(const struct kiocb *iocb,
+                           struct address_space *mapping,
                            loff_t pos, unsigned len, unsigned copied,
                            struct folio *folio, void *fsdata)
 {
@@ -468,7 +470,7 @@ static int hostfs_write_end(struct file *file, struct address_space *mapping,
        int err;
 
        buffer = kmap_local_folio(folio, from);
-       err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer, copied);
+       err = write_file(FILE_HOSTFS_I(iocb->ki_filp)->fd, &pos, buffer, copied);
        kunmap_local(buffer);
 
        if (!folio_test_uptodate(folio) && err == folio_size(folio))

diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
index 449a3fc1b8d9000699561777fbcb6321013147d4..7b95a3d2e2a6d2a1611a2334bc0ebcd62ffe1567 100644 (file)
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -188,13 +188,14 @@ static void hpfs_write_failed(struct address_space *mapping, loff_t to)
        hpfs_unlock(inode->i_sb);
 }
 
-static int hpfs_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int hpfs_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len,
+                           struct folio **foliop, void **fsdata)
 {
        int ret;
 
-       ret = cont_write_begin(file, mapping, pos, len, foliop, fsdata,
+       ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
                                hpfs_get_block,
                                &hpfs_i(mapping->host)->mmu_private);
        if (unlikely(ret))
@@ -203,13 +204,14 @@ static int hpfs_write_begin(struct file *file, struct address_space *mapping,
        return ret;
 }
 
-static int hpfs_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+static int hpfs_write_end(const struct kiocb *iocb,
+                         struct address_space *mapping,
+                         loff_t pos, unsigned len, unsigned copied,
+                         struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
        int err;
-       err = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
+       err = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);
        if (err < len)
                hpfs_write_failed(mapping, pos + len);
        if (!(err < 0)) {

diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index e4de5425838d92c861d5e1f4811ab6ec2582ccc3..541aae502d4d1adbe4b2b622da1cf3789f5fabd9 100644 (file)
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -311,7 +311,7 @@ static ssize_t hugetlbfs_read_iter(struct kiocb *iocb, struct iov_iter *to)
        return retval;
 }
 
-static int hugetlbfs_write_begin(struct file *file,
+static int hugetlbfs_write_begin(const struct kiocb *iocb,
                        struct address_space *mapping,
                        loff_t pos, unsigned len,
                        struct folio **foliop, void **fsdata)
@@ -319,9 +319,10 @@ static int hugetlbfs_write_begin(struct file *file,
        return -EINVAL;
 }
 
-static int hugetlbfs_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+static int hugetlbfs_write_end(const struct kiocb *iocb,
+                              struct address_space *mapping,
+                              loff_t pos, unsigned len, unsigned copied,
+                              struct folio *folio, void *fsdata)
 {
        BUG();
        return -EINVAL;

diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index 13c18ccc13b0ab8d36bf4d90154dbe5c647b266f..adec3af9bf8d1876b19eb26f5eb0735b4f955eff 100644 (file)
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -21,12 +21,14 @@
 #include <linux/jffs2.h>
 #include "nodelist.h"
 
-static int jffs2_write_end(struct file *filp, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata);
-static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata);
+static int jffs2_write_end(const struct kiocb *iocb,
+                          struct address_space *mapping,
+                          loff_t pos, unsigned len, unsigned copied,
+                          struct folio *folio, void *fsdata);
+static int jffs2_write_begin(const struct kiocb *iocb,
+                            struct address_space *mapping,
+                            loff_t pos, unsigned len,
+                            struct folio **foliop, void **fsdata);
 static int jffs2_read_folio(struct file *filp, struct folio *folio);
 
 int jffs2_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
@@ -121,9 +123,10 @@ static int jffs2_read_folio(struct file *file, struct folio *folio)
        return ret;
 }
 
-static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int jffs2_write_begin(const struct kiocb *iocb,
+                            struct address_space *mapping,
+                            loff_t pos, unsigned len,
+                            struct folio **foliop, void **fsdata)
 {
        struct folio *folio;
        struct inode *inode = mapping->host;
@@ -235,9 +238,10 @@ out_err:
        return ret;
 }
 
-static int jffs2_write_end(struct file *filp, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+static int jffs2_write_end(const struct kiocb *iocb,
+                          struct address_space *mapping,
+                          loff_t pos, unsigned len, unsigned copied,
+                          struct folio *folio, void *fsdata)
 {
        /* Actually commit the write from the page cache page we're looking at.
         * For now, we write the full page out each time. It sucks, but it's simple

diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index 60fc92dee24d2059b2d4780accac88c610131536..083e7fa54709d07ebd6ad7fd5639383dbdad43b4 100644 (file)
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -290,9 +290,10 @@ static void jfs_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-static int jfs_write_begin(struct file *file, struct address_space *mapping,
-                               loff_t pos, unsigned len,
-                               struct folio **foliop, void **fsdata)
+static int jfs_write_begin(const struct kiocb *iocb,
+                          struct address_space *mapping,
+                          loff_t pos, unsigned len,
+                          struct folio **foliop, void **fsdata)
 {
        int ret;
 
@@ -303,13 +304,14 @@ static int jfs_write_begin(struct file *file, struct address_space *mapping,
        return ret;
 }
 
-static int jfs_write_end(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, unsigned copied, struct folio *folio,
-               void *fsdata)
+static int jfs_write_end(const struct kiocb *iocb,
+                        struct address_space *mapping,
+                        loff_t pos, unsigned len, unsigned copied,
+                        struct folio *folio, void *fsdata)
 {
        int ret;
 
-       ret = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
+       ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);
        if (ret < len)
                jfs_write_failed(mapping, pos + len);
        return ret;

diff --git a/fs/libfs.c b/fs/libfs.c
index f99ecc3006471d43c827556bdaccf66c5557d430..52196566ccbceb777fd9932dbc2ef78c8d29238c 100644 (file)
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -910,7 +910,7 @@ static int simple_read_folio(struct file *file, struct folio *folio)
        return 0;
 }
 
-int simple_write_begin(struct file *file, struct address_space *mapping,
+int simple_write_begin(const struct kiocb *iocb, struct address_space *mapping,
                        loff_t pos, unsigned len,
                        struct folio **foliop, void **fsdata)
 {
@@ -935,7 +935,7 @@ EXPORT_SYMBOL(simple_write_begin);
 
 /**
  * simple_write_end - .write_end helper for non-block-device FSes
- * @file: See .write_end of address_space_operations
+ * @iocb: kernel I/O control block
  * @mapping:           "
  * @pos:               "
  * @len:               "
@@ -956,9 +956,10 @@ EXPORT_SYMBOL(simple_write_begin);
  *
  * Use *ONLY* with simple_read_folio()
  */
-static int simple_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+static int simple_write_end(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len, unsigned copied,
+                           struct folio *folio, void *fsdata)
 {
        struct inode *inode = folio->mapping->host;
        loff_t last_pos = pos + copied;

diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index f007e389d5d29b8f8416e5a31566f53eeaa4eec9..df9d11479caf1e11f9847df2087ff81763147122 100644 (file)
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -442,9 +442,10 @@ static void minix_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-static int minix_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int minix_write_begin(const struct kiocb *iocb,
+                            struct address_space *mapping,
+                            loff_t pos, unsigned len,
+                            struct folio **foliop, void **fsdata)
 {
        int ret;
 

diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 033feeab8c346ee89ad001487d543d78a3fe7b3d..2bd557ca1af9578525ad8addd9fd497304523cc0 100644 (file)
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -342,12 +342,14 @@ static bool nfs_want_read_modify_write(struct file *file, struct folio *folio,
  * If the writer ends up delaying the write, the writer needs to
  * increment the page use counts until he is done with the page.
  */
-static int nfs_write_begin(struct file *file, struct address_space *mapping,
+static int nfs_write_begin(const struct kiocb *iocb,
+                          struct address_space *mapping,
                           loff_t pos, unsigned len, struct folio **foliop,
                           void **fsdata)
 {
        fgf_t fgp = FGP_WRITEBEGIN;
        struct folio *folio;
+       struct file *file = iocb->ki_filp;
        int once_thru = 0;
        int ret;
 
@@ -377,10 +379,12 @@ start:
        return ret;
 }
 
-static int nfs_write_end(struct file *file, struct address_space *mapping,
+static int nfs_write_end(const struct kiocb *iocb,
+                        struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned copied,
                         struct folio *folio, void *fsdata)
 {
+       struct file *file = iocb->ki_filp;
        struct nfs_open_context *ctx = nfs_file_open_context(file);
        unsigned offset = offset_in_folio(folio, pos);
        int status;

diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 6613b8fcceb0d9c79b367f9614e35a37ef072012..c2ccafdf4a19f3edc5b36bfbe856ba9733cb8d56 100644 (file)
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -218,7 +218,8 @@ void nilfs_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-static int nilfs_write_begin(struct file *file, struct address_space *mapping,
+static int nilfs_write_begin(const struct kiocb *iocb,
+                            struct address_space *mapping,
                             loff_t pos, unsigned len,
                             struct folio **foliop, void **fsdata)
 
@@ -237,7 +238,8 @@ static int nilfs_write_begin(struct file *file, struct address_space *mapping,
        return err;
 }
 
-static int nilfs_write_end(struct file *file, struct address_space *mapping,
+static int nilfs_write_end(const struct kiocb *iocb,
+                          struct address_space *mapping,
                           loff_t pos, unsigned len, unsigned copied,
                           struct folio *folio, void *fsdata)
 {
@@ -248,7 +250,7 @@ static int nilfs_write_end(struct file *file, struct address_space *mapping,
 
        nr_dirty = nilfs_page_count_clean_buffers(folio, start,
                                                  start + copied);
-       copied = generic_write_end(file, mapping, pos, len, copied, folio,
+       copied = generic_write_end(iocb, mapping, pos, len, copied, folio,
                                   fsdata);
        nilfs_set_file_dirty(inode, nr_dirty);
        err = nilfs_transaction_commit(inode->i_sb);

diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c
index 1e99a35691cdfc52072c17275e5571c4d7b3920d..1590c2a3c48fc8002504792f0e424a0b4b4fdc43 100644 (file)
--- a/fs/ntfs3/file.c
+++ b/fs/ntfs3/file.c
@@ -154,13 +154,13 @@ static int ntfs_extend_initialized_size(struct file *file,
                if (pos + len > new_valid)
                        len = new_valid - pos;
 
-               err = ntfs_write_begin(file, mapping, pos, len, &folio, NULL);
+               err = ntfs_write_begin(NULL, mapping, pos, len, &folio, NULL);
                if (err)
                        goto out;
 
                folio_zero_range(folio, zerofrom, folio_size(folio) - zerofrom);
 
-               err = ntfs_write_end(file, mapping, pos, len, len, folio, NULL);
+               err = ntfs_write_end(NULL, mapping, pos, len, len, folio, NULL);
                if (err < 0)
                        goto out;
                pos += len;

diff --git a/fs/ntfs3/inode.c b/fs/ntfs3/inode.c
index 0f0d27d4644a9b5802abfa122d376d3f01bbb3f2..dad088e64b3c52985d826356fc736031cfc85a3a 100644 (file)
--- a/fs/ntfs3/inode.c
+++ b/fs/ntfs3/inode.c
@@ -912,7 +912,7 @@ static int ntfs_get_block_write_begin(struct inode *inode, sector_t vbn,
                                  bh_result, create, GET_BLOCK_WRITE_BEGIN);
 }
 
-int ntfs_write_begin(struct file *file, struct address_space *mapping,
+int ntfs_write_begin(const struct kiocb *iocb, struct address_space *mapping,
                     loff_t pos, u32 len, struct folio **foliop, void **fsdata)
 {
        int err;
@@ -957,7 +957,8 @@ out:
 /*
  * ntfs_write_end - Address_space_operations::write_end.
  */
-int ntfs_write_end(struct file *file, struct address_space *mapping, loff_t pos,
+int ntfs_write_end(const struct kiocb *iocb,
+                  struct address_space *mapping, loff_t pos,
                   u32 len, u32 copied, struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
@@ -989,7 +990,7 @@ int ntfs_write_end(struct file *file, struct address_space *mapping, loff_t pos,
                folio_unlock(folio);
                folio_put(folio);
        } else {
-               err = generic_write_end(file, mapping, pos, len, copied, folio,
+               err = generic_write_end(iocb, mapping, pos, len, copied, folio,
                                        fsdata);
        }
 

diff --git a/fs/ntfs3/ntfs_fs.h b/fs/ntfs3/ntfs_fs.h
index 36b8052660d52c0ceab07c28fac2e23ae5a6a72e..921257773eec61492ebe407de353b080012d68bb 100644 (file)
--- a/fs/ntfs3/ntfs_fs.h
+++ b/fs/ntfs3/ntfs_fs.h
@@ -702,10 +702,12 @@ struct inode *ntfs_iget5(struct super_block *sb, const struct MFT_REF *ref,
 int ntfs_set_size(struct inode *inode, u64 new_size);
 int ntfs_get_block(struct inode *inode, sector_t vbn,
                   struct buffer_head *bh_result, int create);
-int ntfs_write_begin(struct file *file, struct address_space *mapping,
-                    loff_t pos, u32 len, struct folio **foliop, void **fsdata);
-int ntfs_write_end(struct file *file, struct address_space *mapping, loff_t pos,
-                  u32 len, u32 copied, struct folio *folio, void *fsdata);
+int ntfs_write_begin(const struct kiocb *iocb, struct address_space *mapping,
+                    loff_t pos, u32 len, struct folio **foliop,
+                    void **fsdata);
+int ntfs_write_end(const struct kiocb *iocb, struct address_space *mapping,
+                  loff_t pos, u32 len, u32 copied, struct folio *folio,
+                  void *fsdata);
 int ntfs3_write_inode(struct inode *inode, struct writeback_control *wbc);
 int ntfs_sync_inode(struct inode *inode);
 int inode_read_data(struct inode *inode, void *data, size_t bytes);

diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 40b6bce12951ec546beea383f35b3f4285dfcc76..2203438738f68b22ebb3c18436190e20b24c33cc 100644 (file)
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -1856,7 +1856,8 @@ out:
        return ret;
 }
 
-static int ocfs2_write_begin(struct file *file, struct address_space *mapping,
+static int ocfs2_write_begin(const struct kiocb *iocb,
+                            struct address_space *mapping,
                             loff_t pos, unsigned len,
                             struct folio **foliop, void **fsdata)
 {
@@ -2047,7 +2048,8 @@ out:
        return copied;
 }
 
-static int ocfs2_write_end(struct file *file, struct address_space *mapping,
+static int ocfs2_write_end(const struct kiocb *iocb,
+                          struct address_space *mapping,
                           loff_t pos, unsigned len, unsigned copied,
                           struct folio *folio, void *fsdata)
 {

diff --git a/fs/omfs/file.c b/fs/omfs/file.c
index 98358d405b6ab4010ff054b333d4ee5bc6ed8ee6..8d70f816b0c9d97ec8599e230fcbf66e2b62a818 100644 (file)
--- a/fs/omfs/file.c
+++ b/fs/omfs/file.c
@@ -310,9 +310,10 @@ static void omfs_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-static int omfs_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int omfs_write_begin(const struct kiocb *iocb,
+                           struct address_space *mapping,
+                           loff_t pos, unsigned len,
+                           struct folio **foliop, void **fsdata)
 {
        int ret;
 

diff --git a/fs/orangefs/inode.c b/fs/orangefs/inode.c
index 08a6f372a352f81fae3529ff8aa7e3d27082a263..a7ab637767359d0f31af00a8ecbde6c3a2449d66 100644 (file)
--- a/fs/orangefs/inode.c
+++ b/fs/orangefs/inode.c
@@ -285,9 +285,10 @@ static int orangefs_read_folio(struct file *file, struct folio *folio)
        return ret;
 }
 
-static int orangefs_write_begin(struct file *file,
-               struct address_space *mapping, loff_t pos, unsigned len,
-               struct folio **foliop, void **fsdata)
+static int orangefs_write_begin(const struct kiocb *iocb,
+                               struct address_space *mapping, loff_t pos,
+                               unsigned len, struct folio **foliop,
+                               void **fsdata)
 {
        struct orangefs_write_range *wr;
        struct folio *folio;
@@ -340,9 +341,10 @@ okay:
        return 0;
 }
 
-static int orangefs_write_end(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, unsigned copied, struct folio *folio,
-               void *fsdata)
+static int orangefs_write_end(const struct kiocb *iocb,
+                             struct address_space *mapping,
+                             loff_t pos, unsigned len, unsigned copied,
+                             struct folio *folio, void *fsdata)
 {
        struct inode *inode = folio->mapping->host;
        loff_t last_pos = pos + copied;
@@ -372,7 +374,7 @@ static int orangefs_write_end(struct file *file, struct address_space *mapping,
        folio_unlock(folio);
        folio_put(folio);
 
-       mark_inode_dirty_sync(file_inode(file));
+       mark_inode_dirty_sync(file_inode(iocb->ki_filp));
        return copied;
 }
 

diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index bf311c38d9a898364541f1d121f7dafd361d9986..cee8bec1ea26d4765c919d58661fbc4436407174 100644 (file)
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -404,7 +404,8 @@ static int allocate_budget(struct ubifs_info *c, struct folio *folio,
  * there is a plenty of flash space and the budget will be acquired quickly,
  * without forcing write-back. The slow path does not make this assumption.
  */
-static int ubifs_write_begin(struct file *file, struct address_space *mapping,
+static int ubifs_write_begin(const struct kiocb *iocb,
+                            struct address_space *mapping,
                             loff_t pos, unsigned len,
                             struct folio **foliop, void **fsdata)
 {
@@ -514,8 +515,9 @@ static void cancel_budget(struct ubifs_info *c, struct folio *folio,
        }
 }
 
-static int ubifs_write_end(struct file *file, struct address_space *mapping,
-                          loff_t pos, unsigned len, unsigned copied,
+static int ubifs_write_end(const struct kiocb *iocb,
+                          struct address_space *mapping, loff_t pos,
+                          unsigned len, unsigned copied,
                           struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;

diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 4386dd845e40097da75ba8325a12d5c69a37ad36..356b75676fa932822f39b2d3f49b4a7748cf3d45 100644 (file)
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -244,10 +244,12 @@ static void udf_readahead(struct readahead_control *rac)
        mpage_readahead(rac, udf_get_block);
 }
 
-static int udf_write_begin(struct file *file, struct address_space *mapping,
+static int udf_write_begin(const struct kiocb *iocb,
+                          struct address_space *mapping,
                           loff_t pos, unsigned len,
                           struct folio **foliop, void **fsdata)
 {
+       struct file *file = iocb->ki_filp;
        struct udf_inode_info *iinfo = UDF_I(file_inode(file));
        struct folio *folio;
        int ret;
@@ -271,15 +273,16 @@ static int udf_write_begin(struct file *file, struct address_space *mapping,
        return 0;
 }
 
-static int udf_write_end(struct file *file, struct address_space *mapping,
+static int udf_write_end(const struct kiocb *iocb,
+                        struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned copied,
                         struct folio *folio, void *fsdata)
 {
-       struct inode *inode = file_inode(file);
+       struct inode *inode = file_inode(iocb->ki_filp);
        loff_t last_pos;
 
        if (UDF_I(inode)->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB)
-               return generic_write_end(file, mapping, pos, len, copied, folio,
+               return generic_write_end(iocb, mapping, pos, len, copied, folio,
                                         fsdata);
        last_pos = pos + copied;
        if (last_pos > inode->i_size)

diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 7dc38fdef2eab9964f5bb9621a03df3b423be3cc..8361c00e8fa6fecf592d25d19504f5631a08a509 100644 (file)
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -474,9 +474,10 @@ static void ufs_write_failed(struct address_space *mapping, loff_t to)
        }
 }
 
-static int ufs_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+static int ufs_write_begin(const struct kiocb *iocb,
+                          struct address_space *mapping,
+                          loff_t pos, unsigned len,
+                          struct folio **foliop, void **fsdata)
 {
        int ret;
 
@@ -487,13 +488,14 @@ static int ufs_write_begin(struct file *file, struct address_space *mapping,
        return ret;
 }
 
-static int ufs_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+static int ufs_write_end(const struct kiocb *iocb,
+                        struct address_space *mapping,
+                        loff_t pos, unsigned len, unsigned copied,
+                        struct folio *folio, void *fsdata)
 {
        int ret;
 
-       ret = generic_write_end(file, mapping, pos, len, copied, folio, fsdata);
+       ret = generic_write_end(iocb, mapping, pos, len, copied, folio, fsdata);
        if (ret < len)
                ufs_write_failed(mapping, pos + len);
        return ret;

diff --git a/fs/vboxsf/file.c b/fs/vboxsf/file.c
index b492794f8e9a72f8a93efbc35512b1dda9f8e11a..af01e3beaa42b751df482cdf17e75adcdaa5e6ee 100644 (file)
--- a/fs/vboxsf/file.c
+++ b/fs/vboxsf/file.c
@@ -300,12 +300,13 @@ static int vboxsf_writepages(struct address_space *mapping,
        return error;
 }
 
-static int vboxsf_write_end(struct file *file, struct address_space *mapping,
+static int vboxsf_write_end(const struct kiocb *iocb,
+                           struct address_space *mapping,
                            loff_t pos, unsigned int len, unsigned int copied,
                            struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;
-       struct vboxsf_handle *sf_handle = file->private_data;
+       struct vboxsf_handle *sf_handle = iocb->ki_filp->private_data;
        size_t from = offset_in_folio(folio, pos);
        u32 nwritten = len;
        u8 *buf;

diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 178eb90e9cf3068f55ebf260e5c58ced3b306c18..b16b88bfbc3e70a2de4efce26ebba1fcf1916ad3 100644 (file)
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -263,11 +263,11 @@ int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
 int __block_write_begin(struct folio *folio, loff_t pos, unsigned len,
                get_block_t *get_block);
 int block_write_end(loff_t pos, unsigned len, unsigned copied, struct folio *);
-int generic_write_end(struct file *, struct address_space *,
+int generic_write_end(const struct kiocb *, struct address_space *,
                                loff_t, unsigned len, unsigned copied,
                                struct folio *, void *);
 void folio_zero_new_buffers(struct folio *folio, size_t from, size_t to);
-int cont_write_begin(struct file *, struct address_space *, loff_t,
+int cont_write_begin(const struct kiocb *, struct address_space *, loff_t,
                        unsigned, struct folio **, void **,
                        get_block_t *, loff_t *);
 int generic_cont_expand_simple(struct inode *inode, loff_t size);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 09e3e80b0528a3c85903d63f08c499f289684ca6..df8c503100c4e53983ebbe29aba23e383d3632ec 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -444,10 +444,10 @@ struct address_space_operations {
 
        void (*readahead)(struct readahead_control *);
 
-       int (*write_begin)(struct file *, struct address_space *mapping,
+       int (*write_begin)(const struct kiocb *, struct address_space *mapping,
                                loff_t pos, unsigned len,
                                struct folio **foliop, void **fsdata);
-       int (*write_end)(struct file *, struct address_space *mapping,
+       int (*write_end)(const struct kiocb *, struct address_space *mapping,
                                loff_t pos, unsigned len, unsigned copied,
                                struct folio *folio, void *fsdata);
 
@@ -3598,9 +3598,10 @@ extern void simple_recursive_removal(struct dentry *,
 extern int noop_fsync(struct file *, loff_t, loff_t, int);
 extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
 extern int simple_empty(struct dentry *);
-extern int simple_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata);
+extern int simple_write_begin(const struct kiocb *iocb,
+                             struct address_space *mapping,
+                             loff_t pos, unsigned len,
+                             struct folio **foliop, void **fsdata);
 extern const struct address_space_operations ram_aops;
 extern int always_delete_dentry(const struct dentry *);
 extern struct inode *alloc_anon_inode(struct super_block *);

diff --git a/mm/filemap.c b/mm/filemap.c
index bada249b9fb7622d625b0e606fd9c69ecfff24c2..ba089d75fc86860e2c90d3cd9c8b9d1387542a24 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -4109,7 +4109,7 @@ retry:
                        break;
                }
 
-               status = a_ops->write_begin(file, mapping, pos, bytes,
+               status = a_ops->write_begin(iocb, mapping, pos, bytes,
                                                &folio, &fsdata);
                if (unlikely(status < 0))
                        break;
@@ -4130,7 +4130,7 @@ retry:
                copied = copy_folio_from_iter_atomic(folio, offset, bytes, i);
                flush_dcache_folio(folio);
 
-               status = a_ops->write_end(file, mapping, pos, bytes, copied,
+               status = a_ops->write_end(iocb, mapping, pos, bytes, copied,
                                                folio, fsdata);
                if (unlikely(status != copied)) {
                        iov_iter_revert(i, copied - max(status, 0L));

diff --git a/mm/shmem.c b/mm/shmem.c
index 0c5fb4ffa03aadf8397002f0a55f2e96b8eec5c7..2229425e1b298bc3ad787a9f2c3d238198b961d7 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -3266,9 +3266,9 @@ static const struct inode_operations shmem_symlink_inode_operations;
 static const struct inode_operations shmem_short_symlink_operations;
 
 static int
-shmem_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len,
-                       struct folio **foliop, void **fsdata)
+shmem_write_begin(const struct kiocb *iocb, struct address_space *mapping,
+                 loff_t pos, unsigned len,
+                 struct folio **foliop, void **fsdata)
 {
        struct inode *inode = mapping->host;
        struct shmem_inode_info *info = SHMEM_I(inode);
@@ -3300,9 +3300,9 @@ shmem_write_begin(struct file *file, struct address_space *mapping,
 }
 
 static int
-shmem_write_end(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned copied,
-                       struct folio *folio, void *fsdata)
+shmem_write_end(const struct kiocb *iocb, struct address_space *mapping,
+               loff_t pos, unsigned len, unsigned copied,
+               struct folio *folio, void *fsdata)
 {
        struct inode *inode = mapping->host;