mm/filemap: Add filemap_get_folio

filemap_get_folio() is a replacement for find_get_page().
Turn pagecache_get_page() into a wrapper around __filemap_get_folio().
Remove find_lock_head() as this use case is now covered by
filemap_get_folio().

Reduces overall kernel size by 209 bytes.  __filemap_get_folio() is
316 bytes shorter than pagecache_get_page() was, but the new
pagecache_get_page() wrapper is 99 bytes.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: David Howells <dhowells@redhat.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>

diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index a10eb6d..401a903 100644 (file)
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -302,8 +302,26 @@ pgoff_t page_cache_prev_miss(struct address_space *mapping,
 #define FGP_HEAD               0x00000080
 #define FGP_ENTRY              0x00000100
 
-struct page *pagecache_get_page(struct address_space *mapping, pgoff_t offset,
-               int fgp_flags, gfp_t cache_gfp_mask);
+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,
+               int fgp_flags, gfp_t gfp);
+
+/**
+ * filemap_get_folio - Find and get a folio.
+ * @mapping: The address_space to search.
+ * @index: The page index.
+ *
+ * Looks up the page cache entry at @mapping & @index.  If a folio is
+ * present, it is returned with an increased refcount.
+ *
+ * Otherwise, %NULL is returned.
+ */
+static inline struct folio *filemap_get_folio(struct address_space *mapping,
+                                       pgoff_t index)
+{
+       return __filemap_get_folio(mapping, index, 0, 0);
+}
 
 /**
  * find_get_page - find and get a page reference
@@ -346,25 +364,6 @@ static inline struct page *find_lock_page(struct address_space *mapping,
        return pagecache_get_page(mapping, index, FGP_LOCK, 0);
 }
 
-/**
- * find_lock_head - Locate, pin and lock a pagecache page.
- * @mapping: The address_space to search.
- * @index: The page index.
- *
- * Looks up the page cache entry at @mapping & @index.  If there is a
- * page cache page, its head page is returned locked and with an increased
- * refcount.
- *
- * Context: May sleep.
- * Return: A struct page which is !PageTail, or %NULL if there is no page
- * in the cache for this index.
- */
-static inline struct page *find_lock_head(struct address_space *mapping,
-                                       pgoff_t index)
-{
-       return pagecache_get_page(mapping, index, FGP_LOCK | FGP_HEAD, 0);
-}
-
 /**
  * find_or_create_page - locate or add a pagecache page
  * @mapping: the page's address_space

diff --git a/mm/filemap.c b/mm/filemap.c
index 5c99fd9..de4cc1b 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -1849,93 +1849,89 @@ out:
 }
 
 /**
- * pagecache_get_page - Find and get a reference to a page.
+ * __filemap_get_folio - Find and get a reference to a folio.
  * @mapping: The address_space to search.
  * @index: The page index.
- * @fgp_flags: %FGP flags modify how the page is returned.
- * @gfp_mask: Memory allocation flags to use if %FGP_CREAT is specified.
+ * @fgp_flags: %FGP flags modify how the folio is returned.
+ * @gfp: Memory allocation flags to use if %FGP_CREAT is specified.
  *
  * Looks up the page cache entry at @mapping & @index.
  *
  * @fgp_flags can be zero or more of these flags:
  *
- * * %FGP_ACCESSED - The page will be marked accessed.
- * * %FGP_LOCK - The page is returned locked.
- * * %FGP_HEAD - If the page is present and a THP, return the head page
- *   rather than the exact page specified by the index.
+ * * %FGP_ACCESSED - The folio will be marked accessed.
+ * * %FGP_LOCK - The folio is returned locked.
  * * %FGP_ENTRY - If there is a shadow / swap / DAX entry, return it
- *   instead of allocating a new page to replace it.
+ *   instead of allocating a new folio to replace it.
  * * %FGP_CREAT - If no page is present then a new page is allocated using
- *   @gfp_mask and added to the page cache and the VM's LRU list.
+ *   @gfp and added to the page cache and the VM's LRU list.
  *   The page is returned locked and with an increased refcount.
  * * %FGP_FOR_MMAP - The caller wants to do its own locking dance if the
  *   page is already in cache.  If the page was allocated, unlock it before
  *   returning so the caller can do the same dance.
- * * %FGP_WRITE - The page will be written
- * * %FGP_NOFS - __GFP_FS will get cleared in gfp mask
- * * %FGP_NOWAIT - Don't get blocked by page lock
+ * * %FGP_WRITE - The page will be written to by the caller.
+ * * %FGP_NOFS - __GFP_FS will get cleared in gfp.
+ * * %FGP_NOWAIT - Don't get blocked by page lock.
  *
  * If %FGP_LOCK or %FGP_CREAT are specified then the function may sleep even
  * if the %GFP flags specified for %FGP_CREAT are atomic.
  *
  * If there is a page cache page, it is returned with an increased refcount.
  *
- * Return: The found page or %NULL otherwise.
+ * Return: The found folio or %NULL otherwise.
  */
