page-flags.h 19.9 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
#include <linux/bug.h>
10
#include <linux/mmdebug.h>
11
#ifndef __GENERATING_BOUNDS_H
12
#include <linux/mm_types.h>
13
#include <generated/bounds.h>
14
#endif /* !__GENERATING_BOUNDS_H */
A
Andrew Morton 已提交
15

L
Linus Torvalds 已提交
16 17 18 19 20 21
/*
 * 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 已提交
22 23 24
 * 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 已提交
25
 *
N
Nick Piggin 已提交
26 27 28 29 30 31 32 33 34
 * 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 已提交
35 36 37 38
 *
 * 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 已提交
39 40
 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and
 * file-backed pagecache (see mm/vmscan.c).
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51
 *
 * 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 已提交
52
 *
53 54 55
 * PG_hwpoison indicates that a page got corrupted in hardware and contains
 * data with incorrect ECC bits that triggered a machine check. Accessing is
 * not safe since it may cause another machine check. Don't touch!
L
Linus Torvalds 已提交
56 57 58 59
 */

/*
 * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
60 61 62 63 64 65 66
 * 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 |
67 68
 *  N-1           ^       0
 *               (NR_PAGEFLAGS)
69
 *
70 71 72
 * 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 已提交
73
 */
74 75 76 77 78 79 80 81 82 83 84 85 86
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 */
87
	PG_private_2,		/* If pagecache, has fs aux data */
88
	PG_writeback,		/* Page is under writeback */
89 90 91 92
#ifdef CONFIG_PAGEFLAGS_EXTENDED
	PG_head,		/* A head page */
	PG_tail,		/* A tail page */
#else
93
	PG_compound,		/* A compound page */
94
#endif
95 96 97
	PG_swapcache,		/* Swap page: swp_entry_t in private */
	PG_mappedtodisk,	/* Has blocks allocated on-disk */
	PG_reclaim,		/* To be reclaimed asap */
R
Rik van Riel 已提交
98
	PG_swapbacked,		/* Page is backed by RAM/swap */
L
Lee Schermerhorn 已提交
99
	PG_unevictable,		/* Page is "unevictable"  */
H
Hugh Dickins 已提交
100
#ifdef CONFIG_MMU
N
Nick Piggin 已提交
101
	PG_mlocked,		/* Page is vma mlocked */
L
Lee Schermerhorn 已提交
102
#endif
103
#ifdef CONFIG_ARCH_USES_PG_UNCACHED
104
	PG_uncached,		/* Page has been mapped as uncached */
105 106 107
#endif
#ifdef CONFIG_MEMORY_FAILURE
	PG_hwpoison,		/* hardware poisoned page. Don't touch */
A
Andrea Arcangeli 已提交
108 109 110
#endif
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
	PG_compound_lock,
111 112 113 114
#endif
#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
	PG_young,
	PG_idle,
A
Andrew Morton 已提交
115
#endif
116 117 118 119 120
	__NR_PAGEFLAGS,

	/* Filesystems */
	PG_checked = PG_owner_priv_1,

121 122 123 124 125 126
	/* 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 */

127
	/* XEN */
128
	/* Pinned in Xen as a read-only pagetable page. */
129
	PG_pinned = PG_owner_priv_1,
130
	/* Pinned as part of domain save (see xen_mm_pin_all()). */
131
	PG_savepinned = PG_dirty,
132 133
	/* Has a grant mapping of another (foreign) domain's page. */
	PG_foreign = PG_owner_priv_1,
134

135 136
	/* SLOB */
	PG_slob_free = PG_private,
137
};
L
Linus Torvalds 已提交
138

139 140
#ifndef __GENERATING_BOUNDS_H

141 142 143 144
/*
 * Macros to create function definitions for page flags
 */
#define TESTPAGEFLAG(uname, lname)					\
145
static inline int Page##uname(const struct page *page)			\
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
			{ 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); }

