linux/include/linux/page-flags.h
<<
>>
Prefs
   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#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 /* !__GENERATING_BOUNDS_H */
  15
  16/*
  17 * Various page->flags bits:
  18 *
  19 * PG_reserved is set for special pages, which can never be swapped out. Some
  20 * of them might not even exist (eg empty_bad_page)...
  21 *
  22 * The PG_private bitflag is set on pagecache pages if they contain filesystem
  23 * specific data (which is normally at page->private). It can be used by
  24 * private allocations for its own usage.
  25 *
  26 * During initiation of disk I/O, PG_locked is set. This bit is set before I/O
  27 * and cleared when writeback _starts_ or when read _completes_. PG_writeback
  28 * is set before writeback starts and cleared when it finishes.
  29 *
  30 * PG_locked also pins a page in pagecache, and blocks truncation of the file
  31 * while it is held.
  32 *
  33 * page_waitqueue(page) is a wait queue of all tasks waiting for the page
  34 * to become unlocked.
  35 *
  36 * PG_uptodate tells whether the page's contents is valid.  When a read
  37 * completes, the page becomes uptodate, unless a disk I/O error happened.
  38 *
  39 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and
  40 * file-backed pagecache (see mm/vmscan.c).
  41 *
  42 * PG_error is set to indicate that an I/O error occurred on this page.
  43 *
  44 * PG_arch_1 is an architecture specific page state bit.  The generic code
  45 * guarantees that this bit is cleared for a page when it first is entered into
  46 * the page cache.
  47 *
  48 * PG_highmem pages are not permanently mapped into the kernel virtual address
  49 * space, they need to be kmapped separately for doing IO on the pages.  The
  50 * struct page (these bits with information) are always mapped into kernel
  51 * address space...
  52 *
  53 * PG_hwpoison indicates that a page got corrupted in hardware and contains
  54 * data with incorrect ECC bits that triggered a machine check. Accessing is
  55 * not safe since it may cause another machine check. Don't touch!
  56 */
  57
  58/*
  59 * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
  60 * locked- and dirty-page accounting.
  61 *
  62 * The page flags field is split into two parts, the main flags area
  63 * which extends from the low bits upwards, and the fields area which
  64 * extends from the high bits downwards.
  65 *
  66 *  | FIELD | ... | FLAGS |
  67 *  N-1           ^       0
  68 *               (NR_PAGEFLAGS)
  69 *
  70 * The fields area is reserved for fields mapping zone, node (for NUMA) and
  71 * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
  72 * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
  73 */
  74enum pageflags {
  75        PG_locked,              /* Page is locked. Don't touch. */
  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,        /* Owner use. If pagecache, fs may use*/
  84        PG_arch_1,
  85        PG_reserved,
  86        PG_private,             /* If pagecache, has fs-private data */
  87        PG_private_2,           /* If pagecache, has fs aux data */
  88        PG_writeback,           /* Page is under writeback */
  89#ifdef CONFIG_PAGEFLAGS_EXTENDED
  90        PG_head,                /* A head page */
  91        PG_tail,                /* A tail page */
  92#else
  93        PG_compound,            /* A compound page */
  94#endif
  95        PG_swapcache,           /* Swap page: swp_entry_t in private */
  96        PG_mappedtodisk,        /* Has blocks allocated on-disk */
  97        PG_reclaim,             /* To be reclaimed asap */
  98        PG_swapbacked,          /* Page is backed by RAM/swap */
  99        PG_unevictable,         /* Page is "unevictable"  */
 100#ifdef CONFIG_MMU
 101        PG_mlocked,             /* Page is vma mlocked */
 102#endif
 103#ifdef CONFIG_ARCH_USES_PG_UNCACHED
 104        PG_uncached,            /* Page has been mapped as uncached */
 105#endif
 106#ifdef CONFIG_MEMORY_FAILURE
 107        PG_hwpoison,            /* hardware poisoned page. Don't touch */
 108#endif
 109#ifdef CONFIG_TRANSPARENT_HUGEPAGE
 110        PG_compound_lock,
 111#endif
 112        __NR_PAGEFLAGS,
 113
 114        /* Filesystems */
 115        PG_checked = PG_owner_priv_1,
 116
 117        /* Two page bits are conscripted by FS-Cache to maintain local caching
 118         * state.  These bits are set on pages belonging to the netfs's inodes
 119         * when those inodes are being locally cached.
 120         */
 121        PG_fscache = PG_private_2,      /* page backed by cache */
 122
 123        /* XEN */
 124        PG_pinned = PG_owner_priv_1,
 125        PG_savepinned = PG_dirty,
 126
 127        /* SLOB */
 128        PG_slob_free = PG_private,
 129};
 130
 131#ifndef __GENERATING_BOUNDS_H
 132
 133/*
 134 * Macros to create function definitions for page flags
 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;    /* forward declaration */
 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)              /* Used by some filesystems */
 207PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)     /* Xen */
 208PAGEFLAG(SavePinned, savepinned);                       /* Xen */
 209PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
 210PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
 211
 212__PAGEFLAG(SlobFree, slob_free)
 213
 214/*
 215 * Private page markings that may be used by the filesystem that owns the page
 216 * for its own purposes.
 217 * - PG_private and PG_private_2 cause releasepage() and co to be invoked
 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 * Only test-and-set exist for PG_writeback.  The unconditional operators are
 226 * risky: they bypass page accounting.
 227 */
 228TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
 229PAGEFLAG(MappedToDisk, mappedtodisk)
 230
 231/* PG_readahead is only used for file reads; PG_reclaim is only for writes */
 232PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
 233PAGEFLAG(Readahead, reclaim)            /* Reminder to do async read-ahead */
 234
 235#ifdef CONFIG_HIGHMEM
 236/*
 237 * Must use a macro here due to header dependency issues. page_zone() is not
 238 * available at this point.
 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         * Must ensure that the data we read out of the page is loaded
 286         * _after_ we've loaded page->flags to check for PageUptodate.
 287         * We can skip the barrier if the page is not uptodate, because
 288         * we wouldn't be reading anything from it.
 289         *
 290         * See SetPageUptodate() for the other side of the story.
 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         * Memory barrier must be issued before setting the PG_uptodate bit,
 308         * so that all previous stores issued in order to bring the page
 309         * uptodate are actually visible before PageUptodate becomes true.
 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 * System with lots of page flags available. This allows separate
 330 * flags for PageHead() and PageTail() checks of compound pages so that bit
 331 * tests can be used in performance sensitive paths. PageCompound is
 332 * generally not used in hot code paths.
 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 * Reduce page flag use as much as possible by overlapping
 352 * compound page flags with the flags used for page cache pages. Possible
 353 * because PageCompound is always set for compound pages and not for
 354 * pages on the LRU and/or pagecache.
 355 */
 356TESTPAGEFLAG(Compound, compound)
 357__SETPAGEFLAG(Head, compound)  __CLEARPAGEFLAG(Head, compound)
 358
 359/*
 360 * PG_reclaim is used in combination with PG_compound to mark the
 361 * head and tail of a compound page. This saves one page flag
 362 * but makes it impossible to use compound pages for the page cache.
 363 * The PG_reclaim bit would have to be used for reclaim or readahead
 364 * if compound pages enter the page cache.
 365 *
 366 * PG_compound & PG_reclaim     => Tail page
 367 * PG_compound & ~PG_reclaim    => Head page
 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 /* !PAGEFLAGS_EXTENDED */
 401
 402#ifdef CONFIG_TRANSPARENT_HUGEPAGE
 403/*
 404 * PageHuge() only returns true for hugetlbfs pages, but not for
 405 * normal or transparent huge pages.
 406 *
 407 * PageTransHuge() returns true for both transparent huge and
 408 * hugetlbfs pages, but not normal pages. PageTransHuge() can only be
 409 * called only in the core VM paths where hugetlbfs pages can't exist.
 410 */
 411static inline int PageTransHuge(struct page *page)
 412{
 413        VM_BUG_ON(PageTail(page));
 414        return PageHead(page);
 415}
 416
 417/*
 418 * PageTransCompound returns true for both transparent huge pages
 419 * and hugetlbfs pages, so it should only be called when it's known
 420 * that hugetlbfs pages aren't involved.
 421 */
 422static inline int PageTransCompound(struct page *page)
 423{
 424        return PageCompound(page);
 425}
 426
 427/*
 428 * PageTransTail returns true for both transparent huge pages
 429 * and hugetlbfs pages, so it should only be called when it's known
 430 * that hugetlbfs pages aren't involved.
 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 * If network-based swap is enabled, sl*b must keep track of whether pages
 457 * were allocated from pfmemalloc reserves.
 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 * Flags checked when a page is freed.  Pages being freed should not have
 497 * these flags set.  It they are, there is a problem.
 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 * Flags checked when a page is prepped for return by the page allocator.
 509 * Pages being prepped should not have any flags set.  It they are set,
 510 * there has been a kernel bug or struct page corruption.
 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 * page_has_private - Determine if page has private stuff
 518 * @page: The page to be checked
 519 *
 520 * Determine if a page has private stuff, indicating that release routines
 521 * should be invoked upon it.
 522 */
 523static inline int page_has_private(struct page *page)
 524{
 525        return !!(page->flags & PAGE_FLAGS_PRIVATE);
 526}
 527
 528#endif /* !__GENERATING_BOUNDS_H */
 529
 530#endif  /* PAGE_FLAGS_H */
 531
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.