Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 266cf658 authored by David Howells's avatar David Howells
Browse files

FS-Cache: Recruit a page flags for cache management 



Recruit a page flag to aid in cache management.  The following extra flag is
defined:

 (1) PG_fscache (PG_private_2)

     The marked page is backed by a local cache and is pinning resources in the
     cache driver.

If PG_fscache is set, then things that checked for PG_private will now also
check for that.  This includes things like truncation and page invalidation.
The function page_has_private() had been added to make the checks for both
PG_private and PG_private_2 at the same time.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Acked-by: default avatarSteve Dickson <steved@redhat.com>
Acked-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
Acked-by: default avatarRik van Riel <riel@redhat.com>
Acked-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
Tested-by: default avatarDaire Byrne <Daire.Byrne@framestore.com>
parent 03fb3d2a

fs/splice.c

+2 −1
Original line number Diff line number Diff line
@@ -59,7 +59,8 @@ static int page_cache_pipe_buf_steal(struct pipe_inode_info *pipe, 
		 */

		wait_on_page_writeback(page);



		if (PagePrivate(page) && !try_to_release_page(page, GFP_KERNEL))

		if (page_has_private(page) &&

		    !try_to_release_page(page, GFP_KERNEL))

			goto out_unlock;



		/*

include/linux/page-flags.h

+33 −5
Original line number Diff line number Diff line
@@ -82,6 +82,7 @@ enum pageflags { 
	PG_arch_1,

	PG_reserved,

	PG_private,		/* If pagecache, has fs-private data */

	PG_private_2,		/* If pagecache, has fs aux data */

	PG_writeback,		/* Page is under writeback */

#ifdef CONFIG_PAGEFLAGS_EXTENDED

	PG_head,		/* A head page */
@@ -108,6 +109,12 @@ enum pageflags { 
	/* Filesystems */

	PG_checked = PG_owner_priv_1,



	/* Two page bits are conscripted by FS-Cache to maintain local caching

	 * state.  These bits are set on pages belonging to the netfs's inodes

	 * when those inodes are being locally cached.

	 */

	PG_fscache = PG_private_2,	/* page backed by cache */



	/* XEN */

	PG_pinned = PG_owner_priv_1,

	PG_savepinned = PG_dirty,
@@ -194,8 +201,6 @@ PAGEFLAG(Checked, checked) /* Used by some filesystems */ 
PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)	/* Xen */

PAGEFLAG(SavePinned, savepinned);			/* Xen */

PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)

PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private)

	__SETPAGEFLAG(Private, private)

PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)



__PAGEFLAG(SlobPage, slob_page)
@@ -204,6 +209,16 @@ __PAGEFLAG(SlobFree, slob_free) 
__PAGEFLAG(SlubFrozen, slub_frozen)

__PAGEFLAG(SlubDebug, slub_debug)



/*

 * Private page markings that may be used by the filesystem that owns the page

 * for its own purposes.

 * - PG_private and PG_private_2 cause releasepage() and co to be invoked

 */

PAGEFLAG(Private, private) __SETPAGEFLAG(Private, private)

	__CLEARPAGEFLAG(Private, private)

PAGEFLAG(Private2, private_2) TESTSCFLAG(Private2, private_2)

PAGEFLAG(OwnerPriv1, owner_priv_1) TESTCLEARFLAG(OwnerPriv1, owner_priv_1)



/*

 * Only test-and-set exist for PG_writeback.  The unconditional operators are

 * risky: they bypass page accounting.
@@ -384,7 +399,8 @@ static inline void __ClearPageTail(struct page *page) 
 * these flags set.  It they are, there is a problem.

 */