172 173 174
#define __TESTCLEARFLAG(uname, lname)					\
static inline int __TestClearPage##uname(struct page *page)		\
		{ return __test_and_clear_bit(PG_##lname, &page->flags); }
175 176 177 178 179 180 181 182 183 184

#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)

#define TESTSCFLAG(uname, lname)					\
	TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)

185 186 187
#define TESTPAGEFLAG_FALSE(uname)					\
static inline int Page##uname(const struct page *page) { return 0; }

188 189 190 191 192 193 194 195 196
#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) {  }

197 198 199
#define TESTSETFLAG_FALSE(uname)					\
static inline int TestSetPage##uname(struct page *page) { return 0; }

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

203 204 205
#define __TESTCLEARFLAG_FALSE(uname)					\
static inline int __TestClearPage##uname(struct page *page) { return 0; }

206 207 208 209 210 211
#define PAGEFLAG_FALSE(uname) TESTPAGEFLAG_FALSE(uname)			\
	SETPAGEFLAG_NOOP(uname) CLEARPAGEFLAG_NOOP(uname)

#define TESTSCFLAG_FALSE(uname)						\
	TESTSETFLAG_FALSE(uname) TESTCLEARFLAG_FALSE(uname)

212 213
struct page;	/* forward declaration */

214
TESTPAGEFLAG(Locked, locked)
215
PAGEFLAG(Error, error) TESTCLEARFLAG(Error, error)
216
PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
217
	__SETPAGEFLAG(Referenced, referenced)
218 219 220
PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)
PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)
L
Lee Schermerhorn 已提交
221
	TESTCLEARFLAG(Active, active)
222
__PAGEFLAG(Slab, slab)
223 224 225
PAGEFLAG(Checked, checked)		/* Used by some filesystems */
PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)	/* Xen */
PAGEFLAG(SavePinned, savepinned);			/* Xen */
226
PAGEFLAG(Foreign, foreign);				/* Xen */
227
PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
R
Rik van Riel 已提交
228
PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
229
	__SETPAGEFLAG(SwapBacked, swapbacked)
230

231 232
__PAGEFLAG(SlobFree, slob_free)

233 234 235 236 237 238 239 240 241 242
/*
 * 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)

243 244 245 246 247 248 249
/*
 * Only test-and-set exist for PG_writeback.  The unconditional operators are
 * risky: they bypass page accounting.
 */
TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
PAGEFLAG(MappedToDisk, mappedtodisk)

250
/* PG_readahead is only used for reads; PG_reclaim is only for writes */
251
PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
252
PAGEFLAG(Readahead, reclaim) TESTCLEARFLAG(Readahead, reclaim)
253 254

#ifdef CONFIG_HIGHMEM
L
Linus Torvalds 已提交
255
/*
256 257
 * Must use a macro here due to header dependency issues. page_zone() is not
 * available at this point.
L
Linus Torvalds 已提交
258
 */
259
#define PageHighMem(__p) is_highmem(page_zone(__p))
260
#else
261
PAGEFLAG_FALSE(HighMem)
262 263 264 265 266
#endif

#ifdef CONFIG_SWAP
PAGEFLAG(SwapCache, swapcache)
#else
267
PAGEFLAG_FALSE(SwapCache)
268 269
#endif

L
Lee Schermerhorn 已提交
270 271
PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
	TESTCLEARFLAG(Unevictable, unevictable)
N
Nick Piggin 已提交
272

H
Hugh Dickins 已提交
273
#ifdef CONFIG_MMU
N
Nick Piggin 已提交
274
PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
275
	TESTSCFLAG(Mlocked, mlocked) __TESTCLEARFLAG(Mlocked, mlocked)
L
Lee Schermerhorn 已提交
276
#else
277 278
PAGEFLAG_FALSE(Mlocked) __CLEARPAGEFLAG_NOOP(Mlocked)
	TESTSCFLAG_FALSE(Mlocked) __TESTCLEARFLAG_FALSE(Mlocked)
L
Lee Schermerhorn 已提交
279 280
#endif

281
#ifdef CONFIG_ARCH_USES_PG_UNCACHED
282
PAGEFLAG(Uncached, uncached)
283
#else
284
PAGEFLAG_FALSE(Uncached)
285
#endif
L
Linus Torvalds 已提交
286

