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

Commit 6a1e7f77 authored by Christoph Lameter's avatar Christoph Lameter Committed by Linus Torvalds
Browse files

pageflags: convert to the use of new macros 



Replace explicit definitions of page flags through the use of macros.
Significantly reduces the size of the definitions and removes a lot of
opportunity for errors.  Additonal page flags can typically be generated with
a single line.

Signed-off-by: default avatarChristoph Lameter <clameter@sgi.com>
Cc: Andy Whitcroft <apw@shadowen.org>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Cc: Jeremy Fitzhardinge <jeremy@goop.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent f94a62e9

include/linux/page-flags.h

+68 −127
Original line number Diff line number Diff line
@@ -149,28 +149,58 @@ static inline int TestClearPage##uname(struct page *page) \ 
#define TESTSCFLAG(uname, lname)					\

	TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)



struct page;	/* forward declaration */



PAGEFLAG(Locked, locked) TESTSCFLAG(Locked, locked)

PAGEFLAG(Error, error)

PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)

PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)

PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)

PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)

__PAGEFLAG(Slab, slab)

PAGEFLAG(Checked, checked)		/* Used by some filesystems */

PAGEFLAG(Pinned, pinned)		/* Xen pinned pagetable */

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

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

	__SETPAGEFLAG(Private, private)



/*

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

 * risky: they bypass page accounting.

 */

TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)

__PAGEFLAG(Buddy, buddy)

PAGEFLAG(MappedToDisk, mappedtodisk)



/* PG_readahead is only used for file reads; PG_reclaim is only for writes */

PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)

PAGEFLAG(Readahead, readahead)		/* Reminder to do async read-ahead */



#ifdef CONFIG_HIGHMEM

/*

 * Manipulation of page state flags

 * Must use a macro here due to header dependency issues. page_zone() is not

 * available at this point.

 */

#define PageLocked(page)		\

		test_bit(PG_locked, &(page)->flags)

#define SetPageLocked(page)		\

		set_bit(PG_locked, &(page)->flags)

#define TestSetPageLocked(page)		\

		test_and_set_bit(PG_locked, &(page)->flags)

#define ClearPageLocked(page)		\

		clear_bit(PG_locked, &(page)->flags)

#define TestClearPageLocked(page)	\

		test_and_clear_bit(PG_locked, &(page)->flags)



#define PageError(page)		test_bit(PG_error, &(page)->flags)

#define SetPageError(page)	set_bit(PG_error, &(page)->flags)

#define ClearPageError(page)	clear_bit(PG_error, &(page)->flags)



#define PageReferenced(page)	test_bit(PG_referenced, &(page)->flags)

#define SetPageReferenced(page)	set_bit(PG_referenced, &(page)->flags)

#define ClearPageReferenced(page)	clear_bit(PG_referenced, &(page)->flags)

#define TestClearPageReferenced(page) test_and_clear_bit(PG_referenced, &(page)->flags)

#define PageHighMem(__p) is_highmem(page_zone(page))

#else

static inline int PageHighMem(struct page *page)

{

	return 0;

}

#endif



#ifdef CONFIG_SWAP

PAGEFLAG(SwapCache, swapcache)

#else

static inline int PageSwapCache(struct page *page)

{

	return 0;

}

#endif



#if (BITS_PER_LONG > 32)

PAGEFLAG(Uncached, uncached)

#endif



static inline int PageUptodate(struct page *page)

{
@@ -218,97 +248,37 @@ static inline void SetPageUptodate(struct page *page) 
#endif

}



#define ClearPageUptodate(page)	clear_bit(PG_uptodate, &(page)->flags)



#define PageDirty(page)		test_bit(PG_dirty, &(page)->flags)

#define SetPageDirty(page)	set_bit(PG_dirty, &(page)->flags)

#define TestSetPageDirty(page)	test_and_set_bit(PG_dirty, &(page)->flags)

#define ClearPageDirty(page)	clear_bit(PG_dirty, &(page)->flags)

#define __ClearPageDirty(page)	__clear_bit(PG_dirty, &(page)->flags)

#define TestClearPageDirty(page) test_and_clear_bit(PG_dirty, &(page)->flags)



#define PageLRU(page)		test_bit(PG_lru, &(page)->flags)

#define SetPageLRU(page)	set_bit(PG_lru, &(page)->flags)

#define ClearPageLRU(page)	clear_bit(PG_lru, &(page)->flags)

#define __ClearPageLRU(page)	__clear_bit(PG_lru, &(page)->flags)



#define PageActive(page)	test_bit(PG_active, &(page)->flags)

#define SetPageActive(page)	set_bit(PG_active, &(page)->flags)

#define ClearPageActive(page)	clear_bit(PG_active, &(page)->flags)

#define __ClearPageActive(page)	__clear_bit(PG_active, &(page)->flags)



#define PageSlab(page)		test_bit(PG_slab, &(page)->flags)

#define __SetPageSlab(page)	__set_bit(PG_slab, &(page)->flags)

#define __ClearPageSlab(page)	__clear_bit(PG_slab, &(page)->flags)



#ifdef CONFIG_HIGHMEM

#define PageHighMem(page)	is_highmem(page_zone(page))

#else

#define PageHighMem(page)	0 /* needed to optimize away at compile time */

#endif



#define PageChecked(page)	test_bit(PG_checked, &(page)->flags)

#define SetPageChecked(page)	set_bit(PG_checked, &(page)->flags)

