]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - include/linux/page-flags.h
page-flags: trivial cleanup for PageTrans* helpers
[mirror_ubuntu-bionic-kernel.git] / include / linux / page-flags.h
CommitLineData
1da177e4
LT
1/*
2 * Macros for manipulating and testing page->flags
3 */
4
5#ifndef PAGE_FLAGS_H
6#define PAGE_FLAGS_H
7
f886ed44 8#include <linux/types.h>
187f1882 9#include <linux/bug.h>
072bb0aa 10#include <linux/mmdebug.h>
9223b419 11#ifndef __GENERATING_BOUNDS_H
6d777953 12#include <linux/mm_types.h>
01fc0ac1 13#include <generated/bounds.h>
9223b419 14#endif /* !__GENERATING_BOUNDS_H */
f886ed44 15
1da177e4
LT
16/*
17 * Various page->flags bits:
18 *
19 * PG_reserved is set for special pages, which can never be swapped out. Some
20 * of them might not even exist (eg empty_bad_page)...
21 *
da6052f7
NP
22 * The PG_private bitflag is set on pagecache pages if they contain filesystem
23 * specific data (which is normally at page->private). It can be used by
24 * private allocations for its own usage.
1da177e4 25 *
da6052f7
NP
26 * During initiation of disk I/O, PG_locked is set. This bit is set before I/O
27 * and cleared when writeback _starts_ or when read _completes_. PG_writeback
28 * is set before writeback starts and cleared when it finishes.
29 *
30 * PG_locked also pins a page in pagecache, and blocks truncation of the file
31 * while it is held.
32 *
33 * page_waitqueue(page) is a wait queue of all tasks waiting for the page
34 * to become unlocked.
1da177e4
LT
35 *
36 * PG_uptodate tells whether the page's contents is valid. When a read
37 * completes, the page becomes uptodate, unless a disk I/O error happened.
38 *
da6052f7
NP
39 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and
40 * file-backed pagecache (see mm/vmscan.c).
1da177e4
LT
41 *
42 * PG_error is set to indicate that an I/O error occurred on this page.
43 *
44 * PG_arch_1 is an architecture specific page state bit. The generic code
45 * guarantees that this bit is cleared for a page when it first is entered into
46 * the page cache.
47 *
48 * PG_highmem pages are not permanently mapped into the kernel virtual address
49 * space, they need to be kmapped separately for doing IO on the pages. The
50 * struct page (these bits with information) are always mapped into kernel
51 * address space...
da6052f7 52 *
d466f2fc
AK
53 * PG_hwpoison indicates that a page got corrupted in hardware and contains
54 * data with incorrect ECC bits that triggered a machine check. Accessing is
55 * not safe since it may cause another machine check. Don't touch!
1da177e4
LT
56 */
57
58/*
59 * Don't use the *_dontuse flags. Use the macros. Otherwise you'll break
91fc8ab3
AW
60 * locked- and dirty-page accounting.
61 *
62 * The page flags field is split into two parts, the main flags area
63 * which extends from the low bits upwards, and the fields area which
64 * extends from the high bits downwards.
65 *
66 * | FIELD | ... | FLAGS |
9223b419
CL
67 * N-1 ^ 0
68 * (NR_PAGEFLAGS)
91fc8ab3 69 *
9223b419
CL
70 * The fields area is reserved for fields mapping zone, node (for NUMA) and
71 * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
72 * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
1da177e4 73 */
e2683181
CL
74enum pageflags {
75 PG_locked, /* Page is locked. Don't touch. */
76 PG_error,
77 PG_referenced,
78 PG_uptodate,
79 PG_dirty,
80 PG_lru,
81 PG_active,
82 PG_slab,
83 PG_owner_priv_1, /* Owner use. If pagecache, fs may use*/
e2683181
CL
84 PG_arch_1,
85 PG_reserved,
86 PG_private, /* If pagecache, has fs-private data */
266cf658 87 PG_private_2, /* If pagecache, has fs aux data */
e2683181 88 PG_writeback, /* Page is under writeback */
e20b8cca 89 PG_head, /* A head page */
e2683181
CL
90 PG_swapcache, /* Swap page: swp_entry_t in private */
91 PG_mappedtodisk, /* Has blocks allocated on-disk */
92 PG_reclaim, /* To be reclaimed asap */
b2e18538 93 PG_swapbacked, /* Page is backed by RAM/swap */
894bc310 94 PG_unevictable, /* Page is "unevictable" */
af8e3354 95#ifdef CONFIG_MMU
b291f000 96 PG_mlocked, /* Page is vma mlocked */
894bc310 97#endif
46cf98cd 98#ifdef CONFIG_ARCH_USES_PG_UNCACHED
602c4d11 99 PG_uncached, /* Page has been mapped as uncached */
d466f2fc
AK
100#endif
101#ifdef CONFIG_MEMORY_FAILURE
102 PG_hwpoison, /* hardware poisoned page. Don't touch */
e9da73d6
AA
103#endif
104#ifdef CONFIG_TRANSPARENT_HUGEPAGE
105 PG_compound_lock,
33c3fc71
VD
106#endif
107#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
108 PG_young,
109 PG_idle,
f886ed44 110#endif
0cad47cf
AW
111 __NR_PAGEFLAGS,
112
113 /* Filesystems */
114 PG_checked = PG_owner_priv_1,
115
266cf658
DH
116 /* Two page bits are conscripted by FS-Cache to maintain local caching
117 * state. These bits are set on pages belonging to the netfs's inodes
118 * when those inodes are being locally cached.
119 */
120 PG_fscache = PG_private_2, /* page backed by cache */
121
0cad47cf 122 /* XEN */
d8ac3dd4 123 /* Pinned in Xen as a read-only pagetable page. */
0cad47cf 124 PG_pinned = PG_owner_priv_1,
d8ac3dd4 125 /* Pinned as part of domain save (see xen_mm_pin_all()). */
0cad47cf 126 PG_savepinned = PG_dirty,
d8ac3dd4
JH
127 /* Has a grant mapping of another (foreign) domain's page. */
128 PG_foreign = PG_owner_priv_1,
8a38082d 129
9023cb7e 130 /* SLOB */
9023cb7e 131 PG_slob_free = PG_private,
e2683181 132};
1da177e4 133
9223b419
CL
134#ifndef __GENERATING_BOUNDS_H
135
f94a62e9
CL
136/*
137 * Macros to create function definitions for page flags
138 */
139#define TESTPAGEFLAG(uname, lname) \
67db392d 140static inline int Page##uname(const struct page *page) \
f94a62e9
CL
141 { return test_bit(PG_##lname, &page->flags); }
142
143#define SETPAGEFLAG(uname, lname) \
144static inline void SetPage##uname(struct page *page) \
145 { set_bit(PG_##lname, &page->flags); }
146
147#define CLEARPAGEFLAG(uname, lname) \
148static inline void ClearPage##uname(struct page *page) \
149 { clear_bit(PG_##lname, &page->flags); }
150
151#define __SETPAGEFLAG(uname, lname) \
152static inline void __SetPage##uname(struct page *page) \
153 { __set_bit(PG_##lname, &page->flags); }
154
155#define __CLEARPAGEFLAG(uname, lname) \
156static inline void __ClearPage##uname(struct page *page) \
157 { __clear_bit(PG_##lname, &page->flags); }
158
159#define TESTSETFLAG(uname, lname) \
160static inline int TestSetPage##uname(struct page *page) \
161 { return test_and_set_bit(PG_##lname, &page->flags); }
162
163#define TESTCLEARFLAG(uname, lname) \
164static inline int TestClearPage##uname(struct page *page) \
165 { return test_and_clear_bit(PG_##lname, &page->flags); }
166
451ea25d
JW
167#define __TESTCLEARFLAG(uname, lname) \
168static inline int __TestClearPage##uname(struct page *page) \
169 { return __test_and_clear_bit(PG_##lname, &page->flags); }
f94a62e9
CL
170
171#define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \
172 SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)
173
174#define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \
175 __SETPAGEFLAG(uname, lname) __CLEARPAGEFLAG(uname, lname)
176
177#define TESTSCFLAG(uname, lname) \
178 TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)
179
2f3e442c
JW
180#define TESTPAGEFLAG_FALSE(uname) \
181static inline int Page##uname(const struct page *page) { return 0; }
182
8a7a8544
LS
183#define SETPAGEFLAG_NOOP(uname) \
184static inline void SetPage##uname(struct page *page) { }
185
186#define CLEARPAGEFLAG_NOOP(uname) \
187static inline void ClearPage##uname(struct page *page) { }
188
189#define __CLEARPAGEFLAG_NOOP(uname) \
190static inline void __ClearPage##uname(struct page *page) { }
191
2f3e442c
JW
192#define TESTSETFLAG_FALSE(uname) \
193static inline int TestSetPage##uname(struct page *page) { return 0; }
194
8a7a8544
LS
195#define TESTCLEARFLAG_FALSE(uname) \
196static inline int TestClearPage##uname(struct page *page) { return 0; }
197
451ea25d
JW
198#define __TESTCLEARFLAG_FALSE(uname) \
199static inline int __TestClearPage##uname(struct page *page) { return 0; }
200
2f3e442c
JW
201#define PAGEFLAG_FALSE(uname) TESTPAGEFLAG_FALSE(uname) \
202 SETPAGEFLAG_NOOP(uname) CLEARPAGEFLAG_NOOP(uname)
203
204#define TESTSCFLAG_FALSE(uname) \
205 TESTSETFLAG_FALSE(uname) TESTCLEARFLAG_FALSE(uname)
206
6a1e7f77
CL
207struct page; /* forward declaration */
208
cb240452 209TESTPAGEFLAG(Locked, locked)
212260aa 210PAGEFLAG(Error, error) TESTCLEARFLAG(Error, error)
6a1e7f77 211PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
2457aec6 212 __SETPAGEFLAG(Referenced, referenced)
6a1e7f77
CL
213PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
214PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)
215PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)
894bc310 216 TESTCLEARFLAG(Active, active)
6a1e7f77 217__PAGEFLAG(Slab, slab)
0cad47cf
AW
218PAGEFLAG(Checked, checked) /* Used by some filesystems */
219PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned) /* Xen */
220PAGEFLAG(SavePinned, savepinned); /* Xen */
d8ac3dd4 221PAGEFLAG(Foreign, foreign); /* Xen */
6a1e7f77 222PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
b2e18538 223PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
07a42788 224 __SETPAGEFLAG(SwapBacked, swapbacked)
6a1e7f77 225
9023cb7e
AW
226__PAGEFLAG(SlobFree, slob_free)
227
266cf658
DH
228/*
229 * Private page markings that may be used by the filesystem that owns the page
230 * for its own purposes.
231 * - PG_private and PG_private_2 cause releasepage() and co to be invoked
232 */
233PAGEFLAG(Private, private) __SETPAGEFLAG(Private, private)
234 __CLEARPAGEFLAG(Private, private)
235PAGEFLAG(Private2, private_2) TESTSCFLAG(Private2, private_2)
236PAGEFLAG(OwnerPriv1, owner_priv_1) TESTCLEARFLAG(OwnerPriv1, owner_priv_1)
237
6a1e7f77
CL
238/*
239 * Only test-and-set exist for PG_writeback. The unconditional operators are
240 * risky: they bypass page accounting.
241 */
242TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
6a1e7f77
CL
243PAGEFLAG(MappedToDisk, mappedtodisk)
244
579f8290 245/* PG_readahead is only used for reads; PG_reclaim is only for writes */
6a1e7f77 246PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
579f8290 247PAGEFLAG(Readahead, reclaim) TESTCLEARFLAG(Readahead, reclaim)
6a1e7f77
CL
248
249#ifdef CONFIG_HIGHMEM
1da177e4 250/*
6a1e7f77
CL
251 * Must use a macro here due to header dependency issues. page_zone() is not
252 * available at this point.
1da177e4 253 */
3ca65c19 254#define PageHighMem(__p) is_highmem_idx(page_zonenum(__p))
6a1e7f77 255#else
ec7cade8 256PAGEFLAG_FALSE(HighMem)
6a1e7f77
CL
257#endif
258
259#ifdef CONFIG_SWAP
260PAGEFLAG(SwapCache, swapcache)
261#else
ec7cade8 262PAGEFLAG_FALSE(SwapCache)
6a1e7f77
CL
263#endif
264
894bc310
LS
265PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
266 TESTCLEARFLAG(Unevictable, unevictable)
b291f000 267
af8e3354 268#ifdef CONFIG_MMU
b291f000 269PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
451ea25d 270 TESTSCFLAG(Mlocked, mlocked) __TESTCLEARFLAG(Mlocked, mlocked)
894bc310 271#else
2f3e442c
JW
272PAGEFLAG_FALSE(Mlocked) __CLEARPAGEFLAG_NOOP(Mlocked)
273 TESTSCFLAG_FALSE(Mlocked) __TESTCLEARFLAG_FALSE(Mlocked)
894bc310
LS
274#endif
275
46cf98cd 276#ifdef CONFIG_ARCH_USES_PG_UNCACHED
6a1e7f77 277PAGEFLAG(Uncached, uncached)
602c4d11 278#else
ec7cade8 279PAGEFLAG_FALSE(Uncached)
6a1e7f77 280#endif
1da177e4 281
d466f2fc
AK
282#ifdef CONFIG_MEMORY_FAILURE
283PAGEFLAG(HWPoison, hwpoison)
847ce401 284TESTSCFLAG(HWPoison, hwpoison)
d466f2fc
AK
285#define __PG_HWPOISON (1UL << PG_hwpoison)
286#else
287PAGEFLAG_FALSE(HWPoison)
288#define __PG_HWPOISON 0
289#endif
290
33c3fc71
VD
291#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
292TESTPAGEFLAG(Young, young)
293SETPAGEFLAG(Young, young)
294TESTCLEARFLAG(Young, young)
295PAGEFLAG(Idle, idle)
296#endif
297
e8c6158f
KS
298/*
299 * On an anonymous page mapped into a user virtual memory area,
300 * page->mapping points to its anon_vma, not to a struct address_space;
301 * with the PAGE_MAPPING_ANON bit set to distinguish it. See rmap.h.
302 *
303 * On an anonymous page in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
304 * the PAGE_MAPPING_KSM bit may be set along with the PAGE_MAPPING_ANON bit;
305 * and then page->mapping points, not to an anon_vma, but to a private
306 * structure which KSM associates with that merged page. See ksm.h.
307 *
308 * PAGE_MAPPING_KSM without PAGE_MAPPING_ANON is currently never used.
309 *
310 * Please note that, confusingly, "page_mapping" refers to the inode
311 * address_space which maps the page from disk; whereas "page_mapped"
312 * refers to user virtual address space into which the page is mapped.
313 */
314#define PAGE_MAPPING_ANON 1
315#define PAGE_MAPPING_KSM 2
316#define PAGE_MAPPING_FLAGS (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM)
317
318static inline int PageAnon(struct page *page)
319{
320 return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
321}
322
323#ifdef CONFIG_KSM
324/*
325 * A KSM page is one of those write-protected "shared pages" or "merged pages"
326 * which KSM maps into multiple mms, wherever identical anonymous page content
327 * is found in VM_MERGEABLE vmas. It's a PageAnon page, pointing not to any
328 * anon_vma, but to that page's node of the stable tree.
329 */
330static inline int PageKsm(struct page *page)
331{
332 return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
333 (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM);
334}
335#else
336TESTPAGEFLAG_FALSE(Ksm)
337#endif
338
1a9b5b7f
WF
339u64 stable_page_flags(struct page *page);
340
0ed361de
NP
341static inline int PageUptodate(struct page *page)
342{
343 int ret = test_bit(PG_uptodate, &(page)->flags);
344
345 /*
346 * Must ensure that the data we read out of the page is loaded
347 * _after_ we've loaded page->flags to check for PageUptodate.
348 * We can skip the barrier if the page is not uptodate, because
349 * we wouldn't be reading anything from it.
350 *
351 * See SetPageUptodate() for the other side of the story.
352 */
353 if (ret)
354 smp_rmb();
355
356 return ret;
357}
358
359static inline void __SetPageUptodate(struct page *page)
360{
361 smp_wmb();
362 __set_bit(PG_uptodate, &(page)->flags);
0ed361de
NP
363}
364
2dcea57a
HC
365static inline void SetPageUptodate(struct page *page)
366{
0ed361de
NP
367 /*
368 * Memory barrier must be issued before setting the PG_uptodate bit,
369 * so that all previous stores issued in order to bring the page
370 * uptodate are actually visible before PageUptodate becomes true.
0ed361de
NP
371 */
372 smp_wmb();
373 set_bit(PG_uptodate, &(page)->flags);
0ed361de
NP
374}
375
6a1e7f77 376CLEARPAGEFLAG(Uptodate, uptodate)
1da177e4 377
6a1e7f77 378int test_clear_page_writeback(struct page *page);
1c8349a1
NJ
379int __test_set_page_writeback(struct page *page, bool keep_write);
380
381#define test_set_page_writeback(page) \
382 __test_set_page_writeback(page, false)
383#define test_set_page_writeback_keepwrite(page) \
384 __test_set_page_writeback(page, true)
1da177e4 385
6a1e7f77
CL
386static inline void set_page_writeback(struct page *page)
387{
388 test_set_page_writeback(page);
389}
1da177e4 390
1c8349a1
NJ
391static inline void set_page_writeback_keepwrite(struct page *page)
392{
393 test_set_page_writeback_keepwrite(page);
394}
395
4e6af67e 396__PAGEFLAG(Head, head) CLEARPAGEFLAG(Head, head)
e20b8cca 397
1d798ca3 398static inline int PageTail(struct page *page)
4e6af67e 399{
1d798ca3 400 return READ_ONCE(page->compound_head) & 1;
4e6af67e 401}
b3acc56b 402
1d798ca3 403static inline void set_compound_head(struct page *page, struct page *head)
ad4b3fb7 404{
1d798ca3 405 WRITE_ONCE(page->compound_head, (unsigned long)head + 1);
ad4b3fb7
CD
406}
407
1d798ca3 408static inline void clear_compound_head(struct page *page)
6a1e7f77 409{
1d798ca3 410 WRITE_ONCE(page->compound_head, 0);
6a1e7f77 411}
6d777953 412
1d798ca3 413static inline struct page *compound_head(struct page *page)
6d777953 414{
1d798ca3
KS
415 unsigned long head = READ_ONCE(page->compound_head);
416
417 if (unlikely(head & 1))
418 return (struct page *) (head - 1);
419 return page;
6d777953
CL
420}
421
1d798ca3 422static inline int PageCompound(struct page *page)
6d777953 423{
1d798ca3 424 return PageHead(page) || PageTail(page);
6d777953 425
1d798ca3 426}
4e6af67e
AA
427#ifdef CONFIG_TRANSPARENT_HUGEPAGE
428static inline void ClearPageCompound(struct page *page)
429{
1d798ca3
KS
430 BUG_ON(!PageHead(page));
431 ClearPageHead(page);
4e6af67e
AA
432}
433#endif
434
1d798ca3 435#define PG_head_mask ((1L << PG_head))
dfa7e20c 436
e8c6158f
KS
437#ifdef CONFIG_HUGETLB_PAGE
438int PageHuge(struct page *page);
439int PageHeadHuge(struct page *page);
7e1f049e 440bool page_huge_active(struct page *page);
e8c6158f
KS
441#else
442TESTPAGEFLAG_FALSE(Huge)
443TESTPAGEFLAG_FALSE(HeadHuge)
7e1f049e
NH
444
445static inline bool page_huge_active(struct page *page)
446{
447 return 0;
448}
e8c6158f
KS
449#endif
450
7e1f049e 451
936a5fe6 452#ifdef CONFIG_TRANSPARENT_HUGEPAGE
71e3aac0
AA
453/*
454 * PageHuge() only returns true for hugetlbfs pages, but not for
455 * normal or transparent huge pages.
456 *
457 * PageTransHuge() returns true for both transparent huge and
458 * hugetlbfs pages, but not normal pages. PageTransHuge() can only be
459 * called only in the core VM paths where hugetlbfs pages can't exist.
460 */
461static inline int PageTransHuge(struct page *page)
462{
309381fe 463 VM_BUG_ON_PAGE(PageTail(page), page);
71e3aac0
AA
464 return PageHead(page);
465}
466
385de357
DN
467/*
468 * PageTransCompound returns true for both transparent huge pages
469 * and hugetlbfs pages, so it should only be called when it's known
470 * that hugetlbfs pages aren't involved.
471 */
936a5fe6
AA
472static inline int PageTransCompound(struct page *page)
473{
474 return PageCompound(page);
475}
71e3aac0 476
385de357
DN
477/*
478 * PageTransTail returns true for both transparent huge pages
479 * and hugetlbfs pages, so it should only be called when it's known
480 * that hugetlbfs pages aren't involved.
481 */
482static inline int PageTransTail(struct page *page)
483{
484 return PageTail(page);
485}
486
936a5fe6 487#else
d8c1bdeb
KS
488TESTPAGEFLAG_FALSE(TransHuge)
489TESTPAGEFLAG_FALSE(TransCompound)
490TESTPAGEFLAG_FALSE(TransTail)
936a5fe6
AA
491#endif
492
e8c6158f
KS
493/*
494 * PageBuddy() indicate that the page is free and in the buddy system
495 * (see mm/page_alloc.c).
496 *
497 * PAGE_BUDDY_MAPCOUNT_VALUE must be <= -2 but better not too close to
498 * -2 so that an underflow of the page_mapcount() won't be mistaken
499 * for a genuine PAGE_BUDDY_MAPCOUNT_VALUE. -128 can be created very
500 * efficiently by most CPU architectures.
501 */
502#define PAGE_BUDDY_MAPCOUNT_VALUE (-128)
503
504static inline int PageBuddy(struct page *page)
505{
506 return atomic_read(&page->_mapcount) == PAGE_BUDDY_MAPCOUNT_VALUE;
507}
508
509static inline void __SetPageBuddy(struct page *page)
510{
511 VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
512 atomic_set(&page->_mapcount, PAGE_BUDDY_MAPCOUNT_VALUE);
513}
514
515static inline void __ClearPageBuddy(struct page *page)
516{
517 VM_BUG_ON_PAGE(!PageBuddy(page), page);
518 atomic_set(&page->_mapcount, -1);
519}
520
521#define PAGE_BALLOON_MAPCOUNT_VALUE (-256)
522
523static inline int PageBalloon(struct page *page)
524{
525 return atomic_read(&page->_mapcount) == PAGE_BALLOON_MAPCOUNT_VALUE;
526}
527
528static inline void __SetPageBalloon(struct page *page)
529{
530 VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
531 atomic_set(&page->_mapcount, PAGE_BALLOON_MAPCOUNT_VALUE);
532}
533
534static inline void __ClearPageBalloon(struct page *page)
535{
536 VM_BUG_ON_PAGE(!PageBalloon(page), page);
537 atomic_set(&page->_mapcount, -1);
538}
539
072bb0aa
MG
540/*
541 * If network-based swap is enabled, sl*b must keep track of whether pages
542 * were allocated from pfmemalloc reserves.
543 */
544static inline int PageSlabPfmemalloc(struct page *page)
545{
309381fe 546 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
547 return PageActive(page);
548}
549
550static inline void SetPageSlabPfmemalloc(struct page *page)
551{
309381fe 552 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
553 SetPageActive(page);
554}
555
556static inline void __ClearPageSlabPfmemalloc(struct page *page)
557{
309381fe 558 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
559 __ClearPageActive(page);
560}
561
562static inline void ClearPageSlabPfmemalloc(struct page *page)
563{
309381fe 564 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
565 ClearPageActive(page);
566}
567
af8e3354 568#ifdef CONFIG_MMU
33925b25
DH
569#define __PG_MLOCKED (1 << PG_mlocked)
570#else
b291f000 571#define __PG_MLOCKED 0
894bc310
LS
572#endif
573
e9da73d6
AA
574#ifdef CONFIG_TRANSPARENT_HUGEPAGE
575#define __PG_COMPOUND_LOCK (1 << PG_compound_lock)
576#else
577#define __PG_COMPOUND_LOCK 0
578#endif
579
dfa7e20c
RA
580/*
581 * Flags checked when a page is freed. Pages being freed should not have
582 * these flags set. It they are, there is a problem.
583 */
79f4b7bf 584#define PAGE_FLAGS_CHECK_AT_FREE \
266cf658
DH
585 (1 << PG_lru | 1 << PG_locked | \
586 1 << PG_private | 1 << PG_private_2 | \
5f24ce5f 587 1 << PG_writeback | 1 << PG_reserved | \
266cf658 588 1 << PG_slab | 1 << PG_swapcache | 1 << PG_active | \
f4c18e6f 589 1 << PG_unevictable | __PG_MLOCKED | \
e9da73d6 590 __PG_COMPOUND_LOCK)
dfa7e20c
RA
591
592/*
593 * Flags checked when a page is prepped for return by the page allocator.
f4c18e6f 594 * Pages being prepped should not have these flags set. It they are set,
79f4b7bf 595 * there has been a kernel bug or struct page corruption.
f4c18e6f
NH
596 *
597 * __PG_HWPOISON is exceptional because it needs to be kept beyond page's
598 * alloc-free cycle to prevent from reusing the page.
dfa7e20c 599 */
f4c18e6f
NH
600#define PAGE_FLAGS_CHECK_AT_PREP \
601 (((1 << NR_PAGEFLAGS) - 1) & ~__PG_HWPOISON)
dfa7e20c 602
edcf4748
JW
603#define PAGE_FLAGS_PRIVATE \
604 (1 << PG_private | 1 << PG_private_2)
266cf658
DH
605/**
606 * page_has_private - Determine if page has private stuff
607 * @page: The page to be checked
608 *
609 * Determine if a page has private stuff, indicating that release routines
610 * should be invoked upon it.
611 */
edcf4748
JW
612static inline int page_has_private(struct page *page)
613{
614 return !!(page->flags & PAGE_FLAGS_PRIVATE);
615}
616
617#endif /* !__GENERATING_BOUNDS_H */
266cf658 618
1da177e4 619#endif /* PAGE_FLAGS_H */