287 288
#ifdef CONFIG_MEMORY_FAILURE
PAGEFLAG(HWPoison, hwpoison)
W
Wu Fengguang 已提交
289
TESTSCFLAG(HWPoison, hwpoison)
290 291 292 293 294 295
#define __PG_HWPOISON (1UL << PG_hwpoison)
#else
PAGEFLAG_FALSE(HWPoison)
#define __PG_HWPOISON 0
#endif

296 297 298 299 300 301 302
#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
TESTPAGEFLAG(Young, young)
SETPAGEFLAG(Young, young)
TESTCLEARFLAG(Young, young)
PAGEFLAG(Idle, idle)
#endif

303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
/*
 * On an anonymous page mapped into a user virtual memory area,
 * page->mapping points to its anon_vma, not to a struct address_space;
 * with the PAGE_MAPPING_ANON bit set to distinguish it.  See rmap.h.
 *
 * On an anonymous page in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
 * the PAGE_MAPPING_KSM bit may be set along with the PAGE_MAPPING_ANON bit;
 * and then page->mapping points, not to an anon_vma, but to a private
 * structure which KSM associates with that merged page.  See ksm.h.
 *
 * PAGE_MAPPING_KSM without PAGE_MAPPING_ANON is currently never used.
 *
 * Please note that, confusingly, "page_mapping" refers to the inode
 * address_space which maps the page from disk; whereas "page_mapped"
 * refers to user virtual address space into which the page is mapped.
 */
#define PAGE_MAPPING_ANON	1
#define PAGE_MAPPING_KSM	2
#define PAGE_MAPPING_FLAGS	(PAGE_MAPPING_ANON | PAGE_MAPPING_KSM)

static inline int PageAnon(struct page *page)
{
	return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
}

#ifdef CONFIG_KSM
/*
 * A KSM page is one of those write-protected "shared pages" or "merged pages"
 * which KSM maps into multiple mms, wherever identical anonymous page content
 * is found in VM_MERGEABLE vmas.  It's a PageAnon page, pointing not to any
 * anon_vma, but to that page's node of the stable tree.
 */
static inline int PageKsm(struct page *page)
{
	return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
				(PAGE_MAPPING_ANON | PAGE_MAPPING_KSM);
}
#else
TESTPAGEFLAG_FALSE(Ksm)
#endif

W
Wu Fengguang 已提交
344 345
u64 stable_page_flags(struct page *page);

N
Nick Piggin 已提交
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
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);
}

370 371
static inline void SetPageUptodate(struct page *page)
{
N
Nick Piggin 已提交
372 373 374 375 376 377 378 379 380
	/*
	 * 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.
	 */
	smp_wmb();
	set_bit(PG_uptodate, &(page)->flags);
}

381
CLEARPAGEFLAG(Uptodate, uptodate)
L
Linus Torvalds 已提交
382

383
int test_clear_page_writeback(struct page *page);
384 385 386 387 388 389
int __test_set_page_writeback(struct page *page, bool keep_write);

#define test_set_page_writeback(page)			\
	__test_set_page_writeback(page, false)
#define test_set_page_writeback_keepwrite(page)	\
	__test_set_page_writeback(page, true)
L
Linus Torvalds 已提交
390

391 392 393 394
static inline void set_page_writeback(struct page *page)
{
	test_set_page_writeback(page);
}
L
Linus Torvalds 已提交
395

396 397 398 399 400
static inline void set_page_writeback_keepwrite(struct page *page)
{
	test_set_page_writeback_keepwrite(page);
}

401 402 403 404 405
#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
406 407 408
 * generally not used in hot code paths except arch/powerpc/mm/init_64.c
 * and arch/powerpc/kvm/book3s_64_vio_hv.c which use it to detect huge pages
 * and avoid handling those in real mode.
409
 */
A
Andrea Arcangeli 已提交
410
__PAGEFLAG(Head, head) CLEARPAGEFLAG(Head, head)
411 412 413 414 415 416 417
__PAGEFLAG(Tail, tail)

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

}
A
Andrea Arcangeli 已提交
418 419 420 421 422 423 424
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
static inline void ClearPageCompound(struct page *page)
{
	BUG_ON(!PageHead(page));
	ClearPageHead(page);
}
#endif
425 426 427

