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#ifdef CONFIG_S390
 307        if (!test_and_set_bit(PG_uptodate, &page->flags))
 308                page_set_storage_key(page_to_phys(page), PAGE_DEFAULT_KEY, 0);
 309#else
 310        /*
 311         * Memory barrier must be issued before setting the PG_uptodate bit,
 312         * so that all previous stores issued in order to bring the page
 313         * uptodate are actually visible before PageUptodate becomes true.
 314         *
 315         * s390 doesn't need an explicit smp_wmb here because the test and
 316         * set bit already provides full barriers.
 317         */
 318        smp_wmb();
 319        set_bit(PG_uptodate, &(page)->flags);
 320#endif
 321}
 322
 323CLEARPAGEFLAG(Uptodate, uptodate)
 324
 325extern void cancel_dirty_page(struct page *page, unsigned int account_size);
 326
 327int test_clear_page_writeback(struct page *page);
 328int test_set_page_writeback(struct page *page);
 329
 330static inline void set_page_writeback(struct page *page)
 331{
 332        test_set_page_writeback(page);
 333}
 334
 335#ifdef CONFIG_PAGEFLAGS_EXTENDED
 336/*
 337 * System with lots of page flags available. This allows separate
 338 * flags for PageHead() and PageTail() checks of compound pages so that bit
 339 * tests can be used in performance sensitive paths. PageCompound is
 340 * generally not used in hot code paths.
 341 */
 342__PAGEFLAG(Head, head) CLEARPAGEFLAG(Head, head)
 343__PAGEFLAG(Tail, tail)
 344
 345static inline int PageCompound(struct page *page)
 346{
 347        return page->flags & ((1L << PG_head) | (1L << PG_tail));
 348
 349}
 350#ifdef CONFIG_TRANSPARENT_HUGEPAGE
 351static inline void ClearPageCompound(struct page *page)
 352{
 353        BUG_ON(!PageHead(page));
 354        ClearPageHead(page);
 355}
 356#endif
 357#else
 358/*
 359 * Reduce page flag use as much as possible by overlapping
 360 * compound page flags with the flags used for page cache pages. Possible
 361 * because PageCompound is always set for compound pages and not for
 362 * pages on the LRU and/or pagecache.
 363 */
 364TESTPAGEFLAG(Compound, compound)
 365__PAGEFLAG(Head, compound)
 366
 367/*
 368 * PG_reclaim is used in combination with PG_compound to mark the
 369 * head and tail of a compound page. This saves one page flag
 370 * but makes it impossible to use compound pages for the page cache.
 371 * The PG_reclaim bit would have to be used for reclaim or readahead
 372 * if compound pages enter the page cache.
 373 *
 374 * PG_compound & PG_reclaim     => Tail page
 375 * PG_compound & ~PG_reclaim    => Head page
 376 */
 377#define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))
 378
 379static inline int PageTail(struct page *page)
 380{
 381        return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
 382}
 383
 384static inline void __SetPageTail(struct page *page)
 385{
 386        page->flags |= PG_head_tail_mask;
 387}
 388
 389static inline void __ClearPageTail(struct page *page)
 390{
 391        page->flags &= ~PG_head_tail_mask;
 392}
 393
 394#ifdef CONFIG_TRANSPARENT_HUGEPAGE
 395static inline void ClearPageCompound(struct page *page)
 396{
 397        BUG_ON((page->flags & PG_head_tail_mask) != (1 << PG_compound));
 398        clear_bit(PG_compound, &page->flags);
 399}
 400#endif
 401
 402#endif /* !PAGEFLAGS_EXTENDED */
 403
 404#ifdef CONFIG_TRANSPARENT_HUGEPAGE
 405/*
 406 * PageHuge() only returns true for hugetlbfs pages, but not for
 407 * normal or transparent huge pages.
 408 *
 409 * PageTransHuge() returns true for both transparent huge and
 410 * hugetlbfs pages, but not normal pages. PageTransHuge() can only be
 411 * called only in the core VM paths where hugetlbfs pages can't exist.
 412 */
 413static inline int PageTransHuge(struct page *page)
 414{
 415        VM_BUG_ON(PageTail(page));
 416        return PageHead(page);
 417}
 418
 419/*
 420 * PageTransCompound returns true for both transparent huge pages
 421 * and hugetlbfs pages, so it should only be called when it's known
 422 * that hugetlbfs pages aren't involved.
 423 */
 424static inline int PageTransCompound(struct page *page)
 425{
 426        return PageCompound(page);
 427}
 428
 429/*
 430 * PageTransTail returns true for both transparent huge pages
 431 * and hugetlbfs pages, so it should only be called when it's known
 432 * that hugetlbfs pages aren't involved.
 433 */
 434static inline int PageTransTail(struct page *page)
 435{
 436        return PageTail(page);
 437}
 438
 439#else
 440
 441static inline int PageTransHuge(struct page *page)
 442{
 443        return 0;
 444}
 445
 446static inline int PageTransCompound(struct page *page)
 447{
 448        return 0;
 449}
 450
 451static inline int PageTransTail(struct page *page)
 452{
 453        return 0;
 454}
 455#endif
 456
 457/*
 458 * If network-based swap is enabled, sl*b must keep track of whether pages
 459 * were allocated from pfmemalloc reserves.
 460 */
 461static inline int PageSlabPfmemalloc(struct page *page)
 462{
 463        VM_BUG_ON(!PageSlab(page));
 464        return PageActive(page);
 465}
 466
 467static inline void SetPageSlabPfmemalloc(struct page *page)
 468{
 469        VM_BUG_ON(!PageSlab(page));
 470        SetPageActive(page);
 471}
 472
 473static inline void __ClearPageSlabPfmemalloc(struct page *page)
 474{
 475        VM_BUG_ON(!PageSlab(page));
 476        __ClearPageActive(page);
 477}
 478
 479static inline void ClearPageSlabPfmemalloc(struct page *page)
 480{
 481        VM_BUG_ON(!PageSlab(page));
 482        ClearPageActive(page);
 483}
 484
 485#ifdef CONFIG_MMU
 486#define __PG_MLOCKED            (1 << PG_mlocked)
 487#else
 488#define __PG_MLOCKED            0
 489#endif
 490
 491#ifdef CONFIG_TRANSPARENT_HUGEPAGE
 492#define __PG_COMPOUND_LOCK              (1 << PG_compound_lock)
 493#else
 494#define __PG_COMPOUND_LOCK              0
 495#endif
 496
 497/*
 498 * Flags checked when a page is freed.  Pages being freed should not have
 499 * these flags set.  It they are, there is a problem.
 500 */
 501#define PAGE_FLAGS_CHECK_AT_FREE \
 502        (1 << PG_lru     | 1 << PG_locked    | \
 503         1 << PG_private | 1 << PG_private_2 | \
 504         1 << PG_writeback | 1 << PG_reserved | \
 505         1 << PG_slab    | 1 << PG_swapcache | 1 << PG_active | \
 506         1 << PG_unevictable | __PG_MLOCKED | __PG_HWPOISON | \
 507         __PG_COMPOUND_LOCK)
 508
 509/*
 510 * Flags checked when a page is prepped for return by the page allocator.
 511 * Pages being prepped should not have any flags set.  It they are set,
 512 * there has been a kernel bug or struct page corruption.
 513 */
 514#define PAGE_FLAGS_CHECK_AT_PREP        ((1 << NR_PAGEFLAGS) - 1)
 515
 516#define PAGE_FLAGS_PRIVATE                              \
 517        (1 << PG_private | 1 << PG_private_2)
 518/**
 519 * page_has_private - Determine if page has private stuff
 520 * @page: The page to be checked
 521 *
 522 * Determine if a page has private stuff, indicating that release routines
 523 * should be invoked upon it.
 524 */
 525static inline int page_has_private(struct page *page)
 526{
 527        return !!(page->flags & PAGE_FLAGS_PRIVATE);
 528}
 529
 530#endif /* !__GENERATING_BOUNDS_H */
 531
 532#endif  /* PAGE_FLAGS_H */
 533
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.