#define ClearPageChecked(page)	clear_bit(PG_checked, &(page)->flags)



#define PagePinned(page)	test_bit(PG_pinned, &(page)->flags)

#define SetPagePinned(page)	set_bit(PG_pinned, &(page)->flags)

#define ClearPagePinned(page)	clear_bit(PG_pinned, &(page)->flags)



#define PageReserved(page)	test_bit(PG_reserved, &(page)->flags)

#define SetPageReserved(page)	set_bit(PG_reserved, &(page)->flags)

#define ClearPageReserved(page)	clear_bit(PG_reserved, &(page)->flags)

#define __ClearPageReserved(page)	__clear_bit(PG_reserved, &(page)->flags)

CLEARPAGEFLAG(Uptodate, uptodate)



#define SetPagePrivate(page)	set_bit(PG_private, &(page)->flags)

#define ClearPagePrivate(page)	clear_bit(PG_private, &(page)->flags)

#define PagePrivate(page)	test_bit(PG_private, &(page)->flags)

#define __SetPagePrivate(page)  __set_bit(PG_private, &(page)->flags)

#define __ClearPagePrivate(page) __clear_bit(PG_private, &(page)->flags)



/*

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

 * risky: they bypass page accounting.

 */

#define PageWriteback(page)	test_bit(PG_writeback, &(page)->flags)

#define TestSetPageWriteback(page) test_and_set_bit(PG_writeback,	\

							&(page)->flags)

#define TestClearPageWriteback(page) test_and_clear_bit(PG_writeback,	\

							&(page)->flags)



#define PageBuddy(page)		test_bit(PG_buddy, &(page)->flags)

#define __SetPageBuddy(page)	__set_bit(PG_buddy, &(page)->flags)

#define __ClearPageBuddy(page)	__clear_bit(PG_buddy, &(page)->flags)



#define PageMappedToDisk(page)	test_bit(PG_mappedtodisk, &(page)->flags)

#define SetPageMappedToDisk(page) set_bit(PG_mappedtodisk, &(page)->flags)

#define ClearPageMappedToDisk(page) clear_bit(PG_mappedtodisk, &(page)->flags)

extern void cancel_dirty_page(struct page *page, unsigned int account_size);



#define PageReadahead(page)	test_bit(PG_readahead, &(page)->flags)

#define SetPageReadahead(page)	set_bit(PG_readahead, &(page)->flags)

#define ClearPageReadahead(page) clear_bit(PG_readahead, &(page)->flags)

int test_clear_page_writeback(struct page *page);

int test_set_page_writeback(struct page *page);



#define PageReclaim(page)	test_bit(PG_reclaim, &(page)->flags)

#define SetPageReclaim(page)	set_bit(PG_reclaim, &(page)->flags)

#define ClearPageReclaim(page)	clear_bit(PG_reclaim, &(page)->flags)

#define TestClearPageReclaim(page) test_and_clear_bit(PG_reclaim, &(page)->flags)

static inline void set_page_writeback(struct page *page)

{

	test_set_page_writeback(page);

}



#define PageCompound(page)	test_bit(PG_compound, &(page)->flags)

#define __SetPageCompound(page)	__set_bit(PG_compound, &(page)->flags)

#define __ClearPageCompound(page) __clear_bit(PG_compound, &(page)->flags)

TESTPAGEFLAG(Compound, compound)

__PAGEFLAG(Head, compound)



/*

 * PG_reclaim is used in combination with PG_compound to mark the

 * head and tail of a compound page

 * head and tail of a compound page. This saves one page flag

 * but makes it impossible to use compound pages for the page cache.

 * The PG_reclaim bit would have to be used for reclaim or readahead

 * if compound pages enter the page cache.

 *

 * PG_compound & PG_reclaim	=> Tail page

 * PG_compound & ~PG_reclaim	=> Head page

 */



#define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))



#define PageTail(page)	(((page)->flags & PG_head_tail_mask)	\

				== PG_head_tail_mask)

static inline int PageTail(struct page *page)

{

	return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);

}



static inline void __SetPageTail(struct page *page)

{
@@ -320,34 +290,5 @@ static inline void __ClearPageTail(struct page *page) 
	page->flags &= ~PG_head_tail_mask;

}



#define PageHead(page)	(((page)->flags & PG_head_tail_mask)	\

				== (1L << PG_compound))

#define __SetPageHead(page)	__SetPageCompound(page)

#define __ClearPageHead(page)	__ClearPageCompound(page)



#ifdef CONFIG_SWAP

#define PageSwapCache(page)	test_bit(PG_swapcache, &(page)->flags)

#define SetPageSwapCache(page)	set_bit(PG_swapcache, &(page)->flags)

#define ClearPageSwapCache(page) clear_bit(PG_swapcache, &(page)->flags)

#else

#define PageSwapCache(page)	0

#endif



#define PageUncached(page)	test_bit(PG_uncached, &(page)->flags)

#define SetPageUncached(page)	set_bit(PG_uncached, &(page)->flags)

#define ClearPageUncached(page)	clear_bit(PG_uncached, &(page)->flags)



struct page;	/* forward declaration */



extern void cancel_dirty_page(struct page *page, unsigned int account_size);



int test_clear_page_writeback(struct page *page);

int test_set_page_writeback(struct page *page);



static inline void set_page_writeback(struct page *page)

{

	test_set_page_writeback(page);

}



#endif /* !__GENERATING_BOUNDS_H */

#endif	/* PAGE_FLAGS_H */