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/percpu.h> 9 #include <linux/cache.h> 10 #include <asm/pgtable.h> 11 12 /* 13 * Various page->flags bits: 14 * 15 * PG_reserved is set for special pages, which can never be swapped out. Some 16 * of them might not even exist (eg empty_bad_page)... 17 * 18 * The PG_private bitflag is set if page->private contains a valid value. 19 * 20 * During disk I/O, PG_locked is used. This bit is set before I/O and 21 * reset when I/O completes. page_waitqueue(page) is a wait queue of all tasks 22 * waiting for the I/O on this page to complete. 23 * 24 * PG_uptodate tells whether the page's contents is valid. When a read 25 * completes, the page becomes uptodate, unless a disk I/O error happened. 26 * 27 * For choosing which pages to swap out, inode pages carry a PG_referenced bit, 28 * which is set any time the system accesses that page through the (mapping, 29 * index) hash table. This referenced bit, together with the referenced bit 30 * in the page tables, is used to manipulate page->age and move the page across 31 * the active, inactive_dirty and inactive_clean lists. 32 * 33 * Note that the referenced bit, the page->lru list_head and the active, 34 * inactive_dirty and inactive_clean lists are protected by the 35 * zone->lru_lock, and *NOT* by the usual PG_locked bit! 36 * 37 * PG_error is set to indicate that an I/O error occurred on this page. 38 * 39 * PG_arch_1 is an architecture specific page state bit. The generic code 40 * guarantees that this bit is cleared for a page when it first is entered into 41 * the page cache. 42 * 43 * PG_highmem pages are not permanently mapped into the kernel virtual address 44 * space, they need to be kmapped separately for doing IO on the pages. The 45 * struct page (these bits with information) are always mapped into kernel 46 * address space... 47 */ 48 49 /* 50 * Don't use the *_dontuse flags. Use the macros. Otherwise you'll break 51 * locked- and dirty-page accounting. The top eight bits of page->flags are 52 * used for page->zone, so putting flag bits there doesn't work. 53 */ 54 #define PG_locked 0 /* Page is locked. Don't touch. */ 55 #define PG_error 1 56 #define PG_referenced 2 57 #define PG_uptodate 3 58 59 #define PG_dirty 4 60 #define PG_lru 5 61 #define PG_active 6 62 #define PG_slab 7 /* slab debug (Suparna wants this) */ 63 64 #define PG_checked 8 /* kill me in 2.5.<early>. */ 65 #define PG_arch_1 9 66 #define PG_reserved 10 67 #define PG_private 11 /* Has something at ->private */ 68 69 #define PG_writeback 12 /* Page is under writeback */ 70 #define PG_nosave 13 /* Used for system suspend/resume */ 71 #define PG_compound 14 /* Part of a compound page */ 72 #define PG_swapcache 15 /* Swap page: swp_entry_t in private */ 73 74 #define PG_mappedtodisk 16 /* Has blocks allocated on-disk */ 75 #define PG_reclaim 17 /* To be reclaimed asap */ 76 #define PG_nosave_free 18 /* Free, should not be written */ 77 #define PG_uncached 19 /* Page has been mapped as uncached */ 78 79 /* 80 * Global page accounting. One instance per CPU. Only unsigned longs are 81 * allowed. 82 */ 83 struct page_state { 84 unsigned long nr_dirty; /* Dirty writeable pages */ 85 unsigned long nr_writeback; /* Pages under writeback */ 86 unsigned long nr_unstable; /* NFS unstable pages */ 87 unsigned long nr_page_table_pages;/* Pages used for pagetables */ 88 unsigned long nr_mapped; /* mapped into pagetables */ 89 unsigned long nr_slab; /* In slab */ 90 #define GET_PAGE_STATE_LAST nr_slab 91 92 /* 93 * The below are zeroed by get_page_state(). Use get_full_page_state() 94 * to add up all these. 95 */ 96 unsigned long pgpgin; /* Disk reads */ 97 unsigned long pgpgout; /* Disk writes */ 98 unsigned long pswpin; /* swap reads */ 99 unsigned long pswpout; /* swap writes */ 100 unsigned long pgalloc_high; /* page allocations */ 101 102 unsigned long pgalloc_normal; 103 unsigned long pgalloc_dma; 104 unsigned long pgfree; /* page freeings */ 105 unsigned long pgactivate; /* pages moved inactive->active */ 106 unsigned long pgdeactivate; /* pages moved active->inactive */ 107 108 unsigned long pgfault; /* faults (major+minor) */ 109 unsigned long pgmajfault; /* faults (major only) */ 110 unsigned long pgrefill_high; /* inspected in refill_inactive_zone */ 111 unsigned long pgrefill_normal; 112 unsigned long pgrefill_dma; 113 114 unsigned long pgsteal_high; /* total highmem pages reclaimed */ 115 unsigned long pgsteal_normal; 116 unsigned long pgsteal_dma; 117 unsigned long pgscan_kswapd_high;/* total highmem pages scanned */ 118 unsigned long pgscan_kswapd_normal; 119 120 unsigned long pgscan_kswapd_dma; 121 unsigned long pgscan_direct_high;/* total highmem pages scanned */ 122 unsigned long pgscan_direct_normal; 123 unsigned long pgscan_direct_dma; 124 unsigned long pginodesteal; /* pages reclaimed via inode freeing */ 125 126 unsigned long slabs_scanned; /* slab objects scanned */ 127 unsigned long kswapd_steal; /* pages reclaimed by kswapd */ 128 unsigned long kswapd_inodesteal;/* reclaimed via kswapd inode freeing */ 129 unsigned long pageoutrun; /* kswapd's calls to page reclaim */ 130 unsigned long allocstall; /* direct reclaim calls */ 131 132 unsigned long pgrotated; /* pages rotated to tail of the LRU */ 133 unsigned long nr_bounce; /* pages for bounce buffers */ 134 }; 135 136 extern void get_page_state(struct page_state *ret); 137 extern void get_full_page_state(struct page_state *ret); 138 extern unsigned long __read_page_state(unsigned long offset); 139 extern void __mod_page_state(unsigned long offset, unsigned long delta); 140 141 #define read_page_state(member) \ 142 __read_page_state(offsetof(struct page_state, member)) 143 144 #define mod_page_state(member, delta) \ 145 __mod_page_state(offsetof(struct page_state, member), (delta)) 146 147 #define inc_page_state(member) mod_page_state(member, 1UL) 148 #define dec_page_state(member) mod_page_state(member, 0UL - 1) 149 #define add_page_state(member,delta) mod_page_state(member, (delta)) 150 #define sub_page_state(member,delta) mod_page_state(member, 0UL - (delta)) 151 152 #define mod_page_state_zone(zone, member, delta) \ 153 do { \ 154 unsigned offset; \ 155 if (is_highmem(zone)) \ 156 offset = offsetof(struct page_state, member##_high); \ 157 else if (is_normal(zone)) \ 158 offset = offsetof(struct page_state, member##_normal); \ 159 else \ 160 offset = offsetof(struct page_state, member##_dma); \ 161 __mod_page_state(offset, (delta)); \ 162 } while (0) 163 164 /* 165 * Manipulation of page state flags 166 */ 167 #define PageLocked(page) \ 168 test_bit(PG_locked, &(page)->flags) 169 #define SetPageLocked(page) \ 170 set_bit(PG_locked, &(page)->flags) 171 #define TestSetPageLocked(page) \ 172 test_and_set_bit(PG_locked, &(page)->flags) 173 #define ClearPageLocked(page) \ 174 clear_bit(PG_locked, &(page)->flags) 175 #define TestClearPageLocked(page) \ 176 test_and_clear_bit(PG_locked, &(page)->flags) 177 178 #define PageError(page) test_bit(PG_error, &(page)->flags) 179 #define SetPageError(page) set_bit(PG_error, &(page)->flags) 180 #define ClearPageError(page) clear_bit(PG_error, &(page)->flags) 181 182 #define PageReferenced(page) test_bit(PG_referenced, &(page)->flags) 183 #define SetPageReferenced(page) set_bit(PG_referenced, &(page)->flags) 184 #define ClearPageReferenced(page) clear_bit(PG_referenced, &(page)->flags) 185 #define TestClearPageReferenced(page) test_and_clear_bit(PG_referenced, &(page)->flags) 186 187 #define PageUptodate(page) test_bit(PG_uptodate, &(page)->flags) 188 #ifndef SetPageUptodate 189 #define SetPageUptodate(page) set_bit(PG_uptodate, &(page)->flags) 190 #endif 191 #define ClearPageUptodate(page) clear_bit(PG_uptodate, &(page)->flags) 192 193 #define PageDirty(page) test_bit(PG_dirty, &(page)->flags) 194 #define SetPageDirty(page) set_bit(PG_dirty, &(page)->flags) 195 #define TestSetPageDirty(page) test_and_set_bit(PG_dirty, &(page)->flags) 196 #define ClearPageDirty(page) clear_bit(PG_dirty, &(page)->flags) 197 #define TestClearPageDirty(page) test_and_clear_bit(PG_dirty, &(page)->flags) 198 199 #define SetPageLRU(page) set_bit(PG_lru, &(page)->flags) 200 #define PageLRU(page) test_bit(PG_lru, &(page)->flags) 201 #define TestSetPageLRU(page) test_and_set_bit(PG_lru, &(page)->flags) 202 #define TestClearPageLRU(page) test_and_clear_bit(PG_lru, &(page)->flags) 203 204 #define PageActive(page) test_bit(PG_active, &(page)->flags) 205 #define SetPageActive(page) set_bit(PG_active, &(page)->flags) 206 #define ClearPageActive(page) clear_bit(PG_active, &(page)->flags) 207 #define TestClearPageActive(page) test_and_clear_bit(PG_active, &(page)->flags) 208 #define TestSetPageActive(page) test_and_set_bit(PG_active, &(page)->flags) 209 210 #define PageSlab(page) test_bit(PG_slab, &(page)->flags) 211 #define SetPageSlab(page) set_bit(PG_slab, &(page)->flags) 212 #define ClearPageSlab(page) clear_bit(PG_slab, &(page)->flags) 213 #define TestClearPageSlab(page) test_and_clear_bit(PG_slab, &(page)->flags) 214 #define TestSetPageSlab(page) test_and_set_bit(PG_slab, &(page)->flags) 215 216 #ifdef CONFIG_HIGHMEM 217 #define PageHighMem(page) is_highmem(page_zone(page)) 218 #else 219 #define PageHighMem(page) 0 /* needed to optimize away at compile time */ 220 #endif 221 222 #define PageChecked(page) test_bit(PG_checked, &(page)->flags) 223 #define SetPageChecked(page) set_bit(PG_checked, &(page)->flags) 224 #define ClearPageChecked(page) clear_bit(PG_checked, &(page)->flags) 225 226 #define PageReserved(page) test_bit(PG_reserved, &(page)->flags) 227 #define SetPageReserved(page) set_bit(PG_reserved, &(page)->flags) 228 #define ClearPageReserved(page) clear_bit(PG_reserved, &(page)->flags) 229 #define __ClearPageReserved(page) __clear_bit(PG_reserved, &(page)->flags) 230 231 #define SetPagePrivate(page) set_bit(PG_private, &(page)->flags) 232 #define ClearPagePrivate(page) clear_bit(PG_private, &(page)->flags) 233 #define PagePrivate(page) test_bit(PG_private, &(page)->flags) 234 #define __SetPagePrivate(page) __set_bit(PG_private, &(page)->flags) 235 #define __ClearPagePrivate(page) __clear_bit(PG_private, &(page)->flags) 236 237 #define PageWriteback(page) test_bit(PG_writeback, &(page)->flags) 238 #define SetPageWriteback(page) \ 239 do { \ 240 if (!test_and_set_bit(PG_writeback, \ 241 &(page)->flags)) \ 242 inc_page_state(nr_writeback); \ 243 } while (0) 244 #define TestSetPageWriteback(page) \ 245 ({ \ 246 int ret; \ 247 ret = test_and_set_bit(PG_writeback, \ 248 &(page)->flags); \ 249 if (!ret) \ 250 inc_page_state(nr_writeback); \ 251 ret; \ 252 }) 253 #define ClearPageWriteback(page) \ 254 do { \ 255 if (test_and_clear_bit(PG_writeback, \ 256 &(page)->flags)) \ 257 dec_page_state(nr_writeback); \ 258 } while (0) 259 #define TestClearPageWriteback(page) \ 260 ({ \ 261 int ret; \ 262 ret = test_and_clear_bit(PG_writeback, \ 263 &(page)->flags); \ 264 if (ret) \ 265 dec_page_state(nr_writeback); \ 266 ret; \ 267 }) 268 269 #define PageNosave(page) test_bit(PG_nosave, &(page)->flags) 270 #define SetPageNosave(page) set_bit(PG_nosave, &(page)->flags) 271 #define TestSetPageNosave(page) test_and_set_bit(PG_nosave, &(page)->flags) 272 #define ClearPageNosave(page) clear_bit(PG_nosave, &(page)->flags) 273 #define TestClearPageNosave(page) test_and_clear_bit(PG_nosave, &(page)->flags) 274 275 #define PageNosaveFree(page) test_bit(PG_nosave_free, &(page)->flags) 276 #define SetPageNosaveFree(page) set_bit(PG_nosave_free, &(page)->flags) 277 #define ClearPageNosaveFree(page) clear_bit(PG_nosave_free, &(page)->flags) 278 279 #define PageMappedToDisk(page) test_bit(PG_mappedtodisk, &(page)->flags) 280 #define SetPageMappedToDisk(page) set_bit(PG_mappedtodisk, &(page)->flags) 281 #define ClearPageMappedToDisk(page) clear_bit(PG_mappedtodisk, &(page)->flags) 282 283 #define PageReclaim(page) test_bit(PG_reclaim, &(page)->flags) 284 #define SetPageReclaim(page) set_bit(PG_reclaim, &(page)->flags) 285 #define ClearPageReclaim(page) clear_bit(PG_reclaim, &(page)->flags) 286 #define TestClearPageReclaim(page) test_and_clear_bit(PG_reclaim, &(page)->flags) 287 288 #ifdef CONFIG_HUGETLB_PAGE 289 #define PageCompound(page) test_bit(PG_compound, &(page)->flags) 290 #else 291 #define PageCompound(page) 0 292 #endif 293 #define SetPageCompound(page) set_bit(PG_compound, &(page)->flags) 294 #define ClearPageCompound(page) clear_bit(PG_compound, &(page)->flags) 295 296 #ifdef CONFIG_SWAP 297 #define PageSwapCache(page) test_bit(PG_swapcache, &(page)->flags) 298 #define SetPageSwapCache(page) set_bit(PG_swapcache, &(page)->flags) 299 #define ClearPageSwapCache(page) clear_bit(PG_swapcache, &(page)->flags) 300 #else 301 #define PageSwapCache(page) 0 302 #endif 303 304 #define PageUncached(page) test_bit(PG_uncached, &(page)->flags) 305 #define SetPageUncached(page) set_bit(PG_uncached, &(page)->flags) 306 #define ClearPageUncached(page) clear_bit(PG_uncached, &(page)->flags) 307 308 struct page; /* forward declaration */ 309 310 int test_clear_page_dirty(struct page *page); 311 int test_clear_page_writeback(struct page *page); 312 int test_set_page_writeback(struct page *page); 313 314 static inline void clear_page_dirty(struct page *page) 315 { 316 test_clear_page_dirty(page); 317 } 318 319 static inline void set_page_writeback(struct page *page) 320 { 321 test_set_page_writeback(page); 322 } 323 324 #endif /* PAGE_FLAGS_H */ 325