-struct page *pagecache_get_page(struct address_space *mapping, pgoff_t index,
-               int fgp_flags, gfp_t gfp_mask)
+struct folio *__filemap_get_folio(struct address_space *mapping, pgoff_t index,
+               int fgp_flags, gfp_t gfp)
 {
-       struct page *page;
+       struct folio *folio;
 
 repeat:
-       page = mapping_get_entry(mapping, index);
-       if (xa_is_value(page)) {
+       folio = mapping_get_entry(mapping, index);
+       if (xa_is_value(folio)) {
                if (fgp_flags & FGP_ENTRY)
-                       return page;
-               page = NULL;
+                       return folio;
+               folio = NULL;
        }
-       if (!page)
+       if (!folio)
                goto no_page;
 
        if (fgp_flags & FGP_LOCK) {
                if (fgp_flags & FGP_NOWAIT) {
-                       if (!trylock_page(page)) {
-                               put_page(page);
+                       if (!folio_trylock(folio)) {
+                               folio_put(folio);
                                return NULL;
                        }
                } else {
-                       lock_page(page);
+                       folio_lock(folio);
                }
 
                /* Has the page been truncated? */
-               if (unlikely(page->mapping != mapping)) {
-                       unlock_page(page);
-                       put_page(page);
+               if (unlikely(folio->mapping != mapping)) {
+                       folio_unlock(folio);
+                       folio_put(folio);
                        goto repeat;
                }
-               VM_BUG_ON_PAGE(!thp_contains(page, index), page);
+               VM_BUG_ON_FOLIO(!folio_contains(folio, index), folio);
        }
 
        if (fgp_flags & FGP_ACCESSED)
-               mark_page_accessed(page);
+               folio_mark_accessed(folio);
        else if (fgp_flags & FGP_WRITE) {
                /* Clear idle flag for buffer write */
-               if (page_is_idle(page))
-                       clear_page_idle(page);
+               if (folio_test_idle(folio))
+                       folio_clear_idle(folio);
        }
-       if (!(fgp_flags & FGP_HEAD))
-               page = find_subpage(page, index);
 
 no_page:
-       if (!page && (fgp_flags & FGP_CREAT)) {
+       if (!folio && (fgp_flags & FGP_CREAT)) {
                int err;
                if ((fgp_flags & FGP_WRITE) && mapping_can_writeback(mapping))
-                       gfp_mask |= __GFP_WRITE;
+                       gfp |= __GFP_WRITE;
                if (fgp_flags & FGP_NOFS)
-                       gfp_mask &= ~__GFP_FS;
+                       gfp &= ~__GFP_FS;
 
-               page = __page_cache_alloc(gfp_mask);
-               if (!page)
+               folio = filemap_alloc_folio(gfp, 0);
+               if (!folio)
                        return NULL;
 
                if (WARN_ON_ONCE(!(fgp_flags & (FGP_LOCK | FGP_FOR_MMAP))))
@@ -1943,27 +1939,27 @@ no_page:
 
                /* Init accessed so avoid atomic mark_page_accessed later */
                if (fgp_flags & FGP_ACCESSED)
-                       __SetPageReferenced(page);
+                       __folio_set_referenced(folio);
 
-               err = add_to_page_cache_lru(page, mapping, index, gfp_mask);
+               err = filemap_add_folio(mapping, folio, index, gfp);
                if (unlikely(err)) {
-                       put_page(page);
-                       page = NULL;
+                       folio_put(folio);
+                       folio = NULL;
                        if (err == -EEXIST)
                                goto repeat;
                }
 
                /*
-                * add_to_page_cache_lru locks the page, and for mmap we expect
-                * an unlocked page.
+                * filemap_add_folio locks the page, and for mmap
+                * we expect an unlocked page.
                 */
-               if (page && (fgp_flags & FGP_FOR_MMAP))
-                       unlock_page(page);
+               if (folio && (fgp_flags & FGP_FOR_MMAP))
+                       folio_unlock(folio);
        }
 
-       return page;
+       return folio;
 }
-EXPORT_SYMBOL(pagecache_get_page);
+EXPORT_SYMBOL(__filemap_get_folio);
 
 static inline struct page *find_get_entry(struct xa_state *xas, pgoff_t max,
                xa_mark_t mark)

diff --git a/mm/folio-compat.c b/mm/folio-compat.c
index 6b19bc4..e833e68 100644 (file)
--- a/mm/folio-compat.c
+++ b/mm/folio-compat.c
@@ -115,3 +115,15 @@ int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
        return filemap_add_folio(mapping, page_folio(page), index, gfp);
 }
 EXPORT_SYMBOL(add_to_page_cache_lru);
+
+struct page *pagecache_get_page(struct address_space *mapping, pgoff_t index,
+               int fgp_flags, gfp_t gfp)
+{
+       struct folio *folio;
+
+       folio = __filemap_get_folio(mapping, index, fgp_flags, gfp);
+       if ((fgp_flags & FGP_HEAD) || !folio || xa_is_value(folio))
+               return &folio->page;
+       return folio_file_page(folio, index);
+}
+EXPORT_SYMBOL(pagecache_get_page);