mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Huang Ying](/assets/img/avatar_default.png)
Patch series "THP swap: Delay splitting THP during swapping out", v11. This patchset is to optimize the performance of Transparent Huge Page (THP) swap. Recently, the performance of the storage devices improved so fast that we cannot saturate the disk bandwidth with single logical CPU when do page swap out even on a high-end server machine. Because the performance of the storage device improved faster than that of single logical CPU. And it seems that the trend will not change in the near future. On the other hand, the THP becomes more and more popular because of increased memory size. So it becomes necessary to optimize THP swap performance. The advantages of the THP swap support include: - Batch the swap operations for the THP to reduce lock acquiring/releasing, including allocating/freeing the swap space, adding/deleting to/from the swap cache, and writing/reading the swap space, etc. This will help improve the performance of the THP swap. - The THP swap space read/write will be 2M sequential IO. It is particularly helpful for the swap read, which are usually 4k random IO. This will improve the performance of the THP swap too. - It will help the memory fragmentation, especially when the THP is heavily used by the applications. The 2M continuous pages will be free up after THP swapping out. - It will improve the THP utilization on the system with the swap turned on. Because the speed for khugepaged to collapse the normal pages into the THP is quite slow. After the THP is split during the swapping out, it will take quite long time for the normal pages to collapse back into the THP after being swapped in. The high THP utilization helps the efficiency of the page based memory management too. There are some concerns regarding THP swap in, mainly because possible enlarged read/write IO size (for swap in/out) may put more overhead on the storage device. To deal with that, the THP swap in should be turned on only when necessary. For example, it can be selected via "always/never/madvise" logic, to be turned on globally, turned off globally, or turned on only for VMA with MADV_HUGEPAGE, etc. This patchset is the first step for the THP swap support. The plan is to delay splitting THP step by step, finally avoid splitting THP during the THP swapping out and swap out/in the THP as a whole. As the first step, in this patchset, the splitting huge page is delayed from almost the first step of swapping out to after allocating the swap space for the THP and adding the THP into the swap cache. This will reduce lock acquiring/releasing for the locks used for the swap cache management. With the patchset, the swap out throughput improves 15.5% (from about 3.73GB/s to about 4.31GB/s) in the vm-scalability swap-w-seq test case with 8 processes. The test is done on a Xeon E5 v3 system. The swap device used is a RAM simulated PMEM (persistent memory) device. To test the sequential swapping out, the test case creates 8 processes, which sequentially allocate and write to the anonymous pages until the RAM and part of the swap device is used up. This patch (of 5): In this patch, splitting huge page is delayed from almost the first step of swapping out to after allocating the swap space for the THP (Transparent Huge Page) and adding the THP into the swap cache. This will batch the corresponding operation, thus improve THP swap out throughput. This is the first step for the THP swap optimization. The plan is to delay splitting the THP step by step and avoid splitting the THP finally. In this patch, one swap cluster is used to hold the contents of each THP swapped out. So, the size of the swap cluster is changed to that of the THP (Transparent Huge Page) on x86_64 architecture (512). For other architectures which want such THP swap optimization, ARCH_USES_THP_SWAP_CLUSTER needs to be selected in the Kconfig file for the architecture. In effect, this will enlarge swap cluster size by 2 times on x86_64. Which may make it harder to find a free cluster when the swap space becomes fragmented. So that, this may reduce the continuous swap space allocation and sequential write in theory. The performance test in 0day shows no regressions caused by this. In the future of THP swap optimization, some information of the swapped out THP (such as compound map count) will be recorded in the swap_cluster_info data structure. The mem cgroup swap accounting functions are enhanced to support charge or uncharge a swap cluster backing a THP as a whole. The swap cluster allocate/free functions are added to allocate/free a swap cluster for a THP. A fair simple algorithm is used for swap cluster allocation, that is, only the first swap device in priority list will be tried to allocate the swap cluster. The function will fail if the trying is not successful, and the caller will fallback to allocate a single swap slot instead. This works good enough for normal cases. If the difference of the number of the free swap clusters among multiple swap devices is significant, it is possible that some THPs are split earlier than necessary. For example, this could be caused by big size difference among multiple swap devices. The swap cache functions is enhanced to support add/delete THP to/from the swap cache as a set of (HPAGE_PMD_NR) sub-pages. This may be enhanced in the future with multi-order radix tree. But because we will split the THP soon during swapping out, that optimization doesn't make much sense for this first step. The THP splitting functions are enhanced to support to split THP in swap cache during swapping out. The page lock will be held during allocating the swap cluster, adding the THP into the swap cache and splitting the THP. So in the code path other than swapping out, if the THP need to be split, the PageSwapCache(THP) will be always false. The swap cluster is only available for SSD, so the THP swap optimization in this patchset has no effect for HDD. [ying.huang@intel.com: fix two issues in THP optimize patch] Link: http://lkml.kernel.org/r/87k25ed8zo.fsf@yhuang-dev.intel.com [hannes@cmpxchg.org: extensive cleanups and simplifications, reduce code size] Link: http://lkml.kernel.org/r/20170515112522.32457-2-ying.huang@intel.com Signed-off-by: "Huang, Ying" <ying.huang@intel.com> Signed-off-by: Johannes Weiner <hannes@cmpxchg.org> Suggested-by: Andrew Morton <akpm@linux-foundation.org> [for config option] Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> [for changes in huge_memory.c and huge_mm.h] Cc: Andrea Arcangeli <aarcange@redhat.com> Cc: Ebru Akagunduz <ebru.akagunduz@gmail.com> Cc: Johannes Weiner <hannes@cmpxchg.org> Cc: Michal Hocko <mhocko@kernel.org> Cc: Tejun Heo <tj@kernel.org> Cc: Hugh Dickins <hughd@google.com> Cc: Shaohua Li <shli@kernel.org> Cc: Minchan Kim <minchan@kernel.org> Cc: Rik van Riel <riel@redhat.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
762 lines
23 KiB
C
762 lines
23 KiB
C
/*
|
|
* Macros for manipulating and testing page->flags
|
|
*/
|
|
|
|
#ifndef PAGE_FLAGS_H
|
|
#define PAGE_FLAGS_H
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/bug.h>
|
|
#include <linux/mmdebug.h>
|
|
#ifndef __GENERATING_BOUNDS_H
|
|
#include <linux/mm_types.h>
|
|
#include <generated/bounds.h>
|
|
#endif /* !__GENERATING_BOUNDS_H */
|
|
|
|
/*
|
|
* Various page->flags bits:
|
|
*
|
|
* PG_reserved is set for special pages, which can never be swapped out. Some
|
|
* of them might not even exist (eg empty_bad_page)...
|
|
*
|
|
* The PG_private bitflag is set on pagecache pages if they contain filesystem
|
|
* specific data (which is normally at page->private). It can be used by
|
|
* private allocations for its own usage.
|
|
*
|
|
* During initiation of disk I/O, PG_locked is set. This bit is set before I/O
|
|
* and cleared when writeback _starts_ or when read _completes_. PG_writeback
|
|
* is set before writeback starts and cleared when it finishes.
|
|
*
|
|
* PG_locked also pins a page in pagecache, and blocks truncation of the file
|
|
* while it is held.
|
|
*
|
|
* page_waitqueue(page) is a wait queue of all tasks waiting for the page
|
|
* to become unlocked.
|
|
*
|
|
* PG_uptodate tells whether the page's contents is valid. When a read
|
|
* completes, the page becomes uptodate, unless a disk I/O error happened.
|
|
*
|
|
* PG_referenced, PG_reclaim are used for page reclaim for anonymous and
|
|
* file-backed pagecache (see mm/vmscan.c).
|
|
*
|
|
* PG_error is set to indicate that an I/O error occurred on this page.
|
|
*
|
|
* PG_arch_1 is an architecture specific page state bit. The generic code
|
|
* guarantees that this bit is cleared for a page when it first is entered into
|
|
* the page cache.
|
|
*
|
|
* PG_highmem pages are not permanently mapped into the kernel virtual address
|
|
* space, they need to be kmapped separately for doing IO on the pages. The
|
|
* struct page (these bits with information) are always mapped into kernel
|
|
* address space...
|
|
*
|
|
* PG_hwpoison indicates that a page got corrupted in hardware and contains
|
|
* data with incorrect ECC bits that triggered a machine check. Accessing is
|
|
* not safe since it may cause another machine check. Don't touch!
|
|
*/
|
|
|
|
/*
|
|
* Don't use the *_dontuse flags. Use the macros. Otherwise you'll break
|
|
* locked- and dirty-page accounting.
|
|
*
|
|
* The page flags field is split into two parts, the main flags area
|
|
* which extends from the low bits upwards, and the fields area which
|
|
* extends from the high bits downwards.
|
|
*
|
|
* | FIELD | ... | FLAGS |
|
|
* N-1 ^ 0
|
|
* (NR_PAGEFLAGS)
|
|
*
|
|
* The fields area is reserved for fields mapping zone, node (for NUMA) and
|
|
* SPARSEMEM section (for variants of SPARSEMEM that require section ids like
|
|
* SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
|
|
*/
|
|
enum pageflags {
|
|
PG_locked, /* Page is locked. Don't touch. */
|
|
PG_error,
|
|
PG_referenced,
|
|
PG_uptodate,
|
|
PG_dirty,
|
|
PG_lru,
|
|
PG_active,
|
|
PG_waiters, /* Page has waiters, check its waitqueue. Must be bit #7 and in the same byte as "PG_locked" */
|
|
PG_slab,
|
|
PG_owner_priv_1, /* Owner use. If pagecache, fs may use*/
|
|
PG_arch_1,
|
|
PG_reserved,
|
|
PG_private, /* If pagecache, has fs-private data */
|
|
PG_private_2, /* If pagecache, has fs aux data */
|
|
PG_writeback, /* Page is under writeback */
|
|
PG_head, /* A head page */
|
|
PG_mappedtodisk, /* Has blocks allocated on-disk */
|
|
PG_reclaim, /* To be reclaimed asap */
|
|
PG_swapbacked, /* Page is backed by RAM/swap */
|
|
PG_unevictable, /* Page is "unevictable" */
|
|
#ifdef CONFIG_MMU
|
|
PG_mlocked, /* Page is vma mlocked */
|
|
#endif
|
|
#ifdef CONFIG_ARCH_USES_PG_UNCACHED
|
|
PG_uncached, /* Page has been mapped as uncached */
|
|
#endif
|
|
#ifdef CONFIG_MEMORY_FAILURE
|
|
PG_hwpoison, /* hardware poisoned page. Don't touch */
|
|
#endif
|
|
#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
|
|
PG_young,
|
|
PG_idle,
|
|
#endif
|
|
__NR_PAGEFLAGS,
|
|
|
|
/* Filesystems */
|
|
PG_checked = PG_owner_priv_1,
|
|
|
|
/* SwapBacked */
|
|
PG_swapcache = PG_owner_priv_1, /* Swap page: swp_entry_t in private */
|
|
|
|
/* Two page bits are conscripted by FS-Cache to maintain local caching
|
|
* state. These bits are set on pages belonging to the netfs's inodes
|
|
* when those inodes are being locally cached.
|
|
*/
|
|
PG_fscache = PG_private_2, /* page backed by cache */
|
|
|
|
/* XEN */
|
|
/* Pinned in Xen as a read-only pagetable page. */
|
|
PG_pinned = PG_owner_priv_1,
|
|
/* Pinned as part of domain save (see xen_mm_pin_all()). */
|
|
PG_savepinned = PG_dirty,
|
|
/* Has a grant mapping of another (foreign) domain's page. */
|
|
PG_foreign = PG_owner_priv_1,
|
|
|
|
/* SLOB */
|
|
PG_slob_free = PG_private,
|
|
|
|
/* Compound pages. Stored in first tail page's flags */
|
|
PG_double_map = PG_private_2,
|
|
|
|
/* non-lru isolated movable page */
|
|
PG_isolated = PG_reclaim,
|
|
};
|
|
|
|
#ifndef __GENERATING_BOUNDS_H
|
|
|
|
struct page; /* forward declaration */
|
|
|
|
static inline struct page *compound_head(struct page *page)
|
|
{
|
|
unsigned long head = READ_ONCE(page->compound_head);
|
|
|
|
if (unlikely(head & 1))
|
|
return (struct page *) (head - 1);
|
|
return page;
|
|
}
|
|
|
|
static __always_inline int PageTail(struct page *page)
|
|
{
|
|
return READ_ONCE(page->compound_head) & 1;
|
|
}
|
|
|
|
static __always_inline int PageCompound(struct page *page)
|
|
{
|
|
return test_bit(PG_head, &page->flags) || PageTail(page);
|
|
}
|
|
|
|
/*
|
|
* Page flags policies wrt compound pages
|
|
*
|
|
* PF_ANY:
|
|
* the page flag is relevant for small, head and tail pages.
|
|
*
|
|
* PF_HEAD:
|
|
* for compound page all operations related to the page flag applied to
|
|
* head page.
|
|
*
|
|
* PF_ONLY_HEAD:
|
|
* for compound page, callers only ever operate on the head page.
|
|
*
|
|
* PF_NO_TAIL:
|
|
* modifications of the page flag must be done on small or head pages,
|
|
* checks can be done on tail pages too.
|
|
*
|
|
* PF_NO_COMPOUND:
|
|
* the page flag is not relevant for compound pages.
|
|
*/
|
|
#define PF_ANY(page, enforce) page
|
|
#define PF_HEAD(page, enforce) compound_head(page)
|
|
#define PF_ONLY_HEAD(page, enforce) ({ \
|
|
VM_BUG_ON_PGFLAGS(PageTail(page), page); \
|
|
page;})
|
|
#define PF_NO_TAIL(page, enforce) ({ \
|
|
VM_BUG_ON_PGFLAGS(enforce && PageTail(page), page); \
|
|
compound_head(page);})
|
|
#define PF_NO_COMPOUND(page, enforce) ({ \
|
|
VM_BUG_ON_PGFLAGS(enforce && PageCompound(page), page); \
|
|
page;})
|
|
|
|
/*
|
|
* Macros to create function definitions for page flags
|
|
*/
|
|
#define TESTPAGEFLAG(uname, lname, policy) \
|
|
static __always_inline int Page##uname(struct page *page) \
|
|
{ return test_bit(PG_##lname, &policy(page, 0)->flags); }
|
|
|
|
#define SETPAGEFLAG(uname, lname, policy) \
|
|
static __always_inline void SetPage##uname(struct page *page) \
|
|
{ set_bit(PG_##lname, &policy(page, 1)->flags); }
|
|
|
|
#define CLEARPAGEFLAG(uname, lname, policy) \
|
|
static __always_inline void ClearPage##uname(struct page *page) \
|
|
{ clear_bit(PG_##lname, &policy(page, 1)->flags); }
|
|
|
|
#define __SETPAGEFLAG(uname, lname, policy) \
|
|
static __always_inline void __SetPage##uname(struct page *page) \
|
|
{ __set_bit(PG_##lname, &policy(page, 1)->flags); }
|
|
|
|
#define __CLEARPAGEFLAG(uname, lname, policy) \
|
|
static __always_inline void __ClearPage##uname(struct page *page) \
|
|
{ __clear_bit(PG_##lname, &policy(page, 1)->flags); }
|
|
|
|
#define TESTSETFLAG(uname, lname, policy) \
|
|
static __always_inline int TestSetPage##uname(struct page *page) \
|
|
{ return test_and_set_bit(PG_##lname, &policy(page, 1)->flags); }
|
|
|
|
#define TESTCLEARFLAG(uname, lname, policy) \
|
|
static __always_inline int TestClearPage##uname(struct page *page) \
|
|
{ return test_and_clear_bit(PG_##lname, &policy(page, 1)->flags); }
|
|
|
|
#define PAGEFLAG(uname, lname, policy) \
|
|
TESTPAGEFLAG(uname, lname, policy) \
|
|
SETPAGEFLAG(uname, lname, policy) \
|
|
CLEARPAGEFLAG(uname, lname, policy)
|
|
|
|
#define __PAGEFLAG(uname, lname, policy) \
|
|
TESTPAGEFLAG(uname, lname, policy) \
|
|
__SETPAGEFLAG(uname, lname, policy) \
|
|
__CLEARPAGEFLAG(uname, lname, policy)
|
|
|
|
#define TESTSCFLAG(uname, lname, policy) \
|
|
TESTSETFLAG(uname, lname, policy) \
|
|
TESTCLEARFLAG(uname, lname, policy)
|
|
|
|
#define TESTPAGEFLAG_FALSE(uname) \
|
|
static inline int Page##uname(const struct page *page) { return 0; }
|
|
|
|
#define SETPAGEFLAG_NOOP(uname) \
|
|
static inline void SetPage##uname(struct page *page) { }
|
|
|
|
#define CLEARPAGEFLAG_NOOP(uname) \
|
|
static inline void ClearPage##uname(struct page *page) { }
|
|
|
|
#define __CLEARPAGEFLAG_NOOP(uname) \
|
|
static inline void __ClearPage##uname(struct page *page) { }
|
|
|
|
#define TESTSETFLAG_FALSE(uname) \
|
|
static inline int TestSetPage##uname(struct page *page) { return 0; }
|
|
|
|
#define TESTCLEARFLAG_FALSE(uname) \
|
|
static inline int TestClearPage##uname(struct page *page) { return 0; }
|
|
|
|
#define PAGEFLAG_FALSE(uname) TESTPAGEFLAG_FALSE(uname) \
|
|
SETPAGEFLAG_NOOP(uname) CLEARPAGEFLAG_NOOP(uname)
|
|
|
|
#define TESTSCFLAG_FALSE(uname) \
|
|
TESTSETFLAG_FALSE(uname) TESTCLEARFLAG_FALSE(uname)
|
|
|
|
__PAGEFLAG(Locked, locked, PF_NO_TAIL)
|
|
PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD) __CLEARPAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)
|
|
PAGEFLAG(Error, error, PF_NO_COMPOUND) TESTCLEARFLAG(Error, error, PF_NO_COMPOUND)
|
|
PAGEFLAG(Referenced, referenced, PF_HEAD)
|
|
TESTCLEARFLAG(Referenced, referenced, PF_HEAD)
|
|
__SETPAGEFLAG(Referenced, referenced, PF_HEAD)
|
|
PAGEFLAG(Dirty, dirty, PF_HEAD) TESTSCFLAG(Dirty, dirty, PF_HEAD)
|
|
__CLEARPAGEFLAG(Dirty, dirty, PF_HEAD)
|
|
PAGEFLAG(LRU, lru, PF_HEAD) __CLEARPAGEFLAG(LRU, lru, PF_HEAD)
|
|
PAGEFLAG(Active, active, PF_HEAD) __CLEARPAGEFLAG(Active, active, PF_HEAD)
|
|
TESTCLEARFLAG(Active, active, PF_HEAD)
|
|
__PAGEFLAG(Slab, slab, PF_NO_TAIL)
|
|
__PAGEFLAG(SlobFree, slob_free, PF_NO_TAIL)
|
|
PAGEFLAG(Checked, checked, PF_NO_COMPOUND) /* Used by some filesystems */
|
|
|
|
/* Xen */
|
|
PAGEFLAG(Pinned, pinned, PF_NO_COMPOUND)
|
|
TESTSCFLAG(Pinned, pinned, PF_NO_COMPOUND)
|
|
PAGEFLAG(SavePinned, savepinned, PF_NO_COMPOUND);
|
|
PAGEFLAG(Foreign, foreign, PF_NO_COMPOUND);
|
|
|
|
PAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
|
|
__CLEARPAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
|
|
PAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
|
|
__CLEARPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
|
|
__SETPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
|
|
|
|
/*
|
|
* Private page markings that may be used by the filesystem that owns the page
|
|
* for its own purposes.
|
|
* - PG_private and PG_private_2 cause releasepage() and co to be invoked
|
|
*/
|
|
PAGEFLAG(Private, private, PF_ANY) __SETPAGEFLAG(Private, private, PF_ANY)
|
|
__CLEARPAGEFLAG(Private, private, PF_ANY)
|
|
PAGEFLAG(Private2, private_2, PF_ANY) TESTSCFLAG(Private2, private_2, PF_ANY)
|
|
PAGEFLAG(OwnerPriv1, owner_priv_1, PF_ANY)
|
|
TESTCLEARFLAG(OwnerPriv1, owner_priv_1, PF_ANY)
|
|
|
|
/*
|
|
* Only test-and-set exist for PG_writeback. The unconditional operators are
|
|
* risky: they bypass page accounting.
|
|
*/
|
|
TESTPAGEFLAG(Writeback, writeback, PF_NO_COMPOUND)
|
|
TESTSCFLAG(Writeback, writeback, PF_NO_COMPOUND)
|
|
PAGEFLAG(MappedToDisk, mappedtodisk, PF_NO_TAIL)
|
|
|
|
/* PG_readahead is only used for reads; PG_reclaim is only for writes */
|
|
PAGEFLAG(Reclaim, reclaim, PF_NO_TAIL)
|
|
TESTCLEARFLAG(Reclaim, reclaim, PF_NO_TAIL)
|
|
PAGEFLAG(Readahead, reclaim, PF_NO_COMPOUND)
|
|
TESTCLEARFLAG(Readahead, reclaim, PF_NO_COMPOUND)
|
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
/*
|
|
* Must use a macro here due to header dependency issues. page_zone() is not
|
|
* available at this point.
|
|
*/
|
|
#define PageHighMem(__p) is_highmem_idx(page_zonenum(__p))
|
|
#else
|
|
PAGEFLAG_FALSE(HighMem)
|
|
#endif
|
|
|
|
#ifdef CONFIG_SWAP
|
|
static __always_inline int PageSwapCache(struct page *page)
|
|
{
|
|
#ifdef CONFIG_THP_SWAP
|
|
page = compound_head(page);
|
|
#endif
|
|
return PageSwapBacked(page) && test_bit(PG_swapcache, &page->flags);
|
|
|
|
}
|
|
SETPAGEFLAG(SwapCache, swapcache, PF_NO_TAIL)
|
|
CLEARPAGEFLAG(SwapCache, swapcache, PF_NO_TAIL)
|
|
#else
|
|
PAGEFLAG_FALSE(SwapCache)
|
|
#endif
|
|
|
|
PAGEFLAG(Unevictable, unevictable, PF_HEAD)
|
|
__CLEARPAGEFLAG(Unevictable, unevictable, PF_HEAD)
|
|
TESTCLEARFLAG(Unevictable, unevictable, PF_HEAD)
|
|
|
|
#ifdef CONFIG_MMU
|
|
PAGEFLAG(Mlocked, mlocked, PF_NO_TAIL)
|
|
__CLEARPAGEFLAG(Mlocked, mlocked, PF_NO_TAIL)
|
|
TESTSCFLAG(Mlocked, mlocked, PF_NO_TAIL)
|
|
#else
|
|
PAGEFLAG_FALSE(Mlocked) __CLEARPAGEFLAG_NOOP(Mlocked)
|
|
TESTSCFLAG_FALSE(Mlocked)
|
|
#endif
|
|
|
|
#ifdef CONFIG_ARCH_USES_PG_UNCACHED
|
|
PAGEFLAG(Uncached, uncached, PF_NO_COMPOUND)
|
|
#else
|
|
PAGEFLAG_FALSE(Uncached)
|
|
#endif
|
|
|
|
#ifdef CONFIG_MEMORY_FAILURE
|
|
PAGEFLAG(HWPoison, hwpoison, PF_ANY)
|
|
TESTSCFLAG(HWPoison, hwpoison, PF_ANY)
|
|
#define __PG_HWPOISON (1UL << PG_hwpoison)
|
|
#else
|
|
PAGEFLAG_FALSE(HWPoison)
|
|
#define __PG_HWPOISON 0
|
|
#endif
|
|
|
|
#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
|
|
TESTPAGEFLAG(Young, young, PF_ANY)
|
|
SETPAGEFLAG(Young, young, PF_ANY)
|
|
TESTCLEARFLAG(Young, young, PF_ANY)
|
|
PAGEFLAG(Idle, idle, PF_ANY)
|
|
#endif
|
|
|
|
/*
|
|
* On an anonymous page mapped into a user virtual memory area,
|
|
* page->mapping points to its anon_vma, not to a struct address_space;
|
|
* with the PAGE_MAPPING_ANON bit set to distinguish it. See rmap.h.
|
|
*
|
|
* On an anonymous page in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
|
|
* the PAGE_MAPPING_MOVABLE bit may be set along with the PAGE_MAPPING_ANON
|
|
* bit; and then page->mapping points, not to an anon_vma, but to a private
|
|
* structure which KSM associates with that merged page. See ksm.h.
|
|
*
|
|
* PAGE_MAPPING_KSM without PAGE_MAPPING_ANON is used for non-lru movable
|
|
* page and then page->mapping points a struct address_space.
|
|
*
|
|
* Please note that, confusingly, "page_mapping" refers to the inode
|
|
* address_space which maps the page from disk; whereas "page_mapped"
|
|
* refers to user virtual address space into which the page is mapped.
|
|
*/
|
|
#define PAGE_MAPPING_ANON 0x1
|
|
#define PAGE_MAPPING_MOVABLE 0x2
|
|
#define PAGE_MAPPING_KSM (PAGE_MAPPING_ANON | PAGE_MAPPING_MOVABLE)
|
|
#define PAGE_MAPPING_FLAGS (PAGE_MAPPING_ANON | PAGE_MAPPING_MOVABLE)
|
|
|
|
static __always_inline int PageMappingFlags(struct page *page)
|
|
{
|
|
return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) != 0;
|
|
}
|
|
|
|
static __always_inline int PageAnon(struct page *page)
|
|
{
|
|
page = compound_head(page);
|
|
return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
|
|
}
|
|
|
|
static __always_inline int __PageMovable(struct page *page)
|
|
{
|
|
return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
|
|
PAGE_MAPPING_MOVABLE;
|
|
}
|
|
|
|
#ifdef CONFIG_KSM
|
|
/*
|
|
* A KSM page is one of those write-protected "shared pages" or "merged pages"
|
|
* which KSM maps into multiple mms, wherever identical anonymous page content
|
|
* is found in VM_MERGEABLE vmas. It's a PageAnon page, pointing not to any
|
|
* anon_vma, but to that page's node of the stable tree.
|
|
*/
|
|
static __always_inline int PageKsm(struct page *page)
|
|
{
|
|
page = compound_head(page);
|
|
return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
|
|
PAGE_MAPPING_KSM;
|
|
}
|
|
#else
|
|
TESTPAGEFLAG_FALSE(Ksm)
|
|
#endif
|
|
|
|
u64 stable_page_flags(struct page *page);
|
|
|
|
static inline int PageUptodate(struct page *page)
|
|
{
|
|
int ret;
|
|
page = compound_head(page);
|
|
ret = test_bit(PG_uptodate, &(page)->flags);
|
|
/*
|
|
* Must ensure that the data we read out of the page is loaded
|
|
* _after_ we've loaded page->flags to check for PageUptodate.
|
|
* We can skip the barrier if the page is not uptodate, because
|
|
* we wouldn't be reading anything from it.
|
|
*
|
|
* See SetPageUptodate() for the other side of the story.
|
|
*/
|
|
if (ret)
|
|
smp_rmb();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static __always_inline void __SetPageUptodate(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(PageTail(page), page);
|
|
smp_wmb();
|
|
__set_bit(PG_uptodate, &page->flags);
|
|
}
|
|
|
|
static __always_inline void SetPageUptodate(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(PageTail(page), page);
|
|
/*
|
|
* Memory barrier must be issued before setting the PG_uptodate bit,
|
|
* so that all previous stores issued in order to bring the page
|
|
* uptodate are actually visible before PageUptodate becomes true.
|
|
*/
|
|
smp_wmb();
|
|
set_bit(PG_uptodate, &page->flags);
|
|
}
|
|
|
|
CLEARPAGEFLAG(Uptodate, uptodate, PF_NO_TAIL)
|
|
|
|
int test_clear_page_writeback(struct page *page);
|
|
int __test_set_page_writeback(struct page *page, bool keep_write);
|
|
|
|
#define test_set_page_writeback(page) \
|
|
__test_set_page_writeback(page, false)
|
|
#define test_set_page_writeback_keepwrite(page) \
|
|
__test_set_page_writeback(page, true)
|
|
|
|
static inline void set_page_writeback(struct page *page)
|
|
{
|
|
test_set_page_writeback(page);
|
|
}
|
|
|
|
static inline void set_page_writeback_keepwrite(struct page *page)
|
|
{
|
|
test_set_page_writeback_keepwrite(page);
|
|
}
|
|
|
|
__PAGEFLAG(Head, head, PF_ANY) CLEARPAGEFLAG(Head, head, PF_ANY)
|
|
|
|
static __always_inline void set_compound_head(struct page *page, struct page *head)
|
|
{
|
|
WRITE_ONCE(page->compound_head, (unsigned long)head + 1);
|
|
}
|
|
|
|
static __always_inline void clear_compound_head(struct page *page)
|
|
{
|
|
WRITE_ONCE(page->compound_head, 0);
|
|
}
|
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
static inline void ClearPageCompound(struct page *page)
|
|
{
|
|
BUG_ON(!PageHead(page));
|
|
ClearPageHead(page);
|
|
}
|
|
#endif
|
|
|
|
#define PG_head_mask ((1UL << PG_head))
|
|
|
|
#ifdef CONFIG_HUGETLB_PAGE
|
|
int PageHuge(struct page *page);
|
|
int PageHeadHuge(struct page *page);
|
|
bool page_huge_active(struct page *page);
|
|
#else
|
|
TESTPAGEFLAG_FALSE(Huge)
|
|
TESTPAGEFLAG_FALSE(HeadHuge)
|
|
|
|
static inline bool page_huge_active(struct page *page)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
/*
|
|
* PageHuge() only returns true for hugetlbfs pages, but not for
|
|
* normal or transparent huge pages.
|
|
*
|
|
* PageTransHuge() returns true for both transparent huge and
|
|
* hugetlbfs pages, but not normal pages. PageTransHuge() can only be
|
|
* called only in the core VM paths where hugetlbfs pages can't exist.
|
|
*/
|
|
static inline int PageTransHuge(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(PageTail(page), page);
|
|
return PageHead(page);
|
|
}
|
|
|
|
/*
|
|
* PageTransCompound returns true for both transparent huge pages
|
|
* and hugetlbfs pages, so it should only be called when it's known
|
|
* that hugetlbfs pages aren't involved.
|
|
*/
|
|
static inline int PageTransCompound(struct page *page)
|
|
{
|
|
return PageCompound(page);
|
|
}
|
|
|
|
/*
|
|
* PageTransCompoundMap is the same as PageTransCompound, but it also
|
|
* guarantees the primary MMU has the entire compound page mapped
|
|
* through pmd_trans_huge, which in turn guarantees the secondary MMUs
|
|
* can also map the entire compound page. This allows the secondary
|
|
* MMUs to call get_user_pages() only once for each compound page and
|
|
* to immediately map the entire compound page with a single secondary
|
|
* MMU fault. If there will be a pmd split later, the secondary MMUs
|
|
* will get an update through the MMU notifier invalidation through
|
|
* split_huge_pmd().
|
|
*
|
|
* Unlike PageTransCompound, this is safe to be called only while
|
|
* split_huge_pmd() cannot run from under us, like if protected by the
|
|
* MMU notifier, otherwise it may result in page->_mapcount < 0 false
|
|
* positives.
|
|
*/
|
|
static inline int PageTransCompoundMap(struct page *page)
|
|
{
|
|
return PageTransCompound(page) && atomic_read(&page->_mapcount) < 0;
|
|
}
|
|
|
|
/*
|
|
* PageTransTail returns true for both transparent huge pages
|
|
* and hugetlbfs pages, so it should only be called when it's known
|
|
* that hugetlbfs pages aren't involved.
|
|
*/
|
|
static inline int PageTransTail(struct page *page)
|
|
{
|
|
return PageTail(page);
|
|
}
|
|
|
|
/*
|
|
* PageDoubleMap indicates that the compound page is mapped with PTEs as well
|
|
* as PMDs.
|
|
*
|
|
* This is required for optimization of rmap operations for THP: we can postpone
|
|
* per small page mapcount accounting (and its overhead from atomic operations)
|
|
* until the first PMD split.
|
|
*
|
|
* For the page PageDoubleMap means ->_mapcount in all sub-pages is offset up
|
|
* by one. This reference will go away with last compound_mapcount.
|
|
*
|
|
* See also __split_huge_pmd_locked() and page_remove_anon_compound_rmap().
|
|
*/
|
|
static inline int PageDoubleMap(struct page *page)
|
|
{
|
|
return PageHead(page) && test_bit(PG_double_map, &page[1].flags);
|
|
}
|
|
|
|
static inline void SetPageDoubleMap(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageHead(page), page);
|
|
set_bit(PG_double_map, &page[1].flags);
|
|
}
|
|
|
|
static inline void ClearPageDoubleMap(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageHead(page), page);
|
|
clear_bit(PG_double_map, &page[1].flags);
|
|
}
|
|
static inline int TestSetPageDoubleMap(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageHead(page), page);
|
|
return test_and_set_bit(PG_double_map, &page[1].flags);
|
|
}
|
|
|
|
static inline int TestClearPageDoubleMap(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageHead(page), page);
|
|
return test_and_clear_bit(PG_double_map, &page[1].flags);
|
|
}
|
|
|
|
#else
|
|
TESTPAGEFLAG_FALSE(TransHuge)
|
|
TESTPAGEFLAG_FALSE(TransCompound)
|
|
TESTPAGEFLAG_FALSE(TransCompoundMap)
|
|
TESTPAGEFLAG_FALSE(TransTail)
|
|
PAGEFLAG_FALSE(DoubleMap)
|
|
TESTSETFLAG_FALSE(DoubleMap)
|
|
TESTCLEARFLAG_FALSE(DoubleMap)
|
|
#endif
|
|
|
|
/*
|
|
* For pages that are never mapped to userspace, page->mapcount may be
|
|
* used for storing extra information about page type. Any value used
|
|
* for this purpose must be <= -2, but it's better start not too close
|
|
* to -2 so that an underflow of the page_mapcount() won't be mistaken
|
|
* for a special page.
|
|
*/
|
|
#define PAGE_MAPCOUNT_OPS(uname, lname) \
|
|
static __always_inline int Page##uname(struct page *page) \
|
|
{ \
|
|
return atomic_read(&page->_mapcount) == \
|
|
PAGE_##lname##_MAPCOUNT_VALUE; \
|
|
} \
|
|
static __always_inline void __SetPage##uname(struct page *page) \
|
|
{ \
|
|
VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page); \
|
|
atomic_set(&page->_mapcount, PAGE_##lname##_MAPCOUNT_VALUE); \
|
|
} \
|
|
static __always_inline void __ClearPage##uname(struct page *page) \
|
|
{ \
|
|
VM_BUG_ON_PAGE(!Page##uname(page), page); \
|
|
atomic_set(&page->_mapcount, -1); \
|
|
}
|
|
|
|
/*
|
|
* PageBuddy() indicate that the page is free and in the buddy system
|
|
* (see mm/page_alloc.c).
|
|
*/
|
|
#define PAGE_BUDDY_MAPCOUNT_VALUE (-128)
|
|
PAGE_MAPCOUNT_OPS(Buddy, BUDDY)
|
|
|
|
/*
|
|
* PageBalloon() is set on pages that are on the balloon page list
|
|
* (see mm/balloon_compaction.c).
|
|
*/
|
|
#define PAGE_BALLOON_MAPCOUNT_VALUE (-256)
|
|
PAGE_MAPCOUNT_OPS(Balloon, BALLOON)
|
|
|
|
/*
|
|
* If kmemcg is enabled, the buddy allocator will set PageKmemcg() on
|
|
* pages allocated with __GFP_ACCOUNT. It gets cleared on page free.
|
|
*/
|
|
#define PAGE_KMEMCG_MAPCOUNT_VALUE (-512)
|
|
PAGE_MAPCOUNT_OPS(Kmemcg, KMEMCG)
|
|
|
|
extern bool is_free_buddy_page(struct page *page);
|
|
|
|
__PAGEFLAG(Isolated, isolated, PF_ANY);
|
|
|
|
/*
|
|
* If network-based swap is enabled, sl*b must keep track of whether pages
|
|
* were allocated from pfmemalloc reserves.
|
|
*/
|
|
static inline int PageSlabPfmemalloc(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageSlab(page), page);
|
|
return PageActive(page);
|
|
}
|
|
|
|
static inline void SetPageSlabPfmemalloc(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageSlab(page), page);
|
|
SetPageActive(page);
|
|
}
|
|
|
|
static inline void __ClearPageSlabPfmemalloc(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageSlab(page), page);
|
|
__ClearPageActive(page);
|
|
}
|
|
|
|
static inline void ClearPageSlabPfmemalloc(struct page *page)
|
|
{
|
|
VM_BUG_ON_PAGE(!PageSlab(page), page);
|
|
ClearPageActive(page);
|
|
}
|
|
|
|
#ifdef CONFIG_MMU
|
|
#define __PG_MLOCKED (1UL << PG_mlocked)
|
|
#else
|
|
#define __PG_MLOCKED 0
|
|
#endif
|
|
|
|
/*
|
|
* Flags checked when a page is freed. Pages being freed should not have
|
|
* these flags set. It they are, there is a problem.
|
|
*/
|
|
#define PAGE_FLAGS_CHECK_AT_FREE \
|
|
(1UL << PG_lru | 1UL << PG_locked | \
|
|
1UL << PG_private | 1UL << PG_private_2 | \
|
|
1UL << PG_writeback | 1UL << PG_reserved | \
|
|
1UL << PG_slab | 1UL << PG_active | \
|
|
1UL << PG_unevictable | __PG_MLOCKED)
|
|
|
|
/*
|
|
* Flags checked when a page is prepped for return by the page allocator.
|
|
* Pages being prepped should not have these flags set. It they are set,
|
|
* there has been a kernel bug or struct page corruption.
|
|
*
|
|
* __PG_HWPOISON is exceptional because it needs to be kept beyond page's
|
|
* alloc-free cycle to prevent from reusing the page.
|
|
*/
|
|
#define PAGE_FLAGS_CHECK_AT_PREP \
|
|
(((1UL << NR_PAGEFLAGS) - 1) & ~__PG_HWPOISON)
|
|
|
|
#define PAGE_FLAGS_PRIVATE \
|
|
(1UL << PG_private | 1UL << PG_private_2)
|
|
/**
|
|
* page_has_private - Determine if page has private stuff
|
|
* @page: The page to be checked
|
|
*
|
|
* Determine if a page has private stuff, indicating that release routines
|
|
* should be invoked upon it.
|
|
*/
|
|
static inline int page_has_private(struct page *page)
|
|
{
|
|
return !!(page->flags & PAGE_FLAGS_PRIVATE);
|
|
}
|
|
|
|
#undef PF_ANY
|
|
#undef PF_HEAD
|
|
#undef PF_ONLY_HEAD
|
|
#undef PF_NO_TAIL
|
|
#undef PF_NO_COMPOUND
|
|
#endif /* !__GENERATING_BOUNDS_H */
|
|
|
|
#endif /* PAGE_FLAGS_H */
|