page-flags.h 11.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 * Macros for manipulating and testing page->flags
 */

#ifndef PAGE_FLAGS_H
#define PAGE_FLAGS_H

A
Andrew Morton 已提交
8
#include <linux/types.h>
9
#ifndef __GENERATING_BOUNDS_H
10
#include <linux/mm_types.h>
11 12
#include <linux/bounds.h>
#endif /* !__GENERATING_BOUNDS_H */
A
Andrew Morton 已提交
13

L
Linus Torvalds 已提交
14 15 16 17 18 19
/*
 * Various page->flags bits:
 *
 * PG_reserved is set for special pages, which can never be swapped out. Some
 * of them might not even exist (eg empty_bad_page)...
 *
N
Nick Piggin 已提交
20 21 22
 * The PG_private bitflag is set on pagecache pages if they contain filesystem
 * specific data (which is normally at page->private). It can be used by
 * private allocations for its own usage.
L
Linus Torvalds 已提交
23
 *
N
Nick Piggin 已提交
24 25 26 27 28 29 30 31 32
 * During initiation of disk I/O, PG_locked is set. This bit is set before I/O
 * and cleared when writeback _starts_ or when read _completes_. PG_writeback
 * is set before writeback starts and cleared when it finishes.
 *
 * PG_locked also pins a page in pagecache, and blocks truncation of the file
 * while it is held.
 *
 * page_waitqueue(page) is a wait queue of all tasks waiting for the page
 * to become unlocked.
L
Linus Torvalds 已提交
33 34 35 36
 *
 * PG_uptodate tells whether the page's contents is valid.  When a read
 * completes, the page becomes uptodate, unless a disk I/O error happened.
 *
N
Nick Piggin 已提交
37 38
 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and
 * file-backed pagecache (see mm/vmscan.c).
L
Linus Torvalds 已提交
39 40 41 42 43 44 45 46 47 48 49
 *
 * PG_error is set to indicate that an I/O error occurred on this page.
 *
 * PG_arch_1 is an architecture specific page state bit.  The generic code
 * guarantees that this bit is cleared for a page when it first is entered into
 * the page cache.
 *
 * PG_highmem pages are not permanently mapped into the kernel virtual address
 * space, they need to be kmapped separately for doing IO on the pages.  The
 * struct page (these bits with information) are always mapped into kernel
 * address space...
N
Nick Piggin 已提交
50 51 52 53
 *
 * PG_buddy is set to indicate that the page is free and in the buddy system
 * (see mm/page_alloc.c).
 *
L
Linus Torvalds 已提交
54 55 56 57
 */

/*
 * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
58 59 60 61 62 63 64
 * locked- and dirty-page accounting.
 *
 * The page flags field is split into two parts, the main flags area
 * which extends from the low bits upwards, and the fields area which
 * extends from the high bits downwards.
 *
 *  | FIELD | ... | FLAGS |
65 66
 *  N-1           ^       0
 *               (NR_PAGEFLAGS)
67
 *
68 69 70
 * The fields area is reserved for fields mapping zone, node (for NUMA) and
 * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
 * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
L
Linus Torvalds 已提交
71
 */
72 73 74 75 76 77 78 79 80 81 82 83 84 85
enum pageflags {
	PG_locked,		/* Page is locked. Don't touch. */
	PG_error,
	PG_referenced,
	PG_uptodate,
	PG_dirty,
	PG_lru,
	PG_active,
	PG_slab,
	PG_owner_priv_1,	/* Owner use. If pagecache, fs may use*/
	PG_arch_1,
	PG_reserved,
	PG_private,		/* If pagecache, has fs-private data */
	PG_writeback,		/* Page is under writeback */
86 87 88 89
#ifdef CONFIG_PAGEFLAGS_EXTENDED
	PG_head,		/* A head page */
	PG_tail,		/* A tail page */
#else
90
	PG_compound,		/* A compound page */
91
#endif
92 93 94 95
	PG_swapcache,		/* Swap page: swp_entry_t in private */
	PG_mappedtodisk,	/* Has blocks allocated on-disk */
	PG_reclaim,		/* To be reclaimed asap */
	PG_buddy,		/* Page is free, on buddy lists */
R
Rik van Riel 已提交
96
	PG_swapbacked,		/* Page is backed by RAM/swap */
L
Lee Schermerhorn 已提交
97 98 99
#ifdef CONFIG_UNEVICTABLE_LRU
	PG_unevictable,		/* Page is "unevictable"  */
#endif
100 101
#ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
	PG_uncached,		/* Page has been mapped as uncached */
A
Andrew Morton 已提交
102
#endif
103 104 105 106 107 108 109 110
	__NR_PAGEFLAGS,

	/* Filesystems */
	PG_checked = PG_owner_priv_1,

	/* XEN */
	PG_pinned = PG_owner_priv_1,
	PG_savepinned = PG_dirty,
111

112 113 114 115
	/* SLOB */
	PG_slob_page = PG_active,
	PG_slob_free = PG_private,

116 117 118
	/* SLUB */
	PG_slub_frozen = PG_active,
	PG_slub_debug = PG_error,
119
};
L
Linus Torvalds 已提交
120

