1
2
3
4
5#ifndef PAGE_FLAGS_H
6#define PAGE_FLAGS_H
7
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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74enum pageflags {
75 PG_locked,
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,
84 PG_arch_1,
85 PG_reserved,
86 PG_private,
87 PG_private_2,
88 PG_writeback,
89#ifdef CONFIG_PAGEFLAGS_EXTENDED
90 PG_head,
91 PG_tail,
92#else
93 PG_compound,
94#endif
95 PG_swapcache,
96 PG_mappedtodisk,
97 PG_reclaim,
98 PG_swapbacked,
99 PG_unevictable,
100#ifdef CONFIG_MMU
101 PG_mlocked,
102#endif
103#ifdef CONFIG_ARCH_USES_PG_UNCACHED
104 PG_uncached,
105#endif
106#ifdef CONFIG_MEMORY_FAILURE
107 PG_hwpoison,
108#endif
109#ifdef CONFIG_TRANSPARENT_HUGEPAGE
110 PG_compound_lock,
111#endif
112#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
113 PG_young,
114 PG_idle,
115#endif
116 __NR_PAGEFLAGS,
117
118
119 PG_checked = PG_owner_priv_1,
120
121
122
123
124
125 PG_fscache = PG_private_2,
126
127
128
129 PG_pinned = PG_owner_priv_1,
130
131 PG_savepinned = PG_dirty,
132
133 PG_foreign = PG_owner_priv_1,
134
135
136 PG_slob_free = PG_private,
137};
138
139#ifndef __GENERATING_BOUNDS_H
140
141
142
143
144#define TESTPAGEFLAG(uname, lname) \
145static inline int Page##uname(const struct page *page) \
146 { return test_bit(PG_##lname, &page->flags); }
147
148#define SETPAGEFLAG(uname, lname) \
149static inline void SetPage##uname(struct page *page) \
150 { set_bit(PG_##lname, &page->flags); }
151
152#define CLEARPAGEFLAG(uname, lname) \
153static inline void ClearPage##uname(struct page *page) \
154 { clear_bit(PG_##lname, &page->flags); }
155
156#define __SETPAGEFLAG(uname, lname) \
157static inline void __SetPage##uname(struct page *page) \
158 { __set_bit(PG_##lname, &page->flags); }
159
160#define __CLEARPAGEFLAG(uname, lname) \
161static inline void __ClearPage##uname(struct page *page) \
162 { __clear_bit(PG_##lname, &page->flags); }
163
164#define TESTSETFLAG(uname, lname) \
165static inline int TestSetPage##uname(struct page *page) \
166 { return test_and_set_bit(PG_##lname, &page->flags); }
167
168#define TESTCLEARFLAG(uname, lname) \
169static inline int TestClearPage##uname(struct page *page) \
170 { return test_and_clear_bit(PG_##lname, &page->flags); }
171
172#define __TESTCLEARFLAG(uname, lname) \
173static inline int __TestClearPage##uname(struct page *page) \
174 { return __test_and_clear_bit(PG_##lname, &page->flags); }
175
176#define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \
177 SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)
178
179#define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \
180 __SETPAGEFLAG(uname, lname) __CLEARPAGEFLAG(uname, lname)
181
182#define TESTSCFLAG(uname, lname) \
183 TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)
184
185#define TESTPAGEFLAG_FALSE(uname) \
186static inline int Page##uname(const struct page *page) { return 0; }
187
188#define SETPAGEFLAG_NOOP(uname) \
189static inline void SetPage##uname(struct page *page) { }
190
191#define CLEARPAGEFLAG_NOOP(uname) \
192static inline void ClearPage##uname(struct page *page) { }
193
194#define __CLEARPAGEFLAG_NOOP(uname) \
195static inline void __ClearPage##uname(struct page *page) { }
196
197#define TESTSETFLAG_FALSE(uname) \
198static inline int TestSetPage##uname(struct page *page) { return 0; }
199
200#define TESTCLEARFLAG_FALSE(uname) \
201static inline int TestClearPage##uname(struct page *page) { return 0; }
202
203#define __TESTCLEARFLAG_FALSE(uname) \
204static inline int __TestClearPage##uname(struct page *page) { return 0; }
205
206#define PAGEFLAG_FALSE(uname) TESTPAGEFLAG_FALSE(uname) \
207 SETPAGEFLAG_NOOP(uname) CLEARPAGEFLAG_NOOP(uname)
208
209#define TESTSCFLAG_FALSE(uname) \
210 TESTSETFLAG_FALSE(uname) TESTCLEARFLAG_FALSE(uname)
211
212struct page;
213
214TESTPAGEFLAG(Locked, locked)
215PAGEFLAG(Error, error) TESTCLEARFLAG(Error, error)
216PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
217 __SETPAGEFLAG(Referenced, referenced)
218PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
219PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)
220PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)
221 TESTCLEARFLAG(Active, active)
222__PAGEFLAG(Slab, slab)
223PAGEFLAG(Checked, checked)
224PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)
225PAGEFLAG(SavePinned, savepinned);
226PAGEFLAG(Foreign, foreign);
227PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
228PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
229 __SETPAGEFLAG(SwapBacked, swapbacked)
230
231__PAGEFLAG(SlobFree, slob_free)
232
233
234
235
236
237
238PAGEFLAG(Private, private) __SETPAGEFLAG(Private, private)
239 __CLEARPAGEFLAG(Private, private)
240PAGEFLAG(Private2, private_2) TESTSCFLAG(Private2, private_2)
241PAGEFLAG(OwnerPriv1, owner_priv_1) TESTCLEARFLAG(OwnerPriv1, owner_priv_1)
242
243
244
245
246
247TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
248PAGEFLAG(MappedToDisk, mappedtodisk)
249
250
251PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
252PAGEFLAG(Readahead, reclaim) TESTCLEARFLAG(Readahead, reclaim)
253
254#ifdef CONFIG_HIGHMEM
255
256
257
258
259#define PageHighMem(__p) is_highmem(page_zone(__p))
260#else
261PAGEFLAG_FALSE(HighMem)
262#endif
263
264#ifdef CONFIG_SWAP
265PAGEFLAG(SwapCache, swapcache)
266#else
267PAGEFLAG_FALSE(SwapCache)
268#endif
269
270PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
271 TESTCLEARFLAG(Unevictable, unevictable)
272
273#ifdef CONFIG_MMU
274PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
275 TESTSCFLAG(Mlocked, mlocked) __TESTCLEARFLAG(Mlocked, mlocked)
276#else
277PAGEFLAG_FALSE(Mlocked) __CLEARPAGEFLAG_NOOP(Mlocked)
278 TESTSCFLAG_FALSE(Mlocked) __TESTCLEARFLAG_FALSE(Mlocked)
279#endif
280
281#ifdef CONFIG_ARCH_USES_PG_UNCACHED
282PAGEFLAG(Uncached, uncached)
283#else
284PAGEFLAG_FALSE(Uncached)
285#endif
286
287#ifdef CONFIG_MEMORY_FAILURE
288PAGEFLAG(HWPoison, hwpoison)
289TESTSCFLAG(HWPoison, hwpoison)
290#define __PG_HWPOISON (1UL << PG_hwpoison)
291#else
292PAGEFLAG_FALSE(HWPoison)
293#define __PG_HWPOISON 0
294#endif
295
296#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
297TESTPAGEFLAG(Young, young)
298SETPAGEFLAG(Young, young)
299TESTCLEARFLAG(Young, young)
300PAGEFLAG(Idle, idle)
301#endif
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319#define PAGE_MAPPING_ANON 1
320#define PAGE_MAPPING_KSM 2
321#define PAGE_MAPPING_FLAGS (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM)
322
323static inline int PageAnon(struct page *page)
324{
325 return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
326}
327
328#ifdef CONFIG_KSM
329
330
331
332
333
334
335static inline int PageKsm(struct page *page)
336{
337 return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
338 (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM);
339}
340#else
341TESTPAGEFLAG_FALSE(Ksm)
342#endif
343
344u64 stable_page_flags(struct page *page);
345
346static inline int PageUptodate(struct page *page)
347{
348 int ret = test_bit(PG_uptodate, &(page)->flags);
349
350
351
352
353
354
355
356
357
358 if (ret)
359 smp_rmb();
360
361 return ret;
362}
363
364static inline void __SetPageUptodate(struct page *page)
365{
366 smp_wmb();
367 __set_bit(PG_uptodate, &(page)->flags);
368}
369
370static inline void SetPageUptodate(struct page *page)
371{
372
373
374
375
376
377 smp_wmb();
378 set_bit(PG_uptodate, &(page)->flags);
379}
380
381CLEARPAGEFLAG(Uptodate, uptodate)
382
383int test_clear_page_writeback(struct page *page);
384int __test_set_page_writeback(struct page *page, bool keep_write);
385
386#define test_set_page_writeback(page) \
387 __test_set_page_writeback(page, false)
388#define test_set_page_writeback_keepwrite(page) \
389 __test_set_page_writeback(page, true)
390
391static inline void set_page_writeback(struct page *page)
392{
393 test_set_page_writeback(page);
394}
395
396static inline void set_page_writeback_keepwrite(struct page *page)
397{
398 test_set_page_writeback_keepwrite(page);
399}
400
401#ifdef CONFIG_PAGEFLAGS_EXTENDED
402
403
404
405
406
407
408
409
410__PAGEFLAG(Head, head) CLEARPAGEFLAG(Head, head)
411__PAGEFLAG(Tail, tail)
412
413static inline int PageCompound(struct page *page)
414{
415 return page->flags & ((1L << PG_head) | (1L << PG_tail));
416
417}
418#ifdef CONFIG_TRANSPARENT_HUGEPAGE
419static inline void ClearPageCompound(struct page *page)
420{
421 BUG_ON(!PageHead(page));
422 ClearPageHead(page);
423}
424#endif
425
426#define PG_head_mask ((1L << PG_head))
427
428#else
429
430
431
432
433
434
435TESTPAGEFLAG(Compound, compound)
436__SETPAGEFLAG(Head, compound) __CLEARPAGEFLAG(Head, compound)
437
438
439
440
441
442
443
444
445
446
447
448#define PG_head_mask ((1L << PG_compound))
449#define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))
450
451static inline int PageHead(struct page *page)
452{
453 return ((page->flags & PG_head_tail_mask) == PG_head_mask);
454}
455
456static inline int PageTail(struct page *page)
457{
458 return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
459}
460
461static inline void __SetPageTail(struct page *page)
462{
463 page->flags |= PG_head_tail_mask;
464}
465
466static inline void __ClearPageTail(struct page *page)
467{
468 page->flags &= ~PG_head_tail_mask;
469}
470
471#ifdef CONFIG_TRANSPARENT_HUGEPAGE
472static inline void ClearPageCompound(struct page *page)
473{
474 BUG_ON((page->flags & PG_head_tail_mask) != (1 << PG_compound));
475 clear_bit(PG_compound, &page->flags);
476}
477#endif
478
479#endif
480
481#ifdef CONFIG_HUGETLB_PAGE
482int PageHuge(struct page *page);
483int PageHeadHuge(struct page *page);
484bool page_huge_active(struct page *page);
485#else
486TESTPAGEFLAG_FALSE(Huge)
487TESTPAGEFLAG_FALSE(HeadHuge)
488
489static inline bool page_huge_active(struct page *page)
490{
491 return 0;
492}
493#endif
494
495
496#ifdef CONFIG_TRANSPARENT_HUGEPAGE
497
498
499
500
501
502
503
504
505static inline int PageTransHuge(struct page *page)
506{
507 VM_BUG_ON_PAGE(PageTail(page), page);
508 return PageHead(page);
509}
510
511
512
513
514
515
516static inline int PageTransCompound(struct page *page)
517{
518 return PageCompound(page);
519}
520
521
522
523
524
525
526static inline int PageTransTail(struct page *page)
527{
528 return PageTail(page);
529}
530
531#else
532
533static inline int PageTransHuge(struct page *page)
534{
535 return 0;
536}
537
538static inline int PageTransCompound(struct page *page)
539{
540 return 0;
541}
542
543static inline int PageTransTail(struct page *page)
544{
545 return 0;
546}
547#endif
548
549
550
551
552
553
554
555
556
557
558#define PAGE_BUDDY_MAPCOUNT_VALUE (-128)
559
560static inline int PageBuddy(struct page *page)
561{
562 return atomic_read(&page->_mapcount) == PAGE_BUDDY_MAPCOUNT_VALUE;
563}
564
565static inline void __SetPageBuddy(struct page *page)
566{
567 VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
568 atomic_set(&page->_mapcount, PAGE_BUDDY_MAPCOUNT_VALUE);
569}
570
571static inline void __ClearPageBuddy(struct page *page)
572{
573 VM_BUG_ON_PAGE(!PageBuddy(page), page);
574 atomic_set(&page->_mapcount, -1);
575}
576
577#define PAGE_BALLOON_MAPCOUNT_VALUE (-256)
578
579static inline int PageBalloon(struct page *page)
580{
581 return atomic_read(&page->_mapcount) == PAGE_BALLOON_MAPCOUNT_VALUE;
582}
583
584static inline void __SetPageBalloon(struct page *page)
585{
586 VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
587 atomic_set(&page->_mapcount, PAGE_BALLOON_MAPCOUNT_VALUE);
588}
589
590static inline void __ClearPageBalloon(struct page *page)
591{
592 VM_BUG_ON_PAGE(!PageBalloon(page), page);
593 atomic_set(&page->_mapcount, -1);
594}
595
596
597
598
599
600static inline int PageSlabPfmemalloc(struct page *page)
601{
602 VM_BUG_ON_PAGE(!PageSlab(page), page);
603 return PageActive(page);
604}
605
606static inline void SetPageSlabPfmemalloc(struct page *page)
607{
608 VM_BUG_ON_PAGE(!PageSlab(page), page);
609 SetPageActive(page);
610}
611
612static inline void __ClearPageSlabPfmemalloc(struct page *page)
613{
614 VM_BUG_ON_PAGE(!PageSlab(page), page);
615 __ClearPageActive(page);
616}
617
618static inline void ClearPageSlabPfmemalloc(struct page *page)
619{
620 VM_BUG_ON_PAGE(!PageSlab(page), page);
621 ClearPageActive(page);
622}
623
624#ifdef CONFIG_MMU
625#define __PG_MLOCKED (1 << PG_mlocked)
626#else
627#define __PG_MLOCKED 0
628#endif
629
630#ifdef CONFIG_TRANSPARENT_HUGEPAGE
631#define __PG_COMPOUND_LOCK (1 << PG_compound_lock)
632#else
633#define __PG_COMPOUND_LOCK 0
634#endif
635
636
637
638
639
640#define PAGE_FLAGS_CHECK_AT_FREE \
641 (1 << PG_lru | 1 << PG_locked | \
642 1 << PG_private | 1 << PG_private_2 | \
643 1 << PG_writeback | 1 << PG_reserved | \
644 1 << PG_slab | 1 << PG_swapcache | 1 << PG_active | \
645 1 << PG_unevictable | __PG_MLOCKED | \
646 __PG_COMPOUND_LOCK)
647
648
649
650
651
652
653
654
655
656#define PAGE_FLAGS_CHECK_AT_PREP \
657 (((1 << NR_PAGEFLAGS) - 1) & ~__PG_HWPOISON)
658
659#define PAGE_FLAGS_PRIVATE \
660 (1 << PG_private | 1 << PG_private_2)
661
662
663
664
665
666
667
668static inline int page_has_private(struct page *page)
669{
670 return !!(page->flags & PAGE_FLAGS_PRIVATE);
671}
672
673#endif
674
675#endif
676