#define PG_head_mask ((1L << PG_head))

428 429 430 431 432 433 434
#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.
 */
435
TESTPAGEFLAG(Compound, compound)
436
__SETPAGEFLAG(Head, compound)  __CLEARPAGEFLAG(Head, compound)
L
Linus Torvalds 已提交
437

438
/*
439
 * PG_reclaim is used in combination with PG_compound to mark the
440 441 442 443
 * 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.
444 445 446
 *
 * PG_compound & PG_reclaim	=> Tail page
 * PG_compound & ~PG_reclaim	=> Head page
447
 */
448
#define PG_head_mask ((1L << PG_compound))
449 450
#define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))

451 452 453 454 455
static inline int PageHead(struct page *page)
{
	return ((page->flags & PG_head_tail_mask) == PG_head_mask);
}

456 457 458 459
static inline int PageTail(struct page *page)
{
	return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
}
460 461 462 463 464 465 466 467 468 469 470

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

A
Andrea Arcangeli 已提交
471 472 473 474 475 476 477 478
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
static inline void ClearPageCompound(struct page *page)
{
	BUG_ON((page->flags & PG_head_tail_mask) != (1 << PG_compound));
	clear_bit(PG_compound, &page->flags);
}
#endif

479
#endif /* !PAGEFLAGS_EXTENDED */
480

481 482 483
#ifdef CONFIG_HUGETLB_PAGE
int PageHuge(struct page *page);
int PageHeadHuge(struct page *page);
484
bool page_huge_active(struct page *page);
485 486 487
#else
TESTPAGEFLAG_FALSE(Huge)
TESTPAGEFLAG_FALSE(HeadHuge)
488 489 490 491 492

static inline bool page_huge_active(struct page *page)
{
	return 0;
}
493 494
#endif

495

496
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
497 498 499 500 501 502 503 504 505 506
/*
 * PageHuge() only returns true for hugetlbfs pages, but not for
 * normal or transparent huge pages.
 *
 * PageTransHuge() returns true for both transparent huge and
 * hugetlbfs pages, but not normal pages. PageTransHuge() can only be
 * called only in the core VM paths where hugetlbfs pages can't exist.
 */
static inline int PageTransHuge(struct page *page)
{
507
	VM_BUG_ON_PAGE(PageTail(page), page);
508 509 510
	return PageHead(page);
}

511 512 513 514 515
/*
 * PageTransCompound returns true for both transparent huge pages
 * and hugetlbfs pages, so it should only be called when it's known
 * that hugetlbfs pages aren't involved.
 */
516 517 518 519
static inline int PageTransCompound(struct page *page)
{
	return PageCompound(page);
}
520

521 522 523 524 525 526 527 528 529 530
/*
 * PageTransTail returns true for both transparent huge pages
 * and hugetlbfs pages, so it should only be called when it's known
 * that hugetlbfs pages aren't involved.
 */
static inline int PageTransTail(struct page *page)
{
	return PageTail(page);
}

531
#else
532 533 534 535 536 537

static inline int PageTransHuge(struct page *page)
{
	return 0;
}

538 539 540 541
static inline int PageTransCompound(struct page *page)
{
	return 0;
}
542 543 544 545 546

static inline int PageTransTail(struct page *page)
{
	return 0;
}
547 548
#endif

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
/*
 * PageBuddy() indicate that the page is free and in the buddy system
 * (see mm/page_alloc.c).
 *
 * PAGE_BUDDY_MAPCOUNT_VALUE must be <= -2 but better not too close to
 * -2 so that an underflow of the page_mapcount() won't be mistaken
 * for a genuine PAGE_BUDDY_MAPCOUNT_VALUE. -128 can be created very
 * efficiently by most CPU architectures.
 */
#define PAGE_BUDDY_MAPCOUNT_VALUE (-128)

static inline int PageBuddy(struct page *page)
{
	return atomic_read(&page->_mapcount) == PAGE_BUDDY_MAPCOUNT_VALUE;
}

static inline void __SetPageBuddy(struct page *page)
{
	VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
	atomic_set(&page->_mapcount, PAGE_BUDDY_MAPCOUNT_VALUE);
}