121 122
#ifndef __GENERATING_BOUNDS_H

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
/*
 * Macros to create function definitions for page flags
 */
#define TESTPAGEFLAG(uname, lname)					\
static inline int Page##uname(struct page *page) 			\
			{ return test_bit(PG_##lname, &page->flags); }

#define SETPAGEFLAG(uname, lname)					\
static inline void SetPage##uname(struct page *page)			\
			{ set_bit(PG_##lname, &page->flags); }

#define CLEARPAGEFLAG(uname, lname)					\
static inline void ClearPage##uname(struct page *page)			\
			{ clear_bit(PG_##lname, &page->flags); }

#define __SETPAGEFLAG(uname, lname)					\
static inline void __SetPage##uname(struct page *page)			\
			{ __set_bit(PG_##lname, &page->flags); }

#define __CLEARPAGEFLAG(uname, lname)					\
static inline void __ClearPage##uname(struct page *page)		\
			{ __clear_bit(PG_##lname, &page->flags); }

#define TESTSETFLAG(uname, lname)					\
static inline int TestSetPage##uname(struct page *page)			\
		{ return test_and_set_bit(PG_##lname, &page->flags); }

#define TESTCLEARFLAG(uname, lname)					\
static inline int TestClearPage##uname(struct page *page)		\
		{ return test_and_clear_bit(PG_##lname, &page->flags); }


#define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)		\
	SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)

#define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)		\
	__SETPAGEFLAG(uname, lname)  __CLEARPAGEFLAG(uname, lname)

161 162 163 164
#define PAGEFLAG_FALSE(uname) 						\
static inline int Page##uname(struct page *page) 			\
			{ return 0; }

165 166 167
#define TESTSCFLAG(uname, lname)					\
	TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)

168 169 170 171 172 173 174 175 176 177 178 179
#define SETPAGEFLAG_NOOP(uname)						\
static inline void SetPage##uname(struct page *page) {  }

#define CLEARPAGEFLAG_NOOP(uname)					\
static inline void ClearPage##uname(struct page *page) {  }

#define __CLEARPAGEFLAG_NOOP(uname)					\
static inline void __ClearPage##uname(struct page *page) {  }

#define TESTCLEARFLAG_FALSE(uname)					\
static inline int TestClearPage##uname(struct page *page) { return 0; }

180 181
struct page;	/* forward declaration */

N
Nick Piggin 已提交
182
TESTPAGEFLAG(Locked, locked)
183 184 185 186 187
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)
L
Lee Schermerhorn 已提交
188
	TESTCLEARFLAG(Active, active)
189
__PAGEFLAG(Slab, slab)
190 191 192
PAGEFLAG(Checked, checked)		/* Used by some filesystems */
PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)	/* Xen */
PAGEFLAG(SavePinned, savepinned);			/* Xen */
193 194 195
PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private)
	__SETPAGEFLAG(Private, private)
R
Rik van Riel 已提交
196
PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
197

198 199 200
__PAGEFLAG(SlobPage, slob_page)
__PAGEFLAG(SlobFree, slob_free)

201 202 203
__PAGEFLAG(SlubFrozen, slub_frozen)
__PAGEFLAG(SlubDebug, slub_debug)

204 205 206 207 208 209 210 211 212 213
/*
 * 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)
214
PAGEFLAG(Readahead, reclaim)		/* Reminder to do async read-ahead */
215 216

#ifdef CONFIG_HIGHMEM
L
Linus Torvalds 已提交
217
/*
218 219
 * Must use a macro here due to header dependency issues. page_zone() is not
 * available at this point.
L
Linus Torvalds 已提交
220
 */
221
#define PageHighMem(__p) is_highmem(page_zone(__p))
222
#else
223
PAGEFLAG_FALSE(HighMem)
224 225 226 227 228
#endif

#ifdef CONFIG_SWAP
PAGEFLAG(SwapCache, swapcache)
#else
229
PAGEFLAG_FALSE(SwapCache)
230 231
#endif

L
Lee Schermerhorn 已提交
232 233 234 235 236 237 238 239 240
#ifdef CONFIG_UNEVICTABLE_LRU
PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
	TESTCLEARFLAG(Unevictable, unevictable)
#else
PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable)
	SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable)
	__CLEARPAGEFLAG_NOOP(Unevictable)
#endif

241
#ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
242
PAGEFLAG(Uncached, uncached)
243
#else
244
PAGEFLAG_FALSE(Uncached)
245
#endif
L
Linus Torvalds 已提交
246

N
Nick Piggin 已提交
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
static inline int PageUptodate(struct page *page)
{
	int ret = test_bit(PG_uptodate, &(page)->flags);

	/*
	 * Must ensure that the data we read out of the page is loaded
	 * _after_ we've loaded page->flags to check for PageUptodate.
	 * We can skip the barrier if the page is not uptodate, because
	 * we wouldn't be reading anything from it.
	 *
	 * See SetPageUptodate() for the other side of the story.
	 */
	if (ret)
		smp_rmb();

	return ret;
}

static inline void __SetPageUptodate(struct page *page)
{
	smp_wmb();
	__set_bit(PG_uptodate, &(page)->flags);
}

271 272
static inline void SetPageUptodate(struct page *page)
{
N
Nick Piggin 已提交
273
#ifdef CONFIG_S390
274
	if (!test_and_set_bit(PG_uptodate, &page->flags))
275
		page_clear_dirty(page);
276
#else
N
Nick Piggin 已提交
277 278 279 280 281 282 283 284 285 286
	/*
	 * Memory barrier must be issued before setting the PG_uptodate bit,
	 * so that all previous stores issued in order to bring the page
	 * uptodate are actually visible before PageUptodate becomes true.
	 *
	 * s390 doesn't need an explicit smp_wmb here because the test and
	 * set bit already provides full barriers.
	 */
	smp_wmb();
	set_bit(PG_uptodate, &(page)->flags);
L
Linus Torvalds 已提交
287
#endif
N
Nick Piggin 已提交
288 289
}

290
CLEARPAGEFLAG(Uptodate, uptodate)
L
Linus Torvalds 已提交
291

292
extern void cancel_dirty_page(struct page *page, unsigned int account_size);
F
Fengguang Wu 已提交
293

294 295
int test_clear_page_writeback(struct page *page);
int test_set_page_writeback(struct page *page);
L
Linus Torvalds 已提交
296

297 298 299 300
static inline void set_page_writeback(struct page *page)
{
	test_set_page_writeback(page);
}
L
Linus Torvalds 已提交
301

302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
#ifdef CONFIG_PAGEFLAGS_EXTENDED
/*
 * System with lots of page flags available. This allows separate
 * flags for PageHead() and PageTail() checks of compound pages so that bit
 * tests can be used in performance sensitive paths. PageCompound is
 * generally not used in hot code paths.
 */
__PAGEFLAG(Head, head)
__PAGEFLAG(Tail, tail)

static inline int PageCompound(struct page *page)
{
	return page->flags & ((1L << PG_head) | (1L << PG_tail));

}
#else
/*
 * Reduce page flag use as much as possible by overlapping
 * compound page flags with the flags used for page cache pages. Possible
 * because PageCompound is always set for compound pages and not for
 * pages on the LRU and/or pagecache.
 */
324 325
TESTPAGEFLAG(Compound, compound)
__PAGEFLAG(Head, compound)
L
Linus Torvalds 已提交
326

327
/*
328
 * PG_reclaim is used in combination with PG_compound to mark the
329 330 331 332
 * 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.
333 334 335
 *
 * PG_compound & PG_reclaim	=> Tail page
 * PG_compound & ~PG_reclaim	=> Head page
336
 */
337 338
#define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))

339 340 341 342
static inline int PageTail(struct page *page)
{
	return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
}
343 344 345 346 347 348 349 350 351 352 353

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;
}

354
#endif /* !PAGEFLAGS_EXTENDED */
355

L
Lee Schermerhorn 已提交
356 357 358 359 360 361
#ifdef CONFIG_UNEVICTABLE_LRU
#define __PG_UNEVICTABLE (1 << PG_unevictable)
#else
#define __PG_UNEVICTABLE 0
#endif

362 363
#define PAGE_FLAGS	(1 << PG_lru   | 1 << PG_private   | 1 << PG_locked | \
			 1 << PG_buddy | 1 << PG_writeback | \
L
Lee Schermerhorn 已提交
364 365
			 1 << PG_slab  | 1 << PG_swapcache | 1 << PG_active | \
			 __PG_UNEVICTABLE)
366 367 368 369 370

/*
 * Flags checked in bad_page().  Pages on the free list should not have
 * these flags set.  It they are, there is a problem.
 */
R
Rik van Riel 已提交
371 372
#define PAGE_FLAGS_CLEAR_WHEN_BAD (PAGE_FLAGS | \
		1 << PG_reclaim | 1 << PG_dirty | 1 << PG_swapbacked)
373 374 375 376 377 378 379 380 381 382 383 384

/*
 * Flags checked when a page is freed.  Pages being freed should not have
 * these flags set.  It they are, there is a problem.
 */
#define PAGE_FLAGS_CHECK_AT_FREE (PAGE_FLAGS | 1 << PG_reserved)

/*
 * Flags checked when a page is prepped for return by the page allocator.
 * Pages being prepped should not have these flags set.  It they are, there
 * is a problem.
 */
R
Rik van Riel 已提交
385 386
#define PAGE_FLAGS_CHECK_AT_PREP (PAGE_FLAGS | \
		1 << PG_reserved | 1 << PG_dirty | 1 << PG_swapbacked)
387

388
#endif /* !__GENERATING_BOUNDS_H */
L
Linus Torvalds 已提交
389
#endif	/* PAGE_FLAGS_H */