|
1 /* |
|
2 * Macros for manipulating and testing page->flags |
|
3 */ |
|
4 |
|
5 #ifndef PAGE_FLAGS_H |
|
6 #define PAGE_FLAGS_H |
|
7 |
|
8 #include <linux/types.h> |
|
9 #ifndef __GENERATING_BOUNDS_H |
|
10 #include <linux/mm_types.h> |
|
11 #include <linux/bounds.h> |
|
12 #endif /* !__GENERATING_BOUNDS_H */ |
|
13 |
|
14 /* |
|
15 * Various page->flags bits: |
|
16 * |
|
17 * PG_reserved is set for special pages, which can never be swapped out. Some |
|
18 * of them might not even exist (eg empty_bad_page)... |
|
19 * |
|
20 * The PG_private bitflag is set on pagecache pages if they contain filesystem |
|
21 * specific data (which is normally at page->private). It can be used by |
|
22 * private allocations for its own usage. |
|
23 * |
|
24 * During initiation of disk I/O, PG_locked is set. This bit is set before I/O |
|
25 * and cleared when writeback _starts_ or when read _completes_. PG_writeback |
|
26 * is set before writeback starts and cleared when it finishes. |
|
27 * |
|
28 * PG_locked also pins a page in pagecache, and blocks truncation of the file |
|
29 * while it is held. |
|
30 * |
|
31 * page_waitqueue(page) is a wait queue of all tasks waiting for the page |
|
32 * to become unlocked. |
|
33 * |
|
34 * PG_uptodate tells whether the page's contents is valid. When a read |
|
35 * completes, the page becomes uptodate, unless a disk I/O error happened. |
|
36 * |
|
37 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and |
|
38 * file-backed pagecache (see mm/vmscan.c). |
|
39 * |
|
40 * PG_error is set to indicate that an I/O error occurred on this page. |
|
41 * |
|
42 * PG_arch_1 is an architecture specific page state bit. The generic code |
|
43 * guarantees that this bit is cleared for a page when it first is entered into |
|
44 * the page cache. |
|
45 * |
|
46 * PG_highmem pages are not permanently mapped into the kernel virtual address |
|
47 * space, they need to be kmapped separately for doing IO on the pages. The |
|
48 * struct page (these bits with information) are always mapped into kernel |
|
49 * address space... |
|
50 * |
|
51 * PG_buddy is set to indicate that the page is free and in the buddy system |
|
52 * (see mm/page_alloc.c). |
|
53 * |
|
54 */ |
|
55 |
|
56 /* |
|
57 * Don't use the *_dontuse flags. Use the macros. Otherwise you'll break |
|
58 * locked- and dirty-page accounting. |
|
59 * |
|
60 * The page flags field is split into two parts, the main flags area |
|
61 * which extends from the low bits upwards, and the fields area which |
|
62 * extends from the high bits downwards. |
|
63 * |
|
64 * | FIELD | ... | FLAGS | |
|
65 * N-1 ^ 0 |
|
66 * (NR_PAGEFLAGS) |
|
67 * |
|
68 * The fields area is reserved for fields mapping zone, node (for NUMA) and |
|
69 * SPARSEMEM section (for variants of SPARSEMEM that require section ids like |
|
70 * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP). |
|
71 */ |
|
72 enum pageflags { |
|
73 PG_locked, /* Page is locked. Don't touch. */ |
|
74 PG_error, |
|
75 PG_referenced, |
|
76 PG_uptodate, |
|
77 PG_dirty, |
|
78 PG_lru, |
|
79 PG_active, |
|
80 PG_slab, |
|
81 PG_owner_priv_1, /* Owner use. If pagecache, fs may use*/ |
|
82 PG_arch_1, |
|
83 PG_reserved, |
|
84 PG_private, /* If pagecache, has fs-private data */ |
|
85 PG_writeback, /* Page is under writeback */ |
|
86 #ifdef CONFIG_PAGEFLAGS_EXTENDED |
|
87 PG_head, /* A head page */ |
|
88 PG_tail, /* A tail page */ |
|
89 #else |
|
90 PG_compound, /* A compound page */ |
|
91 #endif |
|
92 PG_swapcache, /* Swap page: swp_entry_t in private */ |
|
93 PG_mappedtodisk, /* Has blocks allocated on-disk */ |
|
94 PG_reclaim, /* To be reclaimed asap */ |
|
95 PG_buddy, /* Page is free, on buddy lists */ |
|
96 PG_swapbacked, /* Page is backed by RAM/swap */ |
|
97 #ifdef CONFIG_UNEVICTABLE_LRU |
|
98 PG_unevictable, /* Page is "unevictable" */ |
|
99 PG_mlocked, /* Page is vma mlocked */ |
|
100 #endif |
|
101 #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR |
|
102 PG_uncached, /* Page has been mapped as uncached */ |
|
103 #endif |
|
104 __NR_PAGEFLAGS, |
|
105 |
|
106 /* Filesystems */ |
|
107 PG_checked = PG_owner_priv_1, |
|
108 |
|
109 /* XEN */ |
|
110 PG_pinned = PG_owner_priv_1, |
|
111 PG_savepinned = PG_dirty, |
|
112 |
|
113 /* SLOB */ |
|
114 PG_slob_page = PG_active, |
|
115 PG_slob_free = PG_private, |
|
116 |
|
117 /* SLUB */ |
|
118 PG_slub_frozen = PG_active, |
|
119 PG_slub_debug = PG_error, |
|
120 }; |
|
121 |
|
122 #ifndef __GENERATING_BOUNDS_H |
|
123 |
|
124 /* |
|
125 * Macros to create function definitions for page flags |
|
126 */ |
|
127 #define TESTPAGEFLAG(uname, lname) \ |
|
128 static inline int Page##uname(struct page *page) \ |
|
129 { return test_bit(PG_##lname, &page->flags); } |
|
130 |
|
131 #define SETPAGEFLAG(uname, lname) \ |
|
132 static inline void SetPage##uname(struct page *page) \ |
|
133 { set_bit(PG_##lname, &page->flags); } |
|
134 |
|
135 #define CLEARPAGEFLAG(uname, lname) \ |
|
136 static inline void ClearPage##uname(struct page *page) \ |
|
137 { clear_bit(PG_##lname, &page->flags); } |
|
138 |
|
139 #define __SETPAGEFLAG(uname, lname) \ |
|
140 static inline void __SetPage##uname(struct page *page) \ |
|
141 { __set_bit(PG_##lname, &page->flags); } |
|
142 |
|
143 #define __CLEARPAGEFLAG(uname, lname) \ |
|
144 static inline void __ClearPage##uname(struct page *page) \ |
|
145 { __clear_bit(PG_##lname, &page->flags); } |
|
146 |
|
147 #define TESTSETFLAG(uname, lname) \ |
|
148 static inline int TestSetPage##uname(struct page *page) \ |
|
149 { return test_and_set_bit(PG_##lname, &page->flags); } |
|
150 |
|
151 #define TESTCLEARFLAG(uname, lname) \ |
|
152 static inline int TestClearPage##uname(struct page *page) \ |
|
153 { return test_and_clear_bit(PG_##lname, &page->flags); } |
|
154 |
|
155 |
|
156 #define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \ |
|
157 SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname) |
|
158 |
|
159 #define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname) \ |
|
160 __SETPAGEFLAG(uname, lname) __CLEARPAGEFLAG(uname, lname) |
|
161 |
|
162 #define PAGEFLAG_FALSE(uname) \ |
|
163 static inline int Page##uname(struct page *page) \ |
|
164 { return 0; } |
|
165 |
|
166 #define TESTSCFLAG(uname, lname) \ |
|
167 TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname) |
|
168 |
|
169 #define SETPAGEFLAG_NOOP(uname) \ |
|
170 static inline void SetPage##uname(struct page *page) { } |
|
171 |
|
172 #define CLEARPAGEFLAG_NOOP(uname) \ |
|
173 static inline void ClearPage##uname(struct page *page) { } |
|
174 |
|
175 #define __CLEARPAGEFLAG_NOOP(uname) \ |
|
176 static inline void __ClearPage##uname(struct page *page) { } |
|
177 |
|
178 #define TESTCLEARFLAG_FALSE(uname) \ |
|
179 static inline int TestClearPage##uname(struct page *page) { return 0; } |
|
180 |
|
181 struct page; /* forward declaration */ |
|
182 |
|
183 TESTPAGEFLAG(Locked, locked) |
|
184 PAGEFLAG(Error, error) |
|
185 PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced) |
|
186 PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty) |
|
187 PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru) |
|
188 PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active) |
|
189 TESTCLEARFLAG(Active, active) |
|
190 __PAGEFLAG(Slab, slab) |
|
191 PAGEFLAG(Checked, checked) /* Used by some filesystems */ |
|
192 PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned) /* Xen */ |
|
193 PAGEFLAG(SavePinned, savepinned); /* Xen */ |
|
194 PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved) |
|
195 PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private) |
|
196 __SETPAGEFLAG(Private, private) |
|
197 PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked) |
|
198 |
|
199 __PAGEFLAG(SlobPage, slob_page) |
|
200 __PAGEFLAG(SlobFree, slob_free) |
|
201 |
|
202 __PAGEFLAG(SlubFrozen, slub_frozen) |
|
203 __PAGEFLAG(SlubDebug, slub_debug) |
|
204 |
|
205 /* |
|
206 * Only test-and-set exist for PG_writeback. The unconditional operators are |
|
207 * risky: they bypass page accounting. |
|
208 */ |
|
209 TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback) |
|
210 __PAGEFLAG(Buddy, buddy) |
|
211 PAGEFLAG(MappedToDisk, mappedtodisk) |
|
212 |
|
213 /* PG_readahead is only used for file reads; PG_reclaim is only for writes */ |
|
214 PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim) |
|
215 PAGEFLAG(Readahead, reclaim) /* Reminder to do async read-ahead */ |
|
216 |
|
217 #ifdef CONFIG_HIGHMEM |
|
218 /* |
|
219 * Must use a macro here due to header dependency issues. page_zone() is not |
|
220 * available at this point. |
|
221 */ |
|
222 #define PageHighMem(__p) is_highmem(page_zone(__p)) |
|
223 #else |
|
224 PAGEFLAG_FALSE(HighMem) |
|
225 #endif |
|
226 |
|
227 #ifdef CONFIG_SWAP |
|
228 PAGEFLAG(SwapCache, swapcache) |
|
229 #else |
|
230 PAGEFLAG_FALSE(SwapCache) |
|
231 #endif |
|
232 |
|
233 #ifdef CONFIG_UNEVICTABLE_LRU |
|
234 PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable) |
|
235 TESTCLEARFLAG(Unevictable, unevictable) |
|
236 |
|
237 #define MLOCK_PAGES 1 |
|
238 PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked) |
|
239 TESTSCFLAG(Mlocked, mlocked) |
|
240 |
|
241 #else |
|
242 |
|
243 #define MLOCK_PAGES 0 |
|
244 PAGEFLAG_FALSE(Mlocked) |
|
245 SETPAGEFLAG_NOOP(Mlocked) TESTCLEARFLAG_FALSE(Mlocked) |
|
246 |
|
247 PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable) |
|
248 SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable) |
|
249 __CLEARPAGEFLAG_NOOP(Unevictable) |
|
250 #endif |
|
251 |
|
252 #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR |
|
253 PAGEFLAG(Uncached, uncached) |
|
254 #else |
|
255 PAGEFLAG_FALSE(Uncached) |
|
256 #endif |
|
257 |
|
258 static inline int PageUptodate(struct page *page) |
|
259 { |
|
260 int ret = test_bit(PG_uptodate, &(page)->flags); |
|
261 |
|
262 /* |
|
263 * Must ensure that the data we read out of the page is loaded |
|
264 * _after_ we've loaded page->flags to check for PageUptodate. |
|
265 * We can skip the barrier if the page is not uptodate, because |
|
266 * we wouldn't be reading anything from it. |
|
267 * |
|
268 * See SetPageUptodate() for the other side of the story. |
|
269 */ |
|
270 if (ret) |
|
271 smp_rmb(); |
|
272 |
|
273 return ret; |
|
274 } |
|
275 |
|
276 static inline void __SetPageUptodate(struct page *page) |
|
277 { |
|
278 smp_wmb(); |
|
279 __set_bit(PG_uptodate, &(page)->flags); |
|
280 } |
|
281 |
|
282 static inline void SetPageUptodate(struct page *page) |
|
283 { |
|
284 #ifdef CONFIG_S390 |
|
285 if (!test_and_set_bit(PG_uptodate, &page->flags)) |
|
286 page_clear_dirty(page); |
|
287 #else |
|
288 /* |
|
289 * Memory barrier must be issued before setting the PG_uptodate bit, |
|
290 * so that all previous stores issued in order to bring the page |
|
291 * uptodate are actually visible before PageUptodate becomes true. |
|
292 * |
|
293 * s390 doesn't need an explicit smp_wmb here because the test and |
|
294 * set bit already provides full barriers. |
|
295 */ |
|
296 smp_wmb(); |
|
297 set_bit(PG_uptodate, &(page)->flags); |
|
298 #endif |
|
299 } |
|
300 |
|
301 CLEARPAGEFLAG(Uptodate, uptodate) |
|
302 |
|
303 extern void cancel_dirty_page(struct page *page, unsigned int account_size); |
|
304 |
|
305 int test_clear_page_writeback(struct page *page); |
|
306 int test_set_page_writeback(struct page *page); |
|
307 |
|
308 static inline void set_page_writeback(struct page *page) |
|
309 { |
|
310 test_set_page_writeback(page); |
|
311 } |
|
312 |
|
313 #ifdef CONFIG_PAGEFLAGS_EXTENDED |
|
314 /* |
|
315 * System with lots of page flags available. This allows separate |
|
316 * flags for PageHead() and PageTail() checks of compound pages so that bit |
|
317 * tests can be used in performance sensitive paths. PageCompound is |
|
318 * generally not used in hot code paths. |
|
319 */ |
|
320 __PAGEFLAG(Head, head) |
|
321 __PAGEFLAG(Tail, tail) |
|
322 |
|
323 static inline int PageCompound(struct page *page) |
|
324 { |
|
325 return page->flags & ((1L << PG_head) | (1L << PG_tail)); |
|
326 |
|
327 } |
|
328 #else |
|
329 /* |
|
330 * Reduce page flag use as much as possible by overlapping |
|
331 * compound page flags with the flags used for page cache pages. Possible |
|
332 * because PageCompound is always set for compound pages and not for |
|
333 * pages on the LRU and/or pagecache. |
|
334 */ |
|
335 TESTPAGEFLAG(Compound, compound) |
|
336 __PAGEFLAG(Head, compound) |
|
337 |
|
338 /* |
|
339 * PG_reclaim is used in combination with PG_compound to mark the |
|
340 * head and tail of a compound page. This saves one page flag |
|
341 * but makes it impossible to use compound pages for the page cache. |
|
342 * The PG_reclaim bit would have to be used for reclaim or readahead |
|
343 * if compound pages enter the page cache. |
|
344 * |
|
345 * PG_compound & PG_reclaim => Tail page |
|
346 * PG_compound & ~PG_reclaim => Head page |
|
347 */ |
|
348 #define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim)) |
|
349 |
|
350 static inline int PageTail(struct page *page) |
|
351 { |
|
352 return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask); |
|
353 } |
|
354 |
|
355 static inline void __SetPageTail(struct page *page) |
|
356 { |
|
357 page->flags |= PG_head_tail_mask; |
|
358 } |
|
359 |
|
360 static inline void __ClearPageTail(struct page *page) |
|
361 { |
|
362 page->flags &= ~PG_head_tail_mask; |
|
363 } |
|
364 |
|
365 #endif /* !PAGEFLAGS_EXTENDED */ |
|
366 |
|
367 #ifdef CONFIG_UNEVICTABLE_LRU |
|
368 #define __PG_UNEVICTABLE (1 << PG_unevictable) |
|
369 #define __PG_MLOCKED (1 << PG_mlocked) |
|
370 #else |
|
371 #define __PG_UNEVICTABLE 0 |
|
372 #define __PG_MLOCKED 0 |
|
373 #endif |
|
374 |
|
375 #define PAGE_FLAGS (1 << PG_lru | 1 << PG_private | 1 << PG_locked | \ |
|
376 1 << PG_buddy | 1 << PG_writeback | \ |
|
377 1 << PG_slab | 1 << PG_swapcache | 1 << PG_active | \ |
|
378 __PG_UNEVICTABLE | __PG_MLOCKED) |
|
379 |
|
380 /* |
|
381 * Flags checked in bad_page(). Pages on the free list should not have |
|
382 * these flags set. It they are, there is a problem. |
|
383 */ |
|
384 #define PAGE_FLAGS_CLEAR_WHEN_BAD (PAGE_FLAGS | \ |
|
385 1 << PG_reclaim | 1 << PG_dirty | 1 << PG_swapbacked) |
|
386 |
|
387 /* |
|
388 * Flags checked when a page is freed. Pages being freed should not have |
|
389 * these flags set. It they are, there is a problem. |
|
390 */ |
|
391 #define PAGE_FLAGS_CHECK_AT_FREE (PAGE_FLAGS | 1 << PG_reserved) |
|
392 |
|
393 /* |
|
394 * Flags checked when a page is prepped for return by the page allocator. |
|
395 * Pages being prepped should not have these flags set. It they are, there |
|
396 * is a problem. |
|
397 */ |
|
398 #define PAGE_FLAGS_CHECK_AT_PREP (PAGE_FLAGS | \ |
|
399 1 << PG_reserved | 1 << PG_dirty | 1 << PG_swapbacked) |
|
400 |
|
401 #endif /* !__GENERATING_BOUNDS_H */ |
|
402 #endif /* PAGE_FLAGS_H */ |