static inline void __ClearPageBuddy(struct page *page)
{
	VM_BUG_ON_PAGE(!PageBuddy(page), page);
	atomic_set(&page->_mapcount, -1);
}

#define PAGE_BALLOON_MAPCOUNT_VALUE (-256)

static inline int PageBalloon(struct page *page)
{
	return atomic_read(&page->_mapcount) == PAGE_BALLOON_MAPCOUNT_VALUE;
}

static inline void __SetPageBalloon(struct page *page)
{
	VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
	atomic_set(&page->_mapcount, PAGE_BALLOON_MAPCOUNT_VALUE);
}

static inline void __ClearPageBalloon(struct page *page)
{
	VM_BUG_ON_PAGE(!PageBalloon(page), page);
	atomic_set(&page->_mapcount, -1);
}

596 597 598 599 600 601
/*
 * If network-based swap is enabled, sl*b must keep track of whether pages
 * were allocated from pfmemalloc reserves.
 */
static inline int PageSlabPfmemalloc(struct page *page)
{
602
	VM_BUG_ON_PAGE(!PageSlab(page), page);
603 604 605 606 607
	return PageActive(page);
}

static inline void SetPageSlabPfmemalloc(struct page *page)
{
608
	VM_BUG_ON_PAGE(!PageSlab(page), page);
609 610 611 612 613
	SetPageActive(page);
}

static inline void __ClearPageSlabPfmemalloc(struct page *page)
{
614
	VM_BUG_ON_PAGE(!PageSlab(page), page);
615 616 617 618 619
	__ClearPageActive(page);
}

static inline void ClearPageSlabPfmemalloc(struct page *page)
{
620
	VM_BUG_ON_PAGE(!PageSlab(page), page);
621 622 623
	ClearPageActive(page);
}

H
Hugh Dickins 已提交
624
#ifdef CONFIG_MMU
625 626
#define __PG_MLOCKED		(1 << PG_mlocked)
#else
N
Nick Piggin 已提交
627
#define __PG_MLOCKED		0
L
Lee Schermerhorn 已提交
628 629
#endif

A
Andrea Arcangeli 已提交
630 631 632 633 634 635
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
#define __PG_COMPOUND_LOCK		(1 << PG_compound_lock)
#else
#define __PG_COMPOUND_LOCK		0
#endif

636 637 638 639
/*
 * Flags checked when a page is freed.  Pages being freed should not have
 * these flags set.  It they are, there is a problem.
 */
640
#define PAGE_FLAGS_CHECK_AT_FREE \
641 642
	(1 << PG_lru	 | 1 << PG_locked    | \
	 1 << PG_private | 1 << PG_private_2 | \
A
Andrea Arcangeli 已提交
643
	 1 << PG_writeback | 1 << PG_reserved | \
644
	 1 << PG_slab	 | 1 << PG_swapcache | 1 << PG_active | \
645
	 1 << PG_unevictable | __PG_MLOCKED | \
A
Andrea Arcangeli 已提交
646
	 __PG_COMPOUND_LOCK)
647 648 649

/*
 * Flags checked when a page is prepped for return by the page allocator.
650
 * Pages being prepped should not have these flags set.  It they are set,
651
 * there has been a kernel bug or struct page corruption.
652 653 654
 *
 * __PG_HWPOISON is exceptional because it needs to be kept beyond page's
 * alloc-free cycle to prevent from reusing the page.
655
 */
656 657
#define PAGE_FLAGS_CHECK_AT_PREP	\
	(((1 << NR_PAGEFLAGS) - 1) & ~__PG_HWPOISON)
658

659 660
#define PAGE_FLAGS_PRIVATE				\
	(1 << PG_private | 1 << PG_private_2)
661 662 663 664 665 666 667
/**
 * 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.
 */
668 669 670 671 672 673
static inline int page_has_private(struct page *page)
{
	return !!(page->flags & PAGE_FLAGS_PRIVATE);
}

#endif /* !__GENERATING_BOUNDS_H */
674

L
Linus Torvalds 已提交
675
#endif	/* PAGE_FLAGS_H */