Merge tag 'for-linus-20160523' of git://git.infradead.org/linux-mtd
[linux-2.6-block.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 103#endif
33c3fc71
VD
104#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
105 PG_young,
106 PG_idle,
f886ed44 107#endif
0cad47cf
AW
108 __NR_PAGEFLAGS,
109
110 /* Filesystems */
111 PG_checked = PG_owner_priv_1,
112
266cf658
DH
113 /* Two page bits are conscripted by FS-Cache to maintain local caching
114 * state. These bits are set on pages belonging to the netfs's inodes
115 * when those inodes are being locally cached.
116 */
117 PG_fscache = PG_private_2, /* page backed by cache */
118
0cad47cf 119 /* XEN */
d8ac3dd4 120 /* Pinned in Xen as a read-only pagetable page. */
0cad47cf 121 PG_pinned = PG_owner_priv_1,
d8ac3dd4 122 /* Pinned as part of domain save (see xen_mm_pin_all()). */
0cad47cf 123 PG_savepinned = PG_dirty,
d8ac3dd4
JH
124 /* Has a grant mapping of another (foreign) domain's page. */
125 PG_foreign = PG_owner_priv_1,
8a38082d 126
9023cb7e 127 /* SLOB */
9023cb7e 128 PG_slob_free = PG_private,
53f9263b
KS
129
130 /* Compound pages. Stored in first tail page's flags */
131 PG_double_map = PG_private_2,
e2683181 132};
1da177e4 133
9223b419
CL
134#ifndef __GENERATING_BOUNDS_H
135
0e6d31a7
KS
136struct page; /* forward declaration */
137
138static inline struct page *compound_head(struct page *page)
139{
140 unsigned long head = READ_ONCE(page->compound_head);
141
142 if (unlikely(head & 1))
143 return (struct page *) (head - 1);
144 return page;
145}
146
4b0f3261 147static __always_inline int PageTail(struct page *page)
0e6d31a7
KS
148{
149 return READ_ONCE(page->compound_head) & 1;
150}
151
4b0f3261 152static __always_inline int PageCompound(struct page *page)
0e6d31a7
KS
153{
154 return test_bit(PG_head, &page->flags) || PageTail(page);
155}
156
95ad9755
KS
157/*
158 * Page flags policies wrt compound pages
159 *
160 * PF_ANY:
161 * the page flag is relevant for small, head and tail pages.
162 *
163 * PF_HEAD:
164 * for compound page all operations related to the page flag applied to
165 * head page.
166 *
167 * PF_NO_TAIL:
168 * modifications of the page flag must be done on small or head pages,
169 * checks can be done on tail pages too.
170 *
171 * PF_NO_COMPOUND:
172 * the page flag is not relevant for compound pages.
173 */
174#define PF_ANY(page, enforce) page
175#define PF_HEAD(page, enforce) compound_head(page)
176#define PF_NO_TAIL(page, enforce) ({ \
177 VM_BUG_ON_PGFLAGS(enforce && PageTail(page), page); \
178 compound_head(page);})
822cdd11 179#define PF_NO_COMPOUND(page, enforce) ({ \
95ad9755
KS
180 VM_BUG_ON_PGFLAGS(enforce && PageCompound(page), page); \
181 page;})
182
f94a62e9
CL
183/*
184 * Macros to create function definitions for page flags
185 */
95ad9755 186#define TESTPAGEFLAG(uname, lname, policy) \
4b0f3261 187static __always_inline int Page##uname(struct page *page) \
95ad9755 188 { return test_bit(PG_##lname, &policy(page, 0)->flags); }
f94a62e9 189
95ad9755 190#define SETPAGEFLAG(uname, lname, policy) \
4b0f3261 191static __always_inline void SetPage##uname(struct page *page) \
95ad9755 192 { set_bit(PG_##lname, &policy(page, 1)->flags); }
f94a62e9 193
95ad9755 194#define CLEARPAGEFLAG(uname, lname, policy) \
4b0f3261 195static __always_inline void ClearPage##uname(struct page *page) \
95ad9755 196 { clear_bit(PG_##lname, &policy(page, 1)->flags); }
f94a62e9 197
95ad9755 198#define __SETPAGEFLAG(uname, lname, policy) \
4b0f3261 199static __always_inline void __SetPage##uname(struct page *page) \
95ad9755 200 { __set_bit(PG_##lname, &policy(page, 1)->flags); }
f94a62e9 201
95ad9755 202#define __CLEARPAGEFLAG(uname, lname, policy) \
4b0f3261 203static __always_inline void __ClearPage##uname(struct page *page) \
95ad9755 204 { __clear_bit(PG_##lname, &policy(page, 1)->flags); }
f94a62e9 205
95ad9755 206#define TESTSETFLAG(uname, lname, policy) \
4b0f3261 207static __always_inline int TestSetPage##uname(struct page *page) \
95ad9755 208 { return test_and_set_bit(PG_##lname, &policy(page, 1)->flags); }
f94a62e9 209
95ad9755 210#define TESTCLEARFLAG(uname, lname, policy) \
4b0f3261 211static __always_inline int TestClearPage##uname(struct page *page) \
95ad9755 212 { return test_and_clear_bit(PG_##lname, &policy(page, 1)->flags); }
f94a62e9 213
95ad9755
KS
214#define PAGEFLAG(uname, lname, policy) \
215 TESTPAGEFLAG(uname, lname, policy) \
216 SETPAGEFLAG(uname, lname, policy) \
217 CLEARPAGEFLAG(uname, lname, policy)
f94a62e9 218
95ad9755
KS
219#define __PAGEFLAG(uname, lname, policy) \
220 TESTPAGEFLAG(uname, lname, policy) \
221 __SETPAGEFLAG(uname, lname, policy) \
222 __CLEARPAGEFLAG(uname, lname, policy)
f94a62e9 223
95ad9755
KS
224#define TESTSCFLAG(uname, lname, policy) \
225 TESTSETFLAG(uname, lname, policy) \
226 TESTCLEARFLAG(uname, lname, policy)
f94a62e9 227
2f3e442c
JW
228#define TESTPAGEFLAG_FALSE(uname) \
229static inline int Page##uname(const struct page *page) { return 0; }
230
8a7a8544
LS
231#define SETPAGEFLAG_NOOP(uname) \
232static inline void SetPage##uname(struct page *page) { }
233
234#define CLEARPAGEFLAG_NOOP(uname) \
235static inline void ClearPage##uname(struct page *page) { }
236
237#define __CLEARPAGEFLAG_NOOP(uname) \
238static inline void __ClearPage##uname(struct page *page) { }
239
2f3e442c
JW
240#define TESTSETFLAG_FALSE(uname) \
241static inline int TestSetPage##uname(struct page *page) { return 0; }
242
8a7a8544
LS
243#define TESTCLEARFLAG_FALSE(uname) \
244static inline int TestClearPage##uname(struct page *page) { return 0; }
245
2f3e442c
JW
246#define PAGEFLAG_FALSE(uname) TESTPAGEFLAG_FALSE(uname) \
247 SETPAGEFLAG_NOOP(uname) CLEARPAGEFLAG_NOOP(uname)
248
249#define TESTSCFLAG_FALSE(uname) \
250 TESTSETFLAG_FALSE(uname) TESTCLEARFLAG_FALSE(uname)
251
48c935ad 252__PAGEFLAG(Locked, locked, PF_NO_TAIL)
df8c94d1 253PAGEFLAG(Error, error, PF_NO_COMPOUND) TESTCLEARFLAG(Error, error, PF_NO_COMPOUND)
8cb38fab
KS
254PAGEFLAG(Referenced, referenced, PF_HEAD)
255 TESTCLEARFLAG(Referenced, referenced, PF_HEAD)
256 __SETPAGEFLAG(Referenced, referenced, PF_HEAD)
df8c94d1
KS
257PAGEFLAG(Dirty, dirty, PF_HEAD) TESTSCFLAG(Dirty, dirty, PF_HEAD)
258 __CLEARPAGEFLAG(Dirty, dirty, PF_HEAD)
8cb38fab
KS
259PAGEFLAG(LRU, lru, PF_HEAD) __CLEARPAGEFLAG(LRU, lru, PF_HEAD)
260PAGEFLAG(Active, active, PF_HEAD) __CLEARPAGEFLAG(Active, active, PF_HEAD)
261 TESTCLEARFLAG(Active, active, PF_HEAD)
dcb351cd
KS
262__PAGEFLAG(Slab, slab, PF_NO_TAIL)
263__PAGEFLAG(SlobFree, slob_free, PF_NO_TAIL)
df8c94d1 264PAGEFLAG(Checked, checked, PF_NO_COMPOUND) /* Used by some filesystems */
c13985fa
KS
265
266/* Xen */
267PAGEFLAG(Pinned, pinned, PF_NO_COMPOUND)
268 TESTSCFLAG(Pinned, pinned, PF_NO_COMPOUND)
269PAGEFLAG(SavePinned, savepinned, PF_NO_COMPOUND);
270PAGEFLAG(Foreign, foreign, PF_NO_COMPOUND);
271
de09d31d
KS
272PAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
273 __CLEARPAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
da5efc40
KS
274PAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
275 __CLEARPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
276 __SETPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
95ad9755 277
266cf658
DH
278/*
279 * Private page markings that may be used by the filesystem that owns the page
280 * for its own purposes.
281 * - PG_private and PG_private_2 cause releasepage() and co to be invoked
282 */
95ad9755
KS
283PAGEFLAG(Private, private, PF_ANY) __SETPAGEFLAG(Private, private, PF_ANY)
284 __CLEARPAGEFLAG(Private, private, PF_ANY)
285PAGEFLAG(Private2, private_2, PF_ANY) TESTSCFLAG(Private2, private_2, PF_ANY)
286PAGEFLAG(OwnerPriv1, owner_priv_1, PF_ANY)
287 TESTCLEARFLAG(OwnerPriv1, owner_priv_1, PF_ANY)
266cf658 288
6a1e7f77
CL
289/*
290 * Only test-and-set exist for PG_writeback. The unconditional operators are
291 * risky: they bypass page accounting.
292 */
df8c94d1
KS
293TESTPAGEFLAG(Writeback, writeback, PF_NO_COMPOUND)
294 TESTSCFLAG(Writeback, writeback, PF_NO_COMPOUND)
295PAGEFLAG(MappedToDisk, mappedtodisk, PF_NO_COMPOUND)
6a1e7f77 296
579f8290 297/* PG_readahead is only used for reads; PG_reclaim is only for writes */
df8c94d1
KS
298PAGEFLAG(Reclaim, reclaim, PF_NO_COMPOUND)
299 TESTCLEARFLAG(Reclaim, reclaim, PF_NO_COMPOUND)
300PAGEFLAG(Readahead, reclaim, PF_NO_COMPOUND)
301 TESTCLEARFLAG(Readahead, reclaim, PF_NO_COMPOUND)
6a1e7f77
CL
302
303#ifdef CONFIG_HIGHMEM
1da177e4 304/*
6a1e7f77
CL
305 * Must use a macro here due to header dependency issues. page_zone() is not
306 * available at this point.
1da177e4 307 */
3ca65c19 308#define PageHighMem(__p) is_highmem_idx(page_zonenum(__p))
6a1e7f77 309#else
ec7cade8 310PAGEFLAG_FALSE(HighMem)
6a1e7f77
CL
311#endif
312
313#ifdef CONFIG_SWAP
50ea78d6 314PAGEFLAG(SwapCache, swapcache, PF_NO_COMPOUND)
6a1e7f77 315#else
ec7cade8 316PAGEFLAG_FALSE(SwapCache)
6a1e7f77
CL
317#endif
318
8cb38fab
KS
319PAGEFLAG(Unevictable, unevictable, PF_HEAD)
320 __CLEARPAGEFLAG(Unevictable, unevictable, PF_HEAD)
321 TESTCLEARFLAG(Unevictable, unevictable, PF_HEAD)
b291f000 322
af8e3354 323#ifdef CONFIG_MMU
e4f87d5d
KS
324PAGEFLAG(Mlocked, mlocked, PF_NO_TAIL)
325 __CLEARPAGEFLAG(Mlocked, mlocked, PF_NO_TAIL)
326 TESTSCFLAG(Mlocked, mlocked, PF_NO_TAIL)
894bc310 327#else
2f3e442c 328PAGEFLAG_FALSE(Mlocked) __CLEARPAGEFLAG_NOOP(Mlocked)
685eaade 329 TESTSCFLAG_FALSE(Mlocked)
894bc310
LS
330#endif
331
46cf98cd 332#ifdef CONFIG_ARCH_USES_PG_UNCACHED
b9d41817 333PAGEFLAG(Uncached, uncached, PF_NO_COMPOUND)
602c4d11 334#else
ec7cade8 335PAGEFLAG_FALSE(Uncached)
6a1e7f77 336#endif
1da177e4 337
d466f2fc 338#ifdef CONFIG_MEMORY_FAILURE
95ad9755
KS
339PAGEFLAG(HWPoison, hwpoison, PF_ANY)
340TESTSCFLAG(HWPoison, hwpoison, PF_ANY)
d466f2fc
AK
341#define __PG_HWPOISON (1UL << PG_hwpoison)
342#else
343PAGEFLAG_FALSE(HWPoison)
344#define __PG_HWPOISON 0
345#endif
346
33c3fc71 347#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
95ad9755
KS
348TESTPAGEFLAG(Young, young, PF_ANY)
349SETPAGEFLAG(Young, young, PF_ANY)
350TESTCLEARFLAG(Young, young, PF_ANY)
351PAGEFLAG(Idle, idle, PF_ANY)
33c3fc71
VD
352#endif
353
e8c6158f
KS
354/*
355 * On an anonymous page mapped into a user virtual memory area,
356 * page->mapping points to its anon_vma, not to a struct address_space;
357 * with the PAGE_MAPPING_ANON bit set to distinguish it. See rmap.h.
358 *
359 * On an anonymous page in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
360 * the PAGE_MAPPING_KSM bit may be set along with the PAGE_MAPPING_ANON bit;
361 * and then page->mapping points, not to an anon_vma, but to a private
362 * structure which KSM associates with that merged page. See ksm.h.
363 *
364 * PAGE_MAPPING_KSM without PAGE_MAPPING_ANON is currently never used.
365 *
366 * Please note that, confusingly, "page_mapping" refers to the inode
367 * address_space which maps the page from disk; whereas "page_mapped"
368 * refers to user virtual address space into which the page is mapped.
369 */
370#define PAGE_MAPPING_ANON 1
371#define PAGE_MAPPING_KSM 2
372#define PAGE_MAPPING_FLAGS (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM)
373
17514574
MG
374static __always_inline int PageAnonHead(struct page *page)
375{
376 return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
377}
378
4b0f3261 379static __always_inline int PageAnon(struct page *page)
e8c6158f 380{
822cdd11 381 page = compound_head(page);
17514574 382 return PageAnonHead(page);
e8c6158f
KS
383}
384
385#ifdef CONFIG_KSM
386/*
387 * A KSM page is one of those write-protected "shared pages" or "merged pages"
388 * which KSM maps into multiple mms, wherever identical anonymous page content
389 * is found in VM_MERGEABLE vmas. It's a PageAnon page, pointing not to any
390 * anon_vma, but to that page's node of the stable tree.
391 */
4b0f3261 392static __always_inline int PageKsm(struct page *page)
e8c6158f 393{
822cdd11 394 page = compound_head(page);
e8c6158f
KS
395 return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
396 (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM);
397}
398#else
399TESTPAGEFLAG_FALSE(Ksm)
400#endif
401
1a9b5b7f
WF
402u64 stable_page_flags(struct page *page);
403
0ed361de
NP
404static inline int PageUptodate(struct page *page)
405{
d2998c4d
KS
406 int ret;
407 page = compound_head(page);
408 ret = test_bit(PG_uptodate, &(page)->flags);
0ed361de
NP
409 /*
410 * Must ensure that the data we read out of the page is loaded
411 * _after_ we've loaded page->flags to check for PageUptodate.
412 * We can skip the barrier if the page is not uptodate, because
413 * we wouldn't be reading anything from it.
414 *
415 * See SetPageUptodate() for the other side of the story.
416 */
417 if (ret)
418 smp_rmb();
419
420 return ret;
421}
422
4b0f3261 423static __always_inline void __SetPageUptodate(struct page *page)
0ed361de 424{
d2998c4d 425 VM_BUG_ON_PAGE(PageTail(page), page);
0ed361de 426 smp_wmb();
df8c94d1 427 __set_bit(PG_uptodate, &page->flags);
0ed361de
NP
428}
429
4b0f3261 430static __always_inline void SetPageUptodate(struct page *page)
2dcea57a 431{
d2998c4d 432 VM_BUG_ON_PAGE(PageTail(page), page);
0ed361de
NP
433 /*
434 * Memory barrier must be issued before setting the PG_uptodate bit,
435 * so that all previous stores issued in order to bring the page
436 * uptodate are actually visible before PageUptodate becomes true.
0ed361de
NP
437 */
438 smp_wmb();
df8c94d1 439 set_bit(PG_uptodate, &page->flags);
0ed361de
NP
440}
441
d2998c4d 442CLEARPAGEFLAG(Uptodate, uptodate, PF_NO_TAIL)
1da177e4 443
6a1e7f77 444int test_clear_page_writeback(struct page *page);
1c8349a1
NJ
445int __test_set_page_writeback(struct page *page, bool keep_write);
446
447#define test_set_page_writeback(page) \
448 __test_set_page_writeback(page, false)
449#define test_set_page_writeback_keepwrite(page) \
450 __test_set_page_writeback(page, true)
1da177e4 451
6a1e7f77
CL
452static inline void set_page_writeback(struct page *page)
453{
454 test_set_page_writeback(page);
455}
1da177e4 456
1c8349a1
NJ
457static inline void set_page_writeback_keepwrite(struct page *page)
458{
459 test_set_page_writeback_keepwrite(page);
460}
461
95ad9755 462__PAGEFLAG(Head, head, PF_ANY) CLEARPAGEFLAG(Head, head, PF_ANY)
e20b8cca 463
4b0f3261 464static __always_inline void set_compound_head(struct page *page, struct page *head)
ad4b3fb7 465{
1d798ca3 466 WRITE_ONCE(page->compound_head, (unsigned long)head + 1);
ad4b3fb7
CD
467}
468
4b0f3261 469static __always_inline void clear_compound_head(struct page *page)
6a1e7f77 470{
1d798ca3 471 WRITE_ONCE(page->compound_head, 0);
6a1e7f77 472}
6d777953 473
4e6af67e
AA
474#ifdef CONFIG_TRANSPARENT_HUGEPAGE
475static inline void ClearPageCompound(struct page *page)
476{
1d798ca3
KS
477 BUG_ON(!PageHead(page));
478 ClearPageHead(page);
4e6af67e
AA
479}
480#endif
481
d2a1a1f0 482#define PG_head_mask ((1UL << PG_head))
dfa7e20c 483
e8c6158f
KS
484#ifdef CONFIG_HUGETLB_PAGE
485int PageHuge(struct page *page);
486int PageHeadHuge(struct page *page);
7e1f049e 487bool page_huge_active(struct page *page);
e8c6158f
KS
488#else
489TESTPAGEFLAG_FALSE(Huge)
490TESTPAGEFLAG_FALSE(HeadHuge)
7e1f049e
NH
491
492static inline bool page_huge_active(struct page *page)
493{
494 return 0;
495}
e8c6158f
KS
496#endif
497
7e1f049e 498
936a5fe6 499#ifdef CONFIG_TRANSPARENT_HUGEPAGE
71e3aac0
AA
500/*
501 * PageHuge() only returns true for hugetlbfs pages, but not for
502 * normal or transparent huge pages.
503 *
504 * PageTransHuge() returns true for both transparent huge and
505 * hugetlbfs pages, but not normal pages. PageTransHuge() can only be
506 * called only in the core VM paths where hugetlbfs pages can't exist.
507 */
508static inline int PageTransHuge(struct page *page)
509{
309381fe 510 VM_BUG_ON_PAGE(PageTail(page), page);
71e3aac0
AA
511 return PageHead(page);
512}
513
385de357
DN
514/*
515 * PageTransCompound returns true for both transparent huge pages
516 * and hugetlbfs pages, so it should only be called when it's known
517 * that hugetlbfs pages aren't involved.
518 */
936a5fe6
AA
519static inline int PageTransCompound(struct page *page)
520{
521 return PageCompound(page);
522}
71e3aac0 523
127393fb
AA
524/*
525 * PageTransCompoundMap is the same as PageTransCompound, but it also
526 * guarantees the primary MMU has the entire compound page mapped
527 * through pmd_trans_huge, which in turn guarantees the secondary MMUs
528 * can also map the entire compound page. This allows the secondary
529 * MMUs to call get_user_pages() only once for each compound page and
530 * to immediately map the entire compound page with a single secondary
531 * MMU fault. If there will be a pmd split later, the secondary MMUs
532 * will get an update through the MMU notifier invalidation through
533 * split_huge_pmd().
534 *
535 * Unlike PageTransCompound, this is safe to be called only while
536 * split_huge_pmd() cannot run from under us, like if protected by the
537 * MMU notifier, otherwise it may result in page->_mapcount < 0 false
538 * positives.
539 */
540static inline int PageTransCompoundMap(struct page *page)
541{
542 return PageTransCompound(page) && atomic_read(&page->_mapcount) < 0;
543}
544
385de357
DN
545/*
546 * PageTransTail returns true for both transparent huge pages
547 * and hugetlbfs pages, so it should only be called when it's known
548 * that hugetlbfs pages aren't involved.
549 */
550static inline int PageTransTail(struct page *page)
551{
552 return PageTail(page);
553}
554
53f9263b
KS
555/*
556 * PageDoubleMap indicates that the compound page is mapped with PTEs as well
557 * as PMDs.
558 *
559 * This is required for optimization of rmap operations for THP: we can postpone
560 * per small page mapcount accounting (and its overhead from atomic operations)
561 * until the first PMD split.
562 *
563 * For the page PageDoubleMap means ->_mapcount in all sub-pages is offset up
564 * by one. This reference will go away with last compound_mapcount.
565 *
566 * See also __split_huge_pmd_locked() and page_remove_anon_compound_rmap().
567 */
568static inline int PageDoubleMap(struct page *page)
569{
570 return PageHead(page) && test_bit(PG_double_map, &page[1].flags);
571}
572
573static inline int TestSetPageDoubleMap(struct page *page)
574{
575 VM_BUG_ON_PAGE(!PageHead(page), page);
576 return test_and_set_bit(PG_double_map, &page[1].flags);
577}
578
579static inline int TestClearPageDoubleMap(struct page *page)
580{
581 VM_BUG_ON_PAGE(!PageHead(page), page);
582 return test_and_clear_bit(PG_double_map, &page[1].flags);
583}
584
936a5fe6 585#else
d8c1bdeb
KS
586TESTPAGEFLAG_FALSE(TransHuge)
587TESTPAGEFLAG_FALSE(TransCompound)
127393fb 588TESTPAGEFLAG_FALSE(TransCompoundMap)
d8c1bdeb 589TESTPAGEFLAG_FALSE(TransTail)
53f9263b
KS
590TESTPAGEFLAG_FALSE(DoubleMap)
591 TESTSETFLAG_FALSE(DoubleMap)
592 TESTCLEARFLAG_FALSE(DoubleMap)
936a5fe6
AA
593#endif
594
e8c6158f
KS
595/*
596 * PageBuddy() indicate that the page is free and in the buddy system
597 * (see mm/page_alloc.c).
598 *
599 * PAGE_BUDDY_MAPCOUNT_VALUE must be <= -2 but better not too close to
600 * -2 so that an underflow of the page_mapcount() won't be mistaken
601 * for a genuine PAGE_BUDDY_MAPCOUNT_VALUE. -128 can be created very
602 * efficiently by most CPU architectures.
603 */
604#define PAGE_BUDDY_MAPCOUNT_VALUE (-128)
605
606static inline int PageBuddy(struct page *page)
607{
608 return atomic_read(&page->_mapcount) == PAGE_BUDDY_MAPCOUNT_VALUE;
609}
610
611static inline void __SetPageBuddy(struct page *page)
612{
613 VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
614 atomic_set(&page->_mapcount, PAGE_BUDDY_MAPCOUNT_VALUE);
615}
616
617static inline void __ClearPageBuddy(struct page *page)
618{
619 VM_BUG_ON_PAGE(!PageBuddy(page), page);
620 atomic_set(&page->_mapcount, -1);
621}
622
832fc1de
NH
623extern bool is_free_buddy_page(struct page *page);
624
e8c6158f
KS
625#define PAGE_BALLOON_MAPCOUNT_VALUE (-256)
626
627static inline int PageBalloon(struct page *page)
628{
629 return atomic_read(&page->_mapcount) == PAGE_BALLOON_MAPCOUNT_VALUE;
630}
631
632static inline void __SetPageBalloon(struct page *page)
633{
634 VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
635 atomic_set(&page->_mapcount, PAGE_BALLOON_MAPCOUNT_VALUE);
636}
637
638static inline void __ClearPageBalloon(struct page *page)
639{
640 VM_BUG_ON_PAGE(!PageBalloon(page), page);
641 atomic_set(&page->_mapcount, -1);
642}
643
072bb0aa
MG
644/*
645 * If network-based swap is enabled, sl*b must keep track of whether pages
646 * were allocated from pfmemalloc reserves.
647 */
648static inline int PageSlabPfmemalloc(struct page *page)
649{
309381fe 650 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
651 return PageActive(page);
652}
653
654static inline void SetPageSlabPfmemalloc(struct page *page)
655{
309381fe 656 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
657 SetPageActive(page);
658}
659
660static inline void __ClearPageSlabPfmemalloc(struct page *page)
661{
309381fe 662 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
663 __ClearPageActive(page);
664}
665
666static inline void ClearPageSlabPfmemalloc(struct page *page)
667{
309381fe 668 VM_BUG_ON_PAGE(!PageSlab(page), page);
072bb0aa
MG
669 ClearPageActive(page);
670}
671
af8e3354 672#ifdef CONFIG_MMU
d2a1a1f0 673#define __PG_MLOCKED (1UL << PG_mlocked)
33925b25 674#else
b291f000 675#define __PG_MLOCKED 0
894bc310
LS
676#endif
677
dfa7e20c
RA
678/*
679 * Flags checked when a page is freed. Pages being freed should not have
680 * these flags set. It they are, there is a problem.
681 */
79f4b7bf 682#define PAGE_FLAGS_CHECK_AT_FREE \
d2a1a1f0
YZ
683 (1UL << PG_lru | 1UL << PG_locked | \
684 1UL << PG_private | 1UL << PG_private_2 | \
685 1UL << PG_writeback | 1UL << PG_reserved | \
686 1UL << PG_slab | 1UL << PG_swapcache | 1UL << PG_active | \
687 1UL << PG_unevictable | __PG_MLOCKED)
dfa7e20c
RA
688
689/*
690 * Flags checked when a page is prepped for return by the page allocator.
f4c18e6f 691 * Pages being prepped should not have these flags set. It they are set,
79f4b7bf 692 * there has been a kernel bug or struct page corruption.
f4c18e6f
NH
693 *
694 * __PG_HWPOISON is exceptional because it needs to be kept beyond page's
695 * alloc-free cycle to prevent from reusing the page.
dfa7e20c 696 */
f4c18e6f 697#define PAGE_FLAGS_CHECK_AT_PREP \
d2a1a1f0 698 (((1UL << NR_PAGEFLAGS) - 1) & ~__PG_HWPOISON)
dfa7e20c 699
edcf4748 700#define PAGE_FLAGS_PRIVATE \
d2a1a1f0 701 (1UL << PG_private | 1UL << PG_private_2)
266cf658
DH
702/**
703 * page_has_private - Determine if page has private stuff
704 * @page: The page to be checked
705 *
706 * Determine if a page has private stuff, indicating that release routines
707 * should be invoked upon it.
708 */
edcf4748
JW
709static inline int page_has_private(struct page *page)
710{
711 return !!(page->flags & PAGE_FLAGS_PRIVATE);
712}
713
95ad9755
KS
714#undef PF_ANY
715#undef PF_HEAD
716#undef PF_NO_TAIL
717#undef PF_NO_COMPOUND
edcf4748 718#endif /* !__GENERATING_BOUNDS_H */
266cf658 719
1da177e4 720#endif /* PAGE_FLAGS_H */