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 __NR_PAGEFLAGS,
113
114
115 PG_checked = PG_owner_priv_1,
116
117
118
119
120
121 PG_fscache = PG_private_2,
122
123
124 PG_pinned = PG_owner_priv_1,
125 PG_savepinned = PG_dirty,
126
127
128 PG_slob_free = PG_private,
129};
130
131#ifndef __GENERATING_BOUNDS_H
132
133
134
135
136#define TESTPAGEFLAG(uname, lname) \
137static inline int Page##uname(const struct page *page) \
138 { return test_bit(PG_##lname, &page->flags); }
139
140#define SETPAGEFLAG(uname, lname) \
141static inline void SetPage##uname(struct page *page) \
142 { set_bit(PG_##lname, &page->flags); }
143
144#define CLEARPAGEFLAG(uname, lname) \
145static inline void ClearPage##uname(struct page *page) \
146 { clear_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 TESTSETFLAG(uname, lname) \
157static inline int TestSetPage##uname(struct page *page) \
158 { return test_and_set_bit(PG_##lname, &page->flags); }
159
160#define TESTCLEARFLAG(uname, lname) \
161static inline int TestClearPage##uname(struct page *page) \
162 { return test_and_clear_bit(PG_##lname, &page->flags); }
163
164#define __TESTCLEARFLAG(uname, lname) \
165static inline int __TestClearPage##uname(struct page *page) \
166 { return __test_and_clear_bit(PG_##lname, &page->flags); }
167
168#define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \
169 SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)
170
171#define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \
172 __SETPAGEFLAG(uname, lname) __CLEARPAGEFLAG(uname, lname)
173
174#define PAGEFLAG_FALSE(uname) \
175static inline int Page##uname(const struct page *page) \
176 { return 0; }
177
178#define TESTSCFLAG(uname, lname) \
179 TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)
180
181#define SETPAGEFLAG_NOOP(uname) \
182static inline void SetPage##uname(struct page *page) { }
183
184#define CLEARPAGEFLAG_NOOP(uname) \
185static inline void ClearPage##uname(struct page *page) { }
186
187#define __CLEARPAGEFLAG_NOOP(uname) \
188static inline void __ClearPage##uname(struct page *page) { }
189
190#define TESTCLEARFLAG_FALSE(uname) \
191static inline int TestClearPage##uname(struct page *page) { return 0; }
192
193#define __TESTCLEARFLAG_FALSE(uname) \
194static inline int __TestClearPage##uname(struct page *page) { return 0; }
195
196struct page;
197
198TESTPAGEFLAG(Locked, locked)
199PAGEFLAG(Error, error) TESTCLEARFLAG(Error, error)
200PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
201PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
202PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)
203PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)
204 TESTCLEARFLAG(Active, active)
205__PAGEFLAG(Slab, slab)
206PAGEFLAG(Checked, checked)
207PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)
208PAGEFLAG(SavePinned, savepinned);
209PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
210PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
211
212__PAGEFLAG(SlobFree, slob_free)
213
214
215
216
217
218
219PAGEFLAG(Private, private) __SETPAGEFLAG(Private, private)
220 __CLEARPAGEFLAG(Private, private)
221PAGEFLAG(Private2, private_2) TESTSCFLAG(Private2, private_2)
222PAGEFLAG(OwnerPriv1, owner_priv_1) TESTCLEARFLAG(OwnerPriv1, owner_priv_1)
223
224
225
226
227
228TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
229PAGEFLAG(MappedToDisk, mappedtodisk)
230
231
232PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
233PAGEFLAG(Readahead, reclaim)
234
235#ifdef CONFIG_HIGHMEM
236
237
238
239
240#define PageHighMem(__p) is_highmem(page_zone(__p))
241#else
242PAGEFLAG_FALSE(HighMem)
243#endif
244
245#ifdef CONFIG_SWAP
246PAGEFLAG(SwapCache, swapcache)
247#else
248PAGEFLAG_FALSE(SwapCache)
249 SETPAGEFLAG_NOOP(SwapCache) CLEARPAGEFLAG_NOOP(SwapCache)
250#endif
251
252PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
253 TESTCLEARFLAG(Unevictable, unevictable)
254
255#ifdef CONFIG_MMU
256PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
257 TESTSCFLAG(Mlocked, mlocked) __TESTCLEARFLAG(Mlocked, mlocked)
258#else
259PAGEFLAG_FALSE(Mlocked) SETPAGEFLAG_NOOP(Mlocked)
260 TESTCLEARFLAG_FALSE(Mlocked) __TESTCLEARFLAG_FALSE(Mlocked)
261#endif
262
263#ifdef CONFIG_ARCH_USES_PG_UNCACHED
264PAGEFLAG(Uncached, uncached)
265#else
266PAGEFLAG_FALSE(Uncached)
267#endif
268
269#ifdef CONFIG_MEMORY_FAILURE
270PAGEFLAG(HWPoison, hwpoison)
271TESTSCFLAG(HWPoison, hwpoison)
272#define __PG_HWPOISON (1UL << PG_hwpoison)
273#else
274PAGEFLAG_FALSE(HWPoison)
275#define __PG_HWPOISON 0
276#endif
277
278u64 stable_page_flags(struct page *page);
279
280static inline int PageUptodate(struct page *page)
281{
282 int ret = test_bit(PG_uptodate, &(page)->flags);
283
284
285
286
287
288
289
290
291
292 if (ret)
293 smp_rmb();
294
295 return ret;
296}
297
298static inline void __SetPageUptodate(struct page *page)
299{
300 smp_wmb();
301 __set_bit(PG_uptodate, &(page)->flags);
302}
303
304static inline void SetPageUptodate(struct page *page)
305{
306
307
308
309
310
311 smp_wmb();
312 set_bit(PG_uptodate, &(page)->flags);
313}
314
315CLEARPAGEFLAG(Uptodate, uptodate)
316
317extern void cancel_dirty_page(struct page *page, unsigned int account_size);
318
319int test_clear_page_writeback(struct page *page);
320int test_set_page_writeback(struct page *page);
321
322static inline void set_page_writeback(struct page *page)
323{
324 test_set_page_writeback(page);
325}
326
327#ifdef CONFIG_PAGEFLAGS_EXTENDED
328
329
330
331
332
333
334__PAGEFLAG(Head, head) CLEARPAGEFLAG(Head, head)
335__PAGEFLAG(Tail, tail)
336
337static inline int PageCompound(struct page *page)
338{
339 return page->flags & ((1L << PG_head) | (1L << PG_tail));
340
341}
342#ifdef CONFIG_TRANSPARENT_HUGEPAGE
343static inline void ClearPageCompound(struct page *page)
344{
345 BUG_ON(!PageHead(page));
346 ClearPageHead(page);
347}
348#endif
349#else
350
351
352
353
354
355
356TESTPAGEFLAG(Compound, compound)
357__SETPAGEFLAG(Head, compound) __CLEARPAGEFLAG(Head, compound)
358
359
360
361
362
363
364
365
366
367
368
369#define PG_head_mask ((1L << PG_compound))
370#define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))
371
372static inline int PageHead(struct page *page)
373{
374 return ((page->flags & PG_head_tail_mask) == PG_head_mask);
375}
376
377static inline int PageTail(struct page *page)
378{
379 return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
380}
381
382static inline void __SetPageTail(struct page *page)
383{
384 page->flags |= PG_head_tail_mask;
385}
386
387static inline void __ClearPageTail(struct page *page)
388{
389 page->flags &= ~PG_head_tail_mask;
390}
391
392#ifdef CONFIG_TRANSPARENT_HUGEPAGE
393static inline void ClearPageCompound(struct page *page)
394{
395 BUG_ON((page->flags & PG_head_tail_mask) != (1 << PG_compound));
396 clear_bit(PG_compound, &page->flags);
397}
398#endif
399
400#endif
401
402#ifdef CONFIG_TRANSPARENT_HUGEPAGE
403
404
405
406
407
408
409
410
411static inline int PageTransHuge(struct page *page)
412{
413 VM_BUG_ON(PageTail(page));
414 return PageHead(page);
415}
416
417
418
419
420
421
422static inline int PageTransCompound(struct page *page)
423{
424 return PageCompound(page);
425}
426
427
428
429
430
431
432static inline int PageTransTail(struct page *page)
433{
434 return PageTail(page);
435}
436
437#else
438
439static inline int PageTransHuge(struct page *page)
440{
441 return 0;
442}
443
444static inline int PageTransCompound(struct page *page)
445{
446 return 0;
447}
448
449static inline int PageTransTail(struct page *page)
450{
451 return 0;
452}
453#endif
454
455
456
457
458
459static inline int PageSlabPfmemalloc(struct page *page)
460{
461 VM_BUG_ON(!PageSlab(page));
462 return PageActive(page);
463}
464
465static inline void SetPageSlabPfmemalloc(struct page *page)
466{
467 VM_BUG_ON(!PageSlab(page));
468 SetPageActive(page);
469}
470
471static inline void __ClearPageSlabPfmemalloc(struct page *page)
472{
473 VM_BUG_ON(!PageSlab(page));
474 __ClearPageActive(page);
475}
476
477static inline void ClearPageSlabPfmemalloc(struct page *page)
478{
479 VM_BUG_ON(!PageSlab(page));
480 ClearPageActive(page);
481}
482
483#ifdef CONFIG_MMU
484#define __PG_MLOCKED (1 << PG_mlocked)
485#else
486#define __PG_MLOCKED 0
487#endif
488
489#ifdef CONFIG_TRANSPARENT_HUGEPAGE
490#define __PG_COMPOUND_LOCK (1 << PG_compound_lock)
491#else
492#define __PG_COMPOUND_LOCK 0
493#endif
494
495
496
497
498
499#define PAGE_FLAGS_CHECK_AT_FREE \
500 (1 << PG_lru | 1 << PG_locked | \
501 1 << PG_private | 1 << PG_private_2 | \
502 1 << PG_writeback | 1 << PG_reserved | \
503 1 << PG_slab | 1 << PG_swapcache | 1 << PG_active | \
504 1 << PG_unevictable | __PG_MLOCKED | __PG_HWPOISON | \
505 __PG_COMPOUND_LOCK)
506
507
508
509
510
511
512#define PAGE_FLAGS_CHECK_AT_PREP ((1 << NR_PAGEFLAGS) - 1)
513
514#define PAGE_FLAGS_PRIVATE \
515 (1 << PG_private | 1 << PG_private_2)
516
517
518
519
520
521
522
523static inline int page_has_private(struct page *page)
524{
525 return !!(page->flags & PAGE_FLAGS_PRIVATE);
526}
527
528#endif
529
530#endif
531