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 */ 403