UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

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>
This commit is contained in:
Matthew Wilcox (Oracle) 2021-03-08 11:45:35 -05:00
parent bca65eeab1
commit 3f0c6a07fe
3 changed files with 76 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
include/linux/pagemap.h
View File

@ -302,8 +302,26 @@ pgoff_t page_cache_prev_miss(struct address_space *mapping,
#define FGP_HEAD 0x00000080 #define FGP_HEAD 0x00000080
#define FGP_ENTRY 0x00000100 #define FGP_ENTRY 0x00000100
struct page *pagecache_get_page(struct address_space *mapping, pgoff_t offset, struct folio *__filemap_get_folio(struct address_space *mapping, pgoff_t index,
int fgp_flags, gfp_t cache_gfp_mask); 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 * 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); 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 * find_or_create_page - locate or add a pagecache page
* @mapping: the page's address_space * @mapping: the page's address_space

92
mm/filemap.c
View File

@ -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. * @mapping: The address_space to search.
* @index: The page index. * @index: The page index.
* @fgp_flags: %FGP flags modify how the page is returned. * @fgp_flags: %FGP flags modify how the folio is returned.
* @gfp_mask: Memory allocation flags to use if %FGP_CREAT is specified. * @gfp: Memory allocation flags to use if %FGP_CREAT is specified.
* *
* Looks up the page cache entry at @mapping & @index. * Looks up the page cache entry at @mapping & @index.
* *
* @fgp_flags can be zero or more of these flags: * @fgp_flags can be zero or more of these flags:
* *
* * %FGP_ACCESSED - The page will be marked accessed. * * %FGP_ACCESSED - The folio will be marked accessed.
* * %FGP_LOCK - The page is returned locked. * * %FGP_LOCK - The folio 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_ENTRY - If there is a shadow / swap / DAX entry, return it * * %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 * * %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. * The page is returned locked and with an increased refcount.
* * %FGP_FOR_MMAP - The caller wants to do its own locking dance if the * * %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 * page is already in cache. If the page was allocated, unlock it before
* returning so the caller can do the same dance. * returning so the caller can do the same dance.
* * %FGP_WRITE - The page will be written * * %FGP_WRITE - The page will be written to by the caller.
* * %FGP_NOFS - __GFP_FS will get cleared in gfp mask * * %FGP_NOFS - __GFP_FS will get cleared in gfp.
* * %FGP_NOWAIT - Don't get blocked by page lock * * %FGP_NOWAIT - Don't get blocked by page lock.
* *
* If %FGP_LOCK or %FGP_CREAT are specified then the function may sleep even * 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 the %GFP flags specified for %FGP_CREAT are atomic.
* *
* If there is a page cache page, it is returned with an increased refcount. * 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, struct folio *__filemap_get_folio(struct address_space *mapping, pgoff_t index,
int fgp_flags, gfp_t gfp_mask) int fgp_flags, gfp_t gfp)
{ {
struct page *page; struct folio *folio;
repeat: repeat:
page = mapping_get_entry(mapping, index); folio = mapping_get_entry(mapping, index);
if (xa_is_value(page)) { if (xa_is_value(folio)) {
if (fgp_flags & FGP_ENTRY) if (fgp_flags & FGP_ENTRY)
return page; return folio;
page = NULL; folio = NULL;
} }
if (!page) if (!folio)
goto no_page; goto no_page;
if (fgp_flags & FGP_LOCK) { if (fgp_flags & FGP_LOCK) {
if (fgp_flags & FGP_NOWAIT) { if (fgp_flags & FGP_NOWAIT) {
if (!trylock_page(page)) { if (!folio_trylock(folio)) {
put_page(page); folio_put(folio);
return NULL; return NULL;
} }
} else { } else {
lock_page(page); folio_lock(folio);
} }
/* Has the page been truncated? */ /* Has the page been truncated? */
if (unlikely(page->mapping != mapping)) { if (unlikely(folio->mapping != mapping)) {
unlock_page(page); folio_unlock(folio);
put_page(page); folio_put(folio);
goto repeat; 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) if (fgp_flags & FGP_ACCESSED)
mark_page_accessed(page); folio_mark_accessed(folio);
else if (fgp_flags & FGP_WRITE) { else if (fgp_flags & FGP_WRITE) {
/* Clear idle flag for buffer write */ /* Clear idle flag for buffer write */
if (page_is_idle(page)) if (folio_test_idle(folio))
clear_page_idle(page); folio_clear_idle(folio);
} }
if (!(fgp_flags & FGP_HEAD))
page = find_subpage(page, index);
no_page: no_page:
if (!page && (fgp_flags & FGP_CREAT)) { if (!folio && (fgp_flags & FGP_CREAT)) {
int err; int err;
if ((fgp_flags & FGP_WRITE) && mapping_can_writeback(mapping)) if ((fgp_flags & FGP_WRITE) && mapping_can_writeback(mapping))
gfp_mask |= __GFP_WRITE; gfp |= __GFP_WRITE;
if (fgp_flags & FGP_NOFS) if (fgp_flags & FGP_NOFS)
gfp_mask &= ~__GFP_FS; gfp &= ~__GFP_FS;
page = __page_cache_alloc(gfp_mask); folio = filemap_alloc_folio(gfp, 0);
if (!page) if (!folio)
return NULL; return NULL;
if (WARN_ON_ONCE(!(fgp_flags & (FGP_LOCK | FGP_FOR_MMAP)))) 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 */ /* Init accessed so avoid atomic mark_page_accessed later */
if (fgp_flags & FGP_ACCESSED) 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)) { if (unlikely(err)) {
put_page(page); folio_put(folio);
page = NULL; folio = NULL;
if (err == -EEXIST) if (err == -EEXIST)
goto repeat; goto repeat;
} }
/* /*
* add_to_page_cache_lru locks the page, and for mmap we expect * filemap_add_folio locks the page, and for mmap
* an unlocked page. * we expect an unlocked page.
*/ */
if (page && (fgp_flags & FGP_FOR_MMAP)) if (folio && (fgp_flags & FGP_FOR_MMAP))
unlock_page(page); 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, static inline struct page *find_get_entry(struct xa_state *xas, pgoff_t max,
xa_mark_t mark) xa_mark_t mark)

12
mm/folio-compat.c
View File

@ -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); return filemap_add_folio(mapping, page_folio(page), index, gfp);
} }
EXPORT_SYMBOL(add_to_page_cache_lru); 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);