#define PAGE_FLAGS_CHECK_AT_FREE \

	(1 << PG_lru   | 1 << PG_private   | 1 << PG_locked | \

	(1 << PG_lru	 | 1 << PG_locked    | \

	 1 << PG_private | 1 << PG_private_2 | \

	 1 << PG_buddy	 | 1 << PG_writeback | 1 << PG_reserved | \

	 1 << PG_slab	 | 1 << PG_swapcache | 1 << PG_active | \

	 __PG_UNEVICTABLE | __PG_MLOCKED)
@@ -397,4 +413,16 @@ static inline void __ClearPageTail(struct page *page) 
#define PAGE_FLAGS_CHECK_AT_PREP	((1 << NR_PAGEFLAGS) - 1)



#endif /* !__GENERATING_BOUNDS_H */



/**

 * page_has_private - Determine if page has private stuff

 * @page: The page to be checked

 *

 * Determine if a page has private stuff, indicating that release routines

 * should be invoked upon it.

 */

#define page_has_private(page)			\

	((page)->flags & ((1 << PG_private) |	\

			  (1 << PG_private_2)))



#endif	/* PAGE_FLAGS_H */

mm/filemap.c

+3 −0
Original line number Diff line number Diff line
@@ -2463,6 +2463,9 @@ EXPORT_SYMBOL(generic_file_aio_write); 
 * (presumably at page->private).  If the release was successful, return `1'.

 * Otherwise return zero.

 *

 * This may also be called if PG_fscache is set on a page, indicating that the

 * page is known to the local caching routines.

 *

 * The @gfp_mask argument specifies whether I/O may be performed to release

 * this page (__GFP_IO), and whether the call may block (__GFP_WAIT & __GFP_FS).

 *

mm/migrate.c

+5 −5
Original line number Diff line number Diff line
@@ -250,7 +250,7 @@ void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd, 
 * The number of remaining references must be:

 * 1 for anonymous pages without a mapping

 * 2 for pages with a mapping

 * 3 for pages with a mapping and PagePrivate set.

 * 3 for pages with a mapping and PagePrivate/PagePrivate2 set.

 */

static int migrate_page_move_mapping(struct address_space *mapping,

		struct page *newpage, struct page *page)
@@ -270,7 +270,7 @@ static int migrate_page_move_mapping(struct address_space *mapping, 
	pslot = radix_tree_lookup_slot(&mapping->page_tree,

 					page_index(page));



	expected_count = 2 + !!PagePrivate(page);

	expected_count = 2 + !!page_has_private(page);

	if (page_count(page) != expected_count ||

			(struct page *)radix_tree_deref_slot(pslot) != page) {

		spin_unlock_irq(&mapping->tree_lock);
@@ -386,7 +386,7 @@ EXPORT_SYMBOL(fail_migrate_page); 


/*

 * Common logic to directly migrate a single page suitable for

 * pages that do not use PagePrivate.

 * pages that do not use PagePrivate/PagePrivate2.

 *

 * Pages are locked upon entry and exit.

 */
@@ -522,7 +522,7 @@ static int fallback_migrate_page(struct address_space *mapping, 
	 * Buffers may be managed in a filesystem specific way.

	 * We must have no buffers or drop them.

	 */

	if (PagePrivate(page) &&

	if (page_has_private(page) &&

	    !try_to_release_page(page, GFP_KERNEL))

		return -EAGAIN;
@@ -655,7 +655,7 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private, 
	 * free the metadata, so the page can be freed.

	 */

	if (!page->mapping) {

		if (!PageAnon(page) && PagePrivate(page)) {

		if (!PageAnon(page) && page_has_private(page)) {

			/*

			 * Go direct to try_to_free_buffers() here because

			 * a) that's what try_to_release_page() would do anyway

mm/readahead.c

+5 −4
Original line number Diff line number Diff line
@@ -33,14 +33,15 @@ EXPORT_SYMBOL_GPL(file_ra_state_init); 


/*

 * see if a page needs releasing upon read_cache_pages() failure

 * - the caller of read_cache_pages() may have set PG_private before calling,

 *   such as the NFS fs marking pages that are cached locally on disk, thus we

 *   need to give the fs a chance to clean up in the event of an error

 * - the caller of read_cache_pages() may have set PG_private or PG_fscache

 *   before calling, such as the NFS fs marking pages that are cached locally

 *   on disk, thus we need to give the fs a chance to clean up in the event of

 *   an error

 */

static void read_cache_pages_invalidate_page(struct address_space *mapping,

					     struct page *page)

{

	if (PagePrivate(page)) {

	if (page_has_private(page)) {

		if (!trylock_page(page))

			BUG();

		page->mapping = mapping;