mirror of
https://github.com/adulau/aha.git
synced 2024-12-29 12:16:20 +00:00
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: Christoph 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: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Christoph Lameter
Linus Torvalds
parent
f94a62e910
commit
6a1e7f777f
1 changed files with 79 additions and 138 deletions
|
|
@ -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)
|
||||
|
||||
/*
|
||||
* Manipulation of page state flags
|
||||
* Only test-and-set exist for PG_writeback. The unconditional operators are
|
||||
* risky: they bypass page accounting.
|
||||
*/
|
||||
#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)
|
||||
TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
|
||||
__PAGEFLAG(Buddy, buddy)
|
||||
PAGEFLAG(MappedToDisk, mappedtodisk)
|
||||
|
||||
#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)
|
||||
/* 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 */
|
||||
|
||||
#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)
|
||||
#ifdef CONFIG_HIGHMEM
|
||||
/*
|
||||
* Must use a macro here due to header dependency issues. page_zone() is not
|
||||
* available at this point.
|
||||
*/
|
||||
#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,126 +248,7 @@ 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)
|
||||
|
||||
#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)
|
||||
|
||||
#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)
|
||||
|
||||
#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)
|
||||
|
||||
#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)
|
||||
|
||||
/*
|
||||
* PG_reclaim is used in combination with PG_compound to mark the
|
||||
* head and tail of a compound page
|
||||
*
|
||||
* 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 void __SetPageTail(struct page *page)
|
||||
{
|
||||
page->flags |= PG_head_tail_mask;
|
||||
}
|
||||
|
||||
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 */
|
||||
CLEARPAGEFLAG(Uptodate, uptodate)
|
||||
|
||||
extern void cancel_dirty_page(struct page *page, unsigned int account_size);
|
||||
|
||||
|
|
@ -349,5 +260,35 @@ static inline void set_page_writeback(struct page *page)
|
|||
test_set_page_writeback(page);
|
||||
}
|
||||
|
||||
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. 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))
|
||||
|
||||
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)
|
||||
{
|
||||
page->flags |= PG_head_tail_mask;
|
||||
}
|
||||
|
||||
static inline void __ClearPageTail(struct page *page)
|
||||
{
|
||||
page->flags &= ~PG_head_tail_mask;
|
||||
}
|
||||
|
||||
#endif /* !__GENERATING_BOUNDS_H */
|
||||
#endif /* PAGE_FLAGS_H */
|
||||
|
|
|
|||
Loading…
Reference in a new issue