fs: Add FGP_WRITEBEGIN

This particular combination of flags is used by most filesystems
in their ->write_begin method, although it does find use in a
few other places.  Before folios, it warranted its own function
(grab_cache_page_write_begin()), but I think that just having specialised
flags is enough.  It certainly helps the few places that have been
converted from grab_cache_page_write_begin() to __filemap_get_folio().

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Link: https://lore.kernel.org/r/20230324180129.1220691-2-willy@infradead.org
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c
index 2de9829aed63bfa631a4a529c64eb4b449f1f1af..0cb361f0a4fe3892f3cc59394d1ce6cc07a1b99f 100644 (file)
--- a/fs/ext4/move_extent.c
+++ b/fs/ext4/move_extent.c
@@ -126,7 +126,6 @@ mext_folio_double_lock(struct inode *inode1, struct inode *inode2,
 {
        struct address_space *mapping[2];
        unsigned int flags;
-       unsigned fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE;
 
        BUG_ON(!inode1 || !inode2);
        if (inode1 < inode2) {
@@ -139,14 +138,14 @@ mext_folio_double_lock(struct inode *inode1, struct inode *inode2,
        }
 
        flags = memalloc_nofs_save();
-       folio[0] = __filemap_get_folio(mapping[0], index1, fgp_flags,
+       folio[0] = __filemap_get_folio(mapping[0], index1, FGP_WRITEBEGIN,
                        mapping_gfp_mask(mapping[0]));
        if (!folio[0]) {
                memalloc_nofs_restore(flags);
                return -ENOMEM;
        }
 
-       folio[1] = __filemap_get_folio(mapping[1], index2, fgp_flags,
+       folio[1] = __filemap_get_folio(mapping[1], index2, FGP_WRITEBEGIN,
                        mapping_gfp_mask(mapping[1]));
        memalloc_nofs_restore(flags);
        if (!folio[1]) {

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 6f4c97a6d7e9dcdaa5aa9a06159d33d91c0aa9f6..10a203515583542d231c17104f2b871fabee7cce 100644 (file)
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -467,7 +467,7 @@ EXPORT_SYMBOL_GPL(iomap_is_partially_uptodate);
  */
 struct folio *iomap_get_folio(struct iomap_iter *iter, loff_t pos)
 {
-       unsigned fgp = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE | FGP_NOFS;
+       unsigned fgp = FGP_WRITEBEGIN | FGP_NOFS;
        struct folio *folio;
 
        if (iter->flags & IOMAP_NOWAIT)

diff --git a/fs/netfs/buffered_read.c b/fs/netfs/buffered_read.c
index 7679a68e8193070bdf22e3554c102e25bf6621e2..e3d754a9e1b0873d40ab30e1949a75b14c619561 100644 (file)
--- a/fs/netfs/buffered_read.c
+++ b/fs/netfs/buffered_read.c
@@ -341,14 +341,13 @@ int netfs_write_begin(struct netfs_inode *ctx,
 {
        struct netfs_io_request *rreq;
        struct folio *folio;
-       unsigned int fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE;
        pgoff_t index = pos >> PAGE_SHIFT;
        int ret;
 
        DEFINE_READAHEAD(ractl, file, NULL, mapping, index);
 
 retry:
-       folio = __filemap_get_folio(mapping, index, fgp_flags,
+       folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,
                                    mapping_gfp_mask(mapping));
        if (!folio)
                return -ENOMEM;

diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 893625eacab9faf9a9e4203c7c8aa92fb474aaa3..2474cbc30712a8237e83ecd9770d6aefb8c181c2 100644 (file)
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -306,15 +306,6 @@ static bool nfs_want_read_modify_write(struct file *file, struct folio *folio,
        return false;
 }
 
-static struct folio *
-nfs_folio_grab_cache_write_begin(struct address_space *mapping, pgoff_t index)
-{
-       unsigned fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE;
-
-       return __filemap_get_folio(mapping, index, fgp_flags,
-                                  mapping_gfp_mask(mapping));
-}
-
 /*
  * This does the "real" work of the write. We must allocate and lock the
  * page to be sent back to the generic routine, which then copies the
@@ -335,7 +326,8 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping,
                file, mapping->host->i_ino, len, (long long) pos);
 
 start:
-       folio = nfs_folio_grab_cache_write_begin(mapping, pos >> PAGE_SHIFT);
+       folio = __filemap_get_folio(mapping, pos >> PAGE_SHIFT, FGP_WRITEBEGIN,
+                                   mapping_gfp_mask(mapping));
        if (!folio)
                return -ENOMEM;
        *pagep = &folio->page;

diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 0acb8e1fb7afdc92b8d17c1216294d02f6fa19d9..51b75b89730edaccd2a1c97a3017a9be21277f9c 100644 (file)
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -507,6 +507,8 @@ pgoff_t page_cache_prev_miss(struct address_space *mapping,
 #define FGP_ENTRY              0x00000080
 #define FGP_STABLE             0x00000100
 
+#define FGP_WRITEBEGIN         (FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE)
+
 struct folio *__filemap_get_folio(struct address_space *mapping, pgoff_t index,
                int fgp_flags, gfp_t gfp);
 struct page *pagecache_get_page(struct address_space *mapping, pgoff_t index,

diff --git a/mm/folio-compat.c b/mm/folio-compat.c
index cabcd1de9ecbb206ad7f95e3744c4b2dabf5e92b..a71523a06ccd1f5a29bb5e51394231c14956a25d 100644 (file)
--- a/mm/folio-compat.c
+++ b/mm/folio-compat.c
@@ -106,9 +106,7 @@ EXPORT_SYMBOL(pagecache_get_page);
 struct page *grab_cache_page_write_begin(struct address_space *mapping,
                                        pgoff_t index)
 {
-       unsigned fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE;
-
-       return pagecache_get_page(mapping, index, fgp_flags,
+       return pagecache_get_page(mapping, index, FGP_WRITEBEGIN,
                        mapping_gfp_mask(mapping));
 }
 EXPORT_SYMBOL(grab_cache_page_write_begin);