LCOV - code coverage report
Current view: top level - lkbce/include/linux - page-flags.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 5 5 100.0 %
Date: 2017-01-25 Functions: 2 2 100.0 %

          Line data    Source code
       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 <generated/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             :  * PG_hwpoison indicates that a page got corrupted in hardware and contains
      55             :  * data with incorrect ECC bits that triggered a machine check. Accessing is
      56             :  * not safe since it may cause another machine check. Don't touch!
      57             :  */
      58             : 
      59             : /*
      60             :  * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
      61             :  * locked- and dirty-page accounting.
      62             :  *
      63             :  * The page flags field is split into two parts, the main flags area
      64             :  * which extends from the low bits upwards, and the fields area which
      65             :  * extends from the high bits downwards.
      66             :  *
      67             :  *  | FIELD | ... | FLAGS |
      68             :  *  N-1           ^       0
      69             :  *               (NR_PAGEFLAGS)
      70             :  *
      71             :  * The fields area is reserved for fields mapping zone, node (for NUMA) and
      72             :  * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
      73             :  * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
      74             :  */
      75             : enum pageflags {
      76             :         PG_locked,              /* Page is locked. Don't touch. */
      77             :         PG_error,
      78             :         PG_referenced,
      79             :         PG_uptodate,
      80             :         PG_dirty,
      81             :         PG_lru,
      82             :         PG_active,
      83             :         PG_slab,
      84             :         PG_owner_priv_1,        /* Owner use. If pagecache, fs may use*/
      85             :         PG_arch_1,
      86             :         PG_reserved,
      87             :         PG_private,             /* If pagecache, has fs-private data */
      88             :         PG_private_2,           /* If pagecache, has fs aux data */
      89             :         PG_writeback,           /* Page is under writeback */
      90             : #ifdef CONFIG_PAGEFLAGS_EXTENDED
      91             :         PG_head,                /* A head page */
      92             :         PG_tail,                /* A tail page */
      93             : #else
      94             :         PG_compound,            /* A compound page */
      95             : #endif
      96             :         PG_swapcache,           /* Swap page: swp_entry_t in private */
      97             :         PG_mappedtodisk,        /* Has blocks allocated on-disk */
      98             :         PG_reclaim,             /* To be reclaimed asap */
      99             :         PG_buddy,               /* Page is free, on buddy lists */
     100             :         PG_swapbacked,          /* Page is backed by RAM/swap */
     101             :         PG_unevictable,         /* Page is "unevictable"  */
     102             : #ifdef CONFIG_MMU
     103             :         PG_mlocked,             /* Page is vma mlocked */
     104             : #endif
     105             : #ifdef CONFIG_ARCH_USES_PG_UNCACHED
     106             :         PG_uncached,            /* Page has been mapped as uncached */
     107             : #endif
     108             : #ifdef CONFIG_MEMORY_FAILURE
     109             :         PG_hwpoison,            /* hardware poisoned page. Don't touch */
     110             : #endif
     111             :         __NR_PAGEFLAGS,
     112             : 
     113             :         /* Filesystems */
     114             :         PG_checked = PG_owner_priv_1,
     115             : 
     116             :         /* Two page bits are conscripted by FS-Cache to maintain local caching
     117             :          * state.  These bits are set on pages belonging to the netfs's inodes
     118             :          * when those inodes are being locally cached.
     119             :          */
     120             :         PG_fscache = PG_private_2,      /* page backed by cache */
     121             : 
     122             :         /* XEN */
     123             :         PG_pinned = PG_owner_priv_1,
     124             :         PG_savepinned = PG_dirty,
     125             : 
     126             :         /* SLOB */
     127             :         PG_slob_free = PG_private,
     128             : 
     129             :         /* SLUB */
     130             :         PG_slub_frozen = PG_active,
     131             :         PG_slub_debug = PG_error,
     132             : };
     133             : 
     134             : #ifndef __GENERATING_BOUNDS_H
     135             : 
     136             : /*
     137             :  * Macros to create function definitions for page flags
     138             :  */
     139             : #define TESTPAGEFLAG(uname, lname)                                      \
     140             : static inline int Page##uname(struct page *page)                        \
     141             :                         { return test_bit(PG_##lname, &page->flags); }
     142             : 
     143             : #define SETPAGEFLAG(uname, lname)                                       \
     144             : static inline void SetPage##uname(struct page *page)                    \
     145             :                         { set_bit(PG_##lname, &page->flags); }
     146             : 
     147             : #define CLEARPAGEFLAG(uname, lname)                                     \
     148             : static inline void ClearPage##uname(struct page *page)                  \
     149             :                         { clear_bit(PG_##lname, &page->flags); }
     150             : 
     151             : #define __SETPAGEFLAG(uname, lname)                                     \
     152             : static inline void __SetPage##uname(struct page *page)                  \
     153             :                         { __set_bit(PG_##lname, &page->flags); }
     154             : 
     155             : #define __CLEARPAGEFLAG(uname, lname)                                   \
     156             : static inline void __ClearPage##uname(struct page *page)                \
     157             :                         { __clear_bit(PG_##lname, &page->flags); }
     158             : 
     159             : #define TESTSETFLAG(uname, lname)                                       \
     160             : static inline int TestSetPage##uname(struct page *page)                 \
     161             :                 { return test_and_set_bit(PG_##lname, &page->flags); }
     162             : 
     163             : #define TESTCLEARFLAG(uname, lname)                                     \
     164             : static inline int TestClearPage##uname(struct page *page)               \
     165             :                 { return test_and_clear_bit(PG_##lname, &page->flags); }
     166             : 
     167             : #define __TESTCLEARFLAG(uname, lname)                                   \
     168             : static inline int __TestClearPage##uname(struct page *page)             \
     169             :                 { return __test_and_clear_bit(PG_##lname, &page->flags); }
     170             : 
     171             : #define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)               \
     172             :         SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)
     173             : 
     174             : #define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)             \
     175             :         __SETPAGEFLAG(uname, lname)  __CLEARPAGEFLAG(uname, lname)
     176             : 
     177             : #define PAGEFLAG_FALSE(uname)                                           \
     178             : static inline int Page##uname(struct page *page)                        \
     179             :                         { return 0; }
     180             : 
     181             : #define TESTSCFLAG(uname, lname)                                        \
     182             :         TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)
     183             : 
     184             : #define SETPAGEFLAG_NOOP(uname)                                         \
     185             : static inline void SetPage##uname(struct page *page) {  }
     186             : 
     187             : #define CLEARPAGEFLAG_NOOP(uname)                                       \
     188             : static inline void ClearPage##uname(struct page *page) {  }
     189             : 
     190             : #define __CLEARPAGEFLAG_NOOP(uname)                                     \
     191             : static inline void __ClearPage##uname(struct page *page) {  }
     192             : 
     193             : #define TESTCLEARFLAG_FALSE(uname)                                      \
     194             : static inline int TestClearPage##uname(struct page *page) { return 0; }
     195             : 
     196             : #define __TESTCLEARFLAG_FALSE(uname)                                    \
     197             : static inline int __TestClearPage##uname(struct page *page) { return 0; }
     198             : 
     199             : struct page;    /* forward declaration */
     200             : 
     201             : TESTPAGEFLAG(Locked, locked) TESTSETFLAG(Locked, locked)
     202           4 : PAGEFLAG(Error, error)
     203           2 : PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
     204             : PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
     205             : PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)
     206             : PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)
     207             :         TESTCLEARFLAG(Active, active)
     208             : __PAGEFLAG(Slab, slab)
     209             : PAGEFLAG(Checked, checked)              /* Used by some filesystems */
     210             : PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)     /* Xen */
     211             : PAGEFLAG(SavePinned, savepinned);                       /* Xen */
     212             : PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
     213             : PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
     214             : 
     215             : __PAGEFLAG(SlobFree, slob_free)
     216             : 
     217             : __PAGEFLAG(SlubFrozen, slub_frozen)
     218             : __PAGEFLAG(SlubDebug, slub_debug)
     219             : 
     220             : /*
     221             :  * Private page markings that may be used by the filesystem that owns the page
     222             :  * for its own purposes.
     223             :  * - PG_private and PG_private_2 cause releasepage() and co to be invoked
     224             :  */
     225             : PAGEFLAG(Private, private) __SETPAGEFLAG(Private, private)
     226             :         __CLEARPAGEFLAG(Private, private)
     227             : PAGEFLAG(Private2, private_2) TESTSCFLAG(Private2, private_2)
     228             : PAGEFLAG(OwnerPriv1, owner_priv_1) TESTCLEARFLAG(OwnerPriv1, owner_priv_1)
     229             : 
     230             : /*
     231             :  * Only test-and-set exist for PG_writeback.  The unconditional operators are
     232             :  * risky: they bypass page accounting.
     233             :  */
     234             : TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
     235             : __PAGEFLAG(Buddy, buddy)
     236             : PAGEFLAG(MappedToDisk, mappedtodisk)
     237             : 
     238             : /* PG_readahead is only used for file reads; PG_reclaim is only for writes */
     239             : PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
     240             : PAGEFLAG(Readahead, reclaim)            /* Reminder to do async read-ahead */
     241             : 
     242             : #ifdef CONFIG_HIGHMEM
     243             : /*
     244             :  * Must use a macro here due to header dependency issues. page_zone() is not
     245             :  * available at this point.
     246             :  */
     247             : #define PageHighMem(__p) is_highmem(page_zone(__p))
     248             : #else
     249             : PAGEFLAG_FALSE(HighMem)
     250             : #endif
     251             : 
     252             : #ifdef CONFIG_SWAP
     253             : PAGEFLAG(SwapCache, swapcache)
     254             : #else
     255             : PAGEFLAG_FALSE(SwapCache)
     256             :         SETPAGEFLAG_NOOP(SwapCache) CLEARPAGEFLAG_NOOP(SwapCache)
     257             : #endif
     258             : 
     259             : PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
     260             :         TESTCLEARFLAG(Unevictable, unevictable)
     261             : 
     262             : #ifdef CONFIG_MMU
     263             : PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
     264             :         TESTSCFLAG(Mlocked, mlocked) __TESTCLEARFLAG(Mlocked, mlocked)
     265             : #else
     266             : PAGEFLAG_FALSE(Mlocked) SETPAGEFLAG_NOOP(Mlocked)
     267             :         TESTCLEARFLAG_FALSE(Mlocked) __TESTCLEARFLAG_FALSE(Mlocked)
     268             : #endif
     269             : 
     270             : #ifdef CONFIG_ARCH_USES_PG_UNCACHED
     271             : PAGEFLAG(Uncached, uncached)
     272             : #else
     273             : PAGEFLAG_FALSE(Uncached)
     274             : #endif
     275             : 
     276             : #ifdef CONFIG_MEMORY_FAILURE
     277             : PAGEFLAG(HWPoison, hwpoison)
     278             : TESTSCFLAG(HWPoison, hwpoison)
     279             : #define __PG_HWPOISON (1UL << PG_hwpoison)
     280             : #else
     281             : PAGEFLAG_FALSE(HWPoison)
     282             : #define __PG_HWPOISON 0
     283             : #endif
     284             : 
     285             : u64 stable_page_flags(struct page *page);
     286             : 
     287             : static inline int PageUptodate(struct page *page)
     288             : {
     289             :         int ret = test_bit(PG_uptodate, &(page)->flags);
     290             : 
     291             :         /*
     292             :          * Must ensure that the data we read out of the page is loaded
     293             :          * _after_ we've loaded page->flags to check for PageUptodate.
     294             :          * We can skip the barrier if the page is not uptodate, because
     295             :          * we wouldn't be reading anything from it.
     296             :          *
     297             :          * See SetPageUptodate() for the other side of the story.
     298             :          */
     299             :         if (ret)
     300             :                 smp_rmb();
     301             : 
     302             :         return ret;
     303             : }
     304             : 
     305             : static inline void __SetPageUptodate(struct page *page)
     306             : {
     307             :         smp_wmb();
     308             :         __set_bit(PG_uptodate, &(page)->flags);
     309             : }
     310             : 
     311             : static inline void SetPageUptodate(struct page *page)
     312             : {
     313             : #ifdef CONFIG_S390
     314             :         if (!test_and_set_bit(PG_uptodate, &page->flags))
     315             :                 page_clear_dirty(page);
     316             : #else
     317             :         /*
     318             :          * Memory barrier must be issued before setting the PG_uptodate bit,
     319             :          * so that all previous stores issued in order to bring the page
     320             :          * uptodate are actually visible before PageUptodate becomes true.
     321             :          *
     322             :          * s390 doesn't need an explicit smp_wmb here because the test and
     323             :          * set bit already provides full barriers.
     324             :          */
     325           1 :         smp_wmb();
     326           2 :         set_bit(PG_uptodate, &(page)->flags);
     327           1 : #endif
     328             : }
     329             : 
     330             : CLEARPAGEFLAG(Uptodate, uptodate)
     331             : 
     332             : extern void cancel_dirty_page(struct page *page, unsigned int account_size);
     333             : 
     334             : int test_clear_page_writeback(struct page *page);
     335             : int test_set_page_writeback(struct page *page);
     336             : 
     337             : static inline void set_page_writeback(struct page *page)
     338             : {
     339             :         test_set_page_writeback(page);
     340             : }
     341             : 
     342             : #ifdef CONFIG_PAGEFLAGS_EXTENDED
     343             : /*
     344             :  * System with lots of page flags available. This allows separate
     345             :  * flags for PageHead() and PageTail() checks of compound pages so that bit
     346             :  * tests can be used in performance sensitive paths. PageCompound is
     347             :  * generally not used in hot code paths.
     348             :  */
     349             : __PAGEFLAG(Head, head)
     350             : __PAGEFLAG(Tail, tail)
     351             : 
     352             : static inline int PageCompound(struct page *page)
     353             : {
     354             :         return page->flags & ((1L << PG_head) | (1L << PG_tail));
     355             : 
     356             : }
     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             :  */
     364             : TESTPAGEFLAG(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             : 
     379             : static inline int PageTail(struct page *page)
     380             : {
     381             :         return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
     382             : }
     383             : 
     384             : static inline void __SetPageTail(struct page *page)
     385             : {
     386             :         page->flags |= PG_head_tail_mask;
     387             : }
     388             : 
     389             : static inline void __ClearPageTail(struct page *page)
     390             : {
     391             :         page->flags &= ~PG_head_tail_mask;
     392             : }
     393             : 
     394             : #endif /* !PAGEFLAGS_EXTENDED */
     395             : 
     396             : #ifdef CONFIG_MMU
     397             : #define __PG_MLOCKED            (1 << PG_mlocked)
     398             : #else
     399             : #define __PG_MLOCKED            0
     400             : #endif
     401             : 
     402             : /*
     403             :  * Flags checked when a page is freed.  Pages being freed should not have
     404             :  * these flags set.  It they are, there is a problem.
     405             :  */
     406             : #define PAGE_FLAGS_CHECK_AT_FREE \
     407             :         (1 << PG_lru       | 1 << PG_locked    | \
     408             :          1 << PG_private | 1 << PG_private_2 | \
     409             :          1 << PG_buddy     | 1 << PG_writeback | 1 << PG_reserved | \
     410             :          1 << PG_slab      | 1 << PG_swapcache | 1 << PG_active | \
     411             :          1 << PG_unevictable | __PG_MLOCKED | __PG_HWPOISON)
     412             : 
     413             : /*
     414             :  * Flags checked when a page is prepped for return by the page allocator.
     415             :  * Pages being prepped should not have any flags set.  It they are set,
     416             :  * there has been a kernel bug or struct page corruption.
     417             :  */
     418             : #define PAGE_FLAGS_CHECK_AT_PREP        ((1 << NR_PAGEFLAGS) - 1)
     419             : 
     420             : #define PAGE_FLAGS_PRIVATE                              \
     421             :         (1 << PG_private | 1 << PG_private_2)
     422             : /**
     423             :  * page_has_private - Determine if page has private stuff
     424             :  * @page: The page to be checked
     425             :  *
     426             :  * Determine if a page has private stuff, indicating that release routines
     427             :  * should be invoked upon it.
     428             :  */
     429             : static inline int page_has_private(struct page *page)
     430             : {
     431             :         return !!(page->flags & PAGE_FLAGS_PRIVATE);
     432             : }
     433             : 
     434             : #endif /* !__GENERATING_BOUNDS_H */
     435             : 
     436             : #endif  /* PAGE_FLAGS_H */

Generated by: LCOV version 1.10