License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 17:07:57 +03:00
// SPDX-License-Identifier: GPL-2.0
2006-03-22 11:09:12 +03:00
/*
2015-11-06 05:49:43 +03:00
* Memory Migration functionality - linux / mm / migrate . c
2006-03-22 11:09:12 +03:00
*
* Copyright ( C ) 2006 Silicon Graphics , Inc . , Christoph Lameter
*
* Page migration was first developed in the context of the memory hotplug
* project . The main authors of the migration code are :
*
* IWAMOTO Toshihiro < iwamoto @ valinux . co . jp >
* Hirokazu Takahashi < taka @ valinux . co . jp >
* Dave Hansen < haveblue @ us . ibm . com >
2008-07-04 20:59:22 +04:00
* Christoph Lameter
2006-03-22 11:09:12 +03:00
*/
# include <linux/migrate.h>
2011-10-16 10:01:52 +04:00
# include <linux/export.h>
2006-03-22 11:09:12 +03:00
# include <linux/swap.h>
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
# include <linux/swapops.h>
2006-03-22 11:09:12 +03:00
# include <linux/pagemap.h>
2006-04-11 09:52:57 +04:00
# include <linux/buffer_head.h>
2006-03-22 11:09:12 +03:00
# include <linux/mm_inline.h>
2007-10-19 10:40:14 +04:00
# include <linux/nsproxy.h>
2006-03-22 11:09:12 +03:00
# include <linux/pagevec.h>
ksm: rmap_walk to remove_migation_ptes
A side-effect of making ksm pages swappable is that they have to be placed
on the LRUs: which then exposes them to isolate_lru_page() and hence to
page migration.
Add rmap_walk() for remove_migration_ptes() to use: rmap_walk_anon() and
rmap_walk_file() in rmap.c, but rmap_walk_ksm() in ksm.c. Perhaps some
consolidation with existing code is possible, but don't attempt that yet
(try_to_unmap needs to handle nonlinears, but migration pte removal does
not).
rmap_walk() is sadly less general than it appears: rmap_walk_anon(), like
remove_anon_migration_ptes() which it replaces, avoids calling
page_lock_anon_vma(), because that includes a page_mapped() test which
fails when all migration ptes are in place. That was valid when NUMA page
migration was introduced (holding mmap_sem provided the missing guarantee
that anon_vma's slab had not already been destroyed), but I believe not
valid in the memory hotremove case added since.
For now do the same as before, and consider the best way to fix that
unlikely race later on. When fixed, we can probably use rmap_walk() on
hwpoisoned ksm pages too: for now, they remain among hwpoison's various
exceptions (its PageKsm test comes before the page is locked, but its
page_lock_anon_vma fails safely if an anon gets upgraded).
Signed-off-by: Hugh Dickins <hugh.dickins@tiscali.co.uk>
Cc: Izik Eidus <ieidus@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Chris Wright <chrisw@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-15 04:59:31 +03:00
# include <linux/ksm.h>
2006-03-22 11:09:12 +03:00
# include <linux/rmap.h>
# include <linux/topology.h>
# include <linux/cpu.h>
# include <linux/cpuset.h>
2006-06-23 13:03:38 +04:00
# include <linux/writeback.h>
2006-06-23 13:03:55 +04:00
# include <linux/mempolicy.h>
# include <linux/vmalloc.h>
2006-06-23 13:04:02 +04:00
# include <linux/security.h>
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
# include <linux/backing-dev.h>
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
# include <linux/compaction.h>
2008-07-24 08:27:02 +04:00
# include <linux/syscalls.h>
2018-03-17 18:08:03 +03:00
# include <linux/compat.h>
2010-09-08 05:19:35 +04:00
# include <linux/hugetlb.h>
2012-08-01 03:42:27 +04:00
# include <linux/hugetlb_cgroup.h>
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
# include <linux/gfp.h>
2017-09-09 02:12:24 +03:00
# include <linux/pfn_t.h>
2017-09-09 02:12:17 +03:00
# include <linux/memremap.h>
2017-09-09 02:12:21 +03:00
# include <linux/userfaultfd_k.h>
2012-12-12 04:02:42 +04:00
# include <linux/balloon_compaction.h>
2013-12-19 05:08:33 +04:00
# include <linux/mmu_notifier.h>
mm: introduce idle page tracking
Knowing the portion of memory that is not used by a certain application or
memory cgroup (idle memory) can be useful for partitioning the system
efficiently, e.g. by setting memory cgroup limits appropriately.
Currently, the only means to estimate the amount of idle memory provided
by the kernel is /proc/PID/{clear_refs,smaps}: the user can clear the
access bit for all pages mapped to a particular process by writing 1 to
clear_refs, wait for some time, and then count smaps:Referenced. However,
this method has two serious shortcomings:
- it does not count unmapped file pages
- it affects the reclaimer logic
To overcome these drawbacks, this patch introduces two new page flags,
Idle and Young, and a new sysfs file, /sys/kernel/mm/page_idle/bitmap.
A page's Idle flag can only be set from userspace by setting bit in
/sys/kernel/mm/page_idle/bitmap at the offset corresponding to the page,
and it is cleared whenever the page is accessed either through page tables
(it is cleared in page_referenced() in this case) or using the read(2)
system call (mark_page_accessed()). Thus by setting the Idle flag for
pages of a particular workload, which can be found e.g. by reading
/proc/PID/pagemap, waiting for some time to let the workload access its
working set, and then reading the bitmap file, one can estimate the amount
of pages that are not used by the workload.
The Young page flag is used to avoid interference with the memory
reclaimer. A page's Young flag is set whenever the Access bit of a page
table entry pointing to the page is cleared by writing to the bitmap file.
If page_referenced() is called on a Young page, it will add 1 to its
return value, therefore concealing the fact that the Access bit was
cleared.
Note, since there is no room for extra page flags on 32 bit, this feature
uses extended page flags when compiled on 32 bit.
[akpm@linux-foundation.org: fix build]
[akpm@linux-foundation.org: kpageidle requires an MMU]
[akpm@linux-foundation.org: decouple from page-flags rework]
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Reviewed-by: Andres Lagar-Cavilla <andreslc@google.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Raghavendra K T <raghavendra.kt@linux.vnet.ibm.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Greg Thelen <gthelen@google.com>
Cc: Michel Lespinasse <walken@google.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Pavel Emelyanov <xemul@parallels.com>
Cc: Cyrill Gorcunov <gorcunov@openvz.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-09-10 01:35:45 +03:00
# include <linux/page_idle.h>
2016-03-16 00:56:15 +03:00
# include <linux/page_owner.h>
2017-02-08 20:51:29 +03:00
# include <linux/sched/mm.h>
2017-08-20 23:26:27 +03:00
# include <linux/ptrace.h>
2006-03-22 11:09:12 +03:00
2010-12-22 04:24:26 +03:00
# include <asm/tlbflush.h>
2012-10-19 17:07:31 +04:00
# define CREATE_TRACE_POINTS
# include <trace/events/migrate.h>
2006-03-22 11:09:12 +03:00
# include "internal.h"
/*
2006-06-23 13:03:55 +04:00
* migrate_prep ( ) needs to be called before we start compiling a list of pages
2010-05-25 01:32:27 +04:00
* to be migrated using isolate_lru_page ( ) . If scheduling work on other CPUs is
* undesirable , use migrate_prep_local ( )
2006-03-22 11:09:12 +03:00
*/
int migrate_prep ( void )
{
/*
* Clear the LRU lists so pages can be isolated .
* Note that pages may be moved off the LRU after we have
* drained them . Those pages will fail to migrate like other
* pages that may be busy .
*/
lru_add_drain_all ( ) ;
return 0 ;
}
2010-05-25 01:32:27 +04:00
/* Do the necessary work of migrate_prep but not if it involves other CPUs */
int migrate_prep_local ( void )
{
lru_add_drain ( ) ;
return 0 ;
}
2017-02-25 01:57:29 +03:00
int isolate_movable_page ( struct page * page , isolate_mode_t mode )
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
{
struct address_space * mapping ;
/*
* Avoid burning cycles with pages that are yet under __free_pages ( ) ,
* or just got freed under us .
*
* In case we ' win ' a race for a movable page being freed under us and
* raise its refcount preventing __free_pages ( ) from doing its job
* the put_page ( ) at the end of this block will take care of
* release this page , thus avoiding a nasty leakage .
*/
if ( unlikely ( ! get_page_unless_zero ( page ) ) )
goto out ;
/*
* Check PageMovable before holding a PG_lock because page ' s owner
* assumes anybody doesn ' t touch PG_lock of newly allocated page
* so unconditionally grapping the lock ruins page ' s owner side .
*/
if ( unlikely ( ! __PageMovable ( page ) ) )
goto out_putpage ;
/*
* As movable pages are not isolated from LRU lists , concurrent
* compaction threads can race against page migration functions
* as well as race against the releasing a page .
*
* In order to avoid having an already isolated movable page
* being ( wrongly ) re - isolated while it is under migration ,
* or to avoid attempting to isolate pages being released ,
* lets be sure we have the page lock
* before proceeding with the movable page isolation steps .
*/
if ( unlikely ( ! trylock_page ( page ) ) )
goto out_putpage ;
if ( ! PageMovable ( page ) | | PageIsolated ( page ) )
goto out_no_isolated ;
mapping = page_mapping ( page ) ;
VM_BUG_ON_PAGE ( ! mapping , page ) ;
if ( ! mapping - > a_ops - > isolate_page ( page , mode ) )
goto out_no_isolated ;
/* Driver shouldn't use PG_isolated bit of page->flags */
WARN_ON_ONCE ( PageIsolated ( page ) ) ;
__SetPageIsolated ( page ) ;
unlock_page ( page ) ;
2017-02-25 01:57:29 +03:00
return 0 ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
out_no_isolated :
unlock_page ( page ) ;
out_putpage :
put_page ( page ) ;
out :
2017-02-25 01:57:29 +03:00
return - EBUSY ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
}
/* It should be called on page which is PG_movable */
void putback_movable_page ( struct page * page )
{
struct address_space * mapping ;
VM_BUG_ON_PAGE ( ! PageLocked ( page ) , page ) ;
VM_BUG_ON_PAGE ( ! PageMovable ( page ) , page ) ;
VM_BUG_ON_PAGE ( ! PageIsolated ( page ) , page ) ;
mapping = page_mapping ( page ) ;
mapping - > a_ops - > putback_page ( page ) ;
__ClearPageIsolated ( page ) ;
}
2012-12-12 04:02:47 +04:00
/*
* Put previously isolated pages back onto the appropriate lists
* from where they were once taken off for compaction / migration .
*
2014-01-22 03:51:17 +04:00
* This function shall be used whenever the isolated pageset has been
* built from lru , balloon , hugetlbfs page . See isolate_migratepages_range ( )
* and isolate_huge_page ( ) .
2012-12-12 04:02:47 +04:00
*/
void putback_movable_pages ( struct list_head * l )
{
struct page * page ;
struct page * page2 ;
2006-03-22 11:09:12 +03:00
list_for_each_entry_safe ( page , page2 , l , lru ) {
mm: migrate: make core migration code aware of hugepage
Currently hugepage migration is available only for soft offlining, but
it's also useful for some other users of page migration (clearly because
users of hugepage can enjoy the benefit of mempolicy and memory hotplug.)
So this patchset tries to extend such users to support hugepage migration.
The target of this patchset is to enable hugepage migration for NUMA
related system calls (migrate_pages(2), move_pages(2), and mbind(2)), and
memory hotplug.
This patchset does not add hugepage migration for memory compaction,
because users of memory compaction mainly expect to construct thp by
arranging raw pages, and there's little or no need to compact hugepages.
CMA, another user of page migration, can have benefit from hugepage
migration, but is not enabled to support it for now (just because of lack
of testing and expertise in CMA.)
Hugepage migration of non pmd-based hugepage (for example 1GB hugepage in
x86_64, or hugepages in architectures like ia64) is not enabled for now
(again, because of lack of testing.)
As for how these are achived, I extended the API (migrate_pages()) to
handle hugepage (with patch 1 and 2) and adjusted code of each caller to
check and collect movable hugepages (with patch 3-7). Remaining 2 patches
are kind of miscellaneous ones to avoid unexpected behavior. Patch 8 is
about making sure that we only migrate pmd-based hugepages. And patch 9
is about choosing appropriate zone for hugepage allocation.
My test is mainly functional one, simply kicking hugepage migration via
each entry point and confirm that migration is done correctly. Test code
is available here:
git://github.com/Naoya-Horiguchi/test_hugepage_migration_extension.git
And I always run libhugetlbfs test when changing hugetlbfs's code. With
this patchset, no regression was found in the test.
This patch (of 9):
Before enabling each user of page migration to support hugepage,
this patch enables the list of pages for migration to link not only
LRU pages, but also hugepages. As a result, putback_movable_pages()
and migrate_pages() can handle both of LRU pages and hugepages.
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Reviewed-by: Wanpeng Li <liwanp@linux.vnet.ibm.com>
Acked-by: Hillf Danton <dhillf@gmail.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-09-12 01:21:59 +04:00
if ( unlikely ( PageHuge ( page ) ) ) {
putback_active_hugepage ( page ) ;
continue ;
}
2006-06-23 13:03:51 +04:00
list_del ( & page - > lru ) ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
/*
* We isolated non - lru movable page so here we can use
* __PageMovable because LRU page ' s mapping cannot have
* PAGE_MAPPING_MOVABLE .
*/
2016-07-27 01:23:09 +03:00
if ( unlikely ( __PageMovable ( page ) ) ) {
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
VM_BUG_ON_PAGE ( ! PageIsolated ( page ) , page ) ;
lock_page ( page ) ;
if ( PageMovable ( page ) )
putback_movable_page ( page ) ;
else
__ClearPageIsolated ( page ) ;
unlock_page ( page ) ;
put_page ( page ) ;
} else {
2017-09-09 02:11:12 +03:00
mod_node_page_state ( page_pgdat ( page ) , NR_ISOLATED_ANON +
page_is_file_cache ( page ) , - hpage_nr_pages ( page ) ) ;
2017-04-21 00:37:46 +03:00
putback_lru_page ( page ) ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
}
2006-03-22 11:09:12 +03:00
}
}
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
/*
* Restore a potential migration pte to a working pte entry
*/
2017-05-04 00:54:27 +03:00
static bool remove_migration_pte ( struct page * page , struct vm_area_struct * vma ,
ksm: rmap_walk to remove_migation_ptes
A side-effect of making ksm pages swappable is that they have to be placed
on the LRUs: which then exposes them to isolate_lru_page() and hence to
page migration.
Add rmap_walk() for remove_migration_ptes() to use: rmap_walk_anon() and
rmap_walk_file() in rmap.c, but rmap_walk_ksm() in ksm.c. Perhaps some
consolidation with existing code is possible, but don't attempt that yet
(try_to_unmap needs to handle nonlinears, but migration pte removal does
not).
rmap_walk() is sadly less general than it appears: rmap_walk_anon(), like
remove_anon_migration_ptes() which it replaces, avoids calling
page_lock_anon_vma(), because that includes a page_mapped() test which
fails when all migration ptes are in place. That was valid when NUMA page
migration was introduced (holding mmap_sem provided the missing guarantee
that anon_vma's slab had not already been destroyed), but I believe not
valid in the memory hotremove case added since.
For now do the same as before, and consider the best way to fix that
unlikely race later on. When fixed, we can probably use rmap_walk() on
hwpoisoned ksm pages too: for now, they remain among hwpoison's various
exceptions (its PageKsm test comes before the page is locked, but its
page_lock_anon_vma fails safely if an anon gets upgraded).
Signed-off-by: Hugh Dickins <hugh.dickins@tiscali.co.uk>
Cc: Izik Eidus <ieidus@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Chris Wright <chrisw@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-15 04:59:31 +03:00
unsigned long addr , void * old )
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
{
2017-02-25 01:58:16 +03:00
struct page_vma_mapped_walk pvmw = {
. page = old ,
. vma = vma ,
. address = addr ,
. flags = PVMW_SYNC | PVMW_MIGRATION ,
} ;
struct page * new ;
pte_t pte ;
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
swp_entry_t entry ;
2017-02-25 01:58:16 +03:00
VM_BUG_ON_PAGE ( PageTail ( page ) , page ) ;
while ( page_vma_mapped_walk ( & pvmw ) ) {
2017-04-01 01:11:44 +03:00
if ( PageKsm ( page ) )
new = page ;
else
new = page - pvmw . page - > index +
linear_page_index ( vma , pvmw . address ) ;
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
2017-09-09 02:10:57 +03:00
# ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
/* PMD-mapped THP migration entry */
if ( ! pvmw . pte ) {
VM_BUG_ON_PAGE ( PageHuge ( page ) | | ! PageTransCompound ( page ) , page ) ;
remove_migration_pmd ( & pvmw , new ) ;
continue ;
}
# endif
2017-02-25 01:58:16 +03:00
get_page ( new ) ;
pte = pte_mkold ( mk_pte ( new , READ_ONCE ( vma - > vm_page_prot ) ) ) ;
if ( pte_swp_soft_dirty ( * pvmw . pte ) )
pte = pte_mksoft_dirty ( pte ) ;
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
2017-02-25 01:58:16 +03:00
/*
* Recheck VMA as permissions can change since migration started
*/
entry = pte_to_swp_entry ( * pvmw . pte ) ;
if ( is_write_migration_entry ( entry ) )
pte = maybe_mkwrite ( pte , vma ) ;
2014-10-02 22:47:41 +04:00
2017-09-09 02:12:24 +03:00
if ( unlikely ( is_zone_device_page ( new ) ) ) {
if ( is_device_private_page ( new ) ) {
entry = make_device_private_entry ( new , pte_write ( pte ) ) ;
pte = swp_entry_to_pte ( entry ) ;
} else if ( is_device_public_page ( new ) ) {
pte = pte_mkdevmap ( pte ) ;
flush_dcache_page ( new ) ;
}
2017-09-09 02:12:17 +03:00
} else
flush_dcache_page ( new ) ;
2010-10-11 18:03:21 +04:00
# ifdef CONFIG_HUGETLB_PAGE
2017-02-25 01:58:16 +03:00
if ( PageHuge ( new ) ) {
pte = pte_mkhuge ( pte ) ;
pte = arch_make_huge_pte ( pte , vma , new , 0 ) ;
2017-07-07 01:38:41 +03:00
set_huge_pte_at ( vma - > vm_mm , pvmw . address , pvmw . pte , pte ) ;
2017-02-25 01:58:16 +03:00
if ( PageAnon ( new ) )
hugepage_add_anon_rmap ( new , vma , pvmw . address ) ;
else
page_dup_rmap ( new , true ) ;
2017-07-07 01:38:41 +03:00
} else
# endif
{
set_pte_at ( vma - > vm_mm , pvmw . address , pvmw . pte , pte ) ;
2006-06-23 13:03:38 +04:00
2017-07-07 01:38:41 +03:00
if ( PageAnon ( new ) )
page_add_anon_rmap ( new , vma , pvmw . address , false ) ;
else
page_add_file_rmap ( new , false ) ;
}
2017-02-25 01:58:16 +03:00
if ( vma - > vm_flags & VM_LOCKED & & ! PageTransCompound ( new ) )
mlock_vma_page ( new ) ;
/* No need to invalidate - it was non-present before */
update_mmu_cache ( vma , pvmw . address , pvmw . pte ) ;
}
2015-11-06 05:49:37 +03:00
2017-05-04 00:54:27 +03:00
return true ;
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
}
2006-06-23 13:03:38 +04:00
/*
* Get rid of all migration entries and replace them by
* references to the indicated page .
*/
2016-03-18 00:20:07 +03:00
void remove_migration_ptes ( struct page * old , struct page * new , bool locked )
2006-06-23 13:03:38 +04:00
{
2014-01-22 03:49:48 +04:00
struct rmap_walk_control rwc = {
. rmap_one = remove_migration_pte ,
. arg = old ,
} ;
2016-03-18 00:20:07 +03:00
if ( locked )
rmap_walk_locked ( new , & rwc ) ;
else
rmap_walk ( new , & rwc ) ;
2006-06-23 13:03:38 +04:00
}
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
/*
* Something used the pte of a page under migration . We need to
* get to the page and wait until migration is finished .
* When we return from this function the fault will be retried .
*/
mm/hugetlb: take page table lock in follow_huge_pmd()
We have a race condition between move_pages() and freeing hugepages, where
move_pages() calls follow_page(FOLL_GET) for hugepages internally and
tries to get its refcount without preventing concurrent freeing. This
race crashes the kernel, so this patch fixes it by moving FOLL_GET code
for hugepages into follow_huge_pmd() with taking the page table lock.
This patch intentionally removes page==NULL check after pte_page.
This is justified because pte_page() never returns NULL for any
architectures or configurations.
This patch changes the behavior of follow_huge_pmd() for tail pages and
then tail pages can be pinned/returned. So the caller must be changed to
properly handle the returned tail pages.
We could have a choice to add the similar locking to
follow_huge_(addr|pud) for consistency, but it's not necessary because
currently these functions don't support FOLL_GET flag, so let's leave it
for future development.
Here is the reproducer:
$ cat movepages.c
#include <stdio.h>
#include <stdlib.h>
#include <numaif.h>
#define ADDR_INPUT 0x700000000000UL
#define HPS 0x200000
#define PS 0x1000
int main(int argc, char *argv[]) {
int i;
int nr_hp = strtol(argv[1], NULL, 0);
int nr_p = nr_hp * HPS / PS;
int ret;
void **addrs;
int *status;
int *nodes;
pid_t pid;
pid = strtol(argv[2], NULL, 0);
addrs = malloc(sizeof(char *) * nr_p + 1);
status = malloc(sizeof(char *) * nr_p + 1);
nodes = malloc(sizeof(char *) * nr_p + 1);
while (1) {
for (i = 0; i < nr_p; i++) {
addrs[i] = (void *)ADDR_INPUT + i * PS;
nodes[i] = 1;
status[i] = 0;
}
ret = numa_move_pages(pid, nr_p, addrs, nodes, status,
MPOL_MF_MOVE_ALL);
if (ret == -1)
err("move_pages");
for (i = 0; i < nr_p; i++) {
addrs[i] = (void *)ADDR_INPUT + i * PS;
nodes[i] = 0;
status[i] = 0;
}
ret = numa_move_pages(pid, nr_p, addrs, nodes, status,
MPOL_MF_MOVE_ALL);
if (ret == -1)
err("move_pages");
}
return 0;
}
$ cat hugepage.c
#include <stdio.h>
#include <sys/mman.h>
#include <string.h>
#define ADDR_INPUT 0x700000000000UL
#define HPS 0x200000
int main(int argc, char *argv[]) {
int nr_hp = strtol(argv[1], NULL, 0);
char *p;
while (1) {
p = mmap((void *)ADDR_INPUT, nr_hp * HPS, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
if (p != (void *)ADDR_INPUT) {
perror("mmap");
break;
}
memset(p, 0, nr_hp * HPS);
munmap(p, nr_hp * HPS);
}
}
$ sysctl vm.nr_hugepages=40
$ ./hugepage 10 &
$ ./movepages 10 $(pgrep -f hugepage)
Fixes: e632a938d914 ("mm: migrate: add hugepage migration code to move_pages()")
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Reported-by: Hugh Dickins <hughd@google.com>
Cc: James Hogan <james.hogan@imgtec.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Luiz Capitulino <lcapitulino@redhat.com>
Cc: Nishanth Aravamudan <nacc@linux.vnet.ibm.com>
Cc: Lee Schermerhorn <lee.schermerhorn@hp.com>
Cc: Steve Capper <steve.capper@linaro.org>
Cc: <stable@vger.kernel.org> [3.12+]
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-02-12 02:25:22 +03:00
void __migration_entry_wait ( struct mm_struct * mm , pte_t * ptep ,
2013-06-13 01:05:04 +04:00
spinlock_t * ptl )
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
{
2013-06-13 01:05:04 +04:00
pte_t pte ;
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
swp_entry_t entry ;
struct page * page ;
2013-06-13 01:05:04 +04:00
spin_lock ( ptl ) ;
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
pte = * ptep ;
if ( ! is_swap_pte ( pte ) )
goto out ;
entry = pte_to_swp_entry ( pte ) ;
if ( ! is_migration_entry ( entry ) )
goto out ;
page = migration_entry_to_page ( entry ) ;
2008-07-26 06:45:30 +04:00
/*
* Once radix - tree replacement of page migration started , page_count
* * must * be zero . And , we don ' t want to call wait_on_page_locked ( )
* against a page without get_page ( ) .
* So , we use get_page_unless_zero ( ) , here . Even failed , page fault
* will occur again .
*/
if ( ! get_page_unless_zero ( page ) )
goto out ;
[PATCH] Swapless page migration: add R/W migration entries
Implement read/write migration ptes
We take the upper two swapfiles for the two types of migration ptes and define
a series of macros in swapops.h.
The VM is modified to handle the migration entries. migration entries can
only be encountered when the page they are pointing to is locked. This limits
the number of places one has to fix. We also check in copy_pte_range and in
mprotect_pte_range() for migration ptes.
We check for migration ptes in do_swap_cache and call a function that will
then wait on the page lock. This allows us to effectively stop all accesses
to apge.
Migration entries are created by try_to_unmap if called for migration and
removed by local functions in migrate.c
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration (I've no NUMA, just
hacking it up to migrate recklessly while running load), I've hit the
BUG_ON(!PageLocked(p)) in migration_entry_to_page.
This comes from an orphaned migration entry, unrelated to the current
correctly locked migration, but hit by remove_anon_migration_ptes as it
checks an address in each vma of the anon_vma list.
Such an orphan may be left behind if an earlier migration raced with fork:
copy_one_pte can duplicate a migration entry from parent to child, after
remove_anon_migration_ptes has checked the child vma, but before it has
removed it from the parent vma. (If the process were later to fault on this
orphaned entry, it would hit the same BUG from migration_entry_wait.)
This could be fixed by locking anon_vma in copy_one_pte, but we'd rather
not. There's no such problem with file pages, because vma_prio_tree_add
adds child vma after parent vma, and the page table locking at each end is
enough to serialize. Follow that example with anon_vma: add new vmas to the
tail instead of the head.
(There's no corresponding problem when inserting migration entries,
because a missed pte will leave the page count and mapcount high, which is
allowed for. And there's no corresponding problem when migrating via swap,
because a leftover swap entry will be correctly faulted. But the swapless
method has no refcounting of its entries.)
From: Ingo Molnar <mingo@elte.hu>
pte_unmap_unlock() takes the pte pointer as an argument.
From: Hugh Dickins <hugh@veritas.com>
Several times while testing swapless page migration, gcc has tried to exec
a pointer instead of a string: smells like COW mappings are not being
properly write-protected on fork.
The protection in copy_one_pte looks very convincing, until at last you
realize that the second arg to make_migration_entry is a boolean "write",
and SWP_MIGRATION_READ is 30.
Anyway, it's better done like in change_pte_range, using
is_write_migration_entry and make_migration_entry_read.
From: Hugh Dickins <hugh@veritas.com>
Remove unnecessary obfuscation from sys_swapon's range check on swap type,
which blew up causing memory corruption once swapless migration made
MAX_SWAPFILES no longer 2 ^ MAX_SWAPFILES_SHIFT.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Christoph Lameter <clameter@engr.sgi.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
From: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 13:03:35 +04:00
pte_unmap_unlock ( ptep , ptl ) ;
wait_on_page_locked ( page ) ;
put_page ( page ) ;
return ;
out :
pte_unmap_unlock ( ptep , ptl ) ;
}
2013-06-13 01:05:04 +04:00
void migration_entry_wait ( struct mm_struct * mm , pmd_t * pmd ,
unsigned long address )
{
spinlock_t * ptl = pte_lockptr ( mm , pmd ) ;
pte_t * ptep = pte_offset_map ( pmd , address ) ;
__migration_entry_wait ( mm , ptep , ptl ) ;
}
2013-11-15 02:31:02 +04:00
void migration_entry_wait_huge ( struct vm_area_struct * vma ,
struct mm_struct * mm , pte_t * pte )
2013-06-13 01:05:04 +04:00
{
2013-11-15 02:31:02 +04:00
spinlock_t * ptl = huge_pte_lockptr ( hstate_vma ( vma ) , mm , pte ) ;
2013-06-13 01:05:04 +04:00
__migration_entry_wait ( mm , pte , ptl ) ;
}
2017-09-09 02:10:57 +03:00
# ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
void pmd_migration_entry_wait ( struct mm_struct * mm , pmd_t * pmd )
{
spinlock_t * ptl ;
struct page * page ;
ptl = pmd_lock ( mm , pmd ) ;
if ( ! is_pmd_migration_entry ( * pmd ) )
goto unlock ;
page = migration_entry_to_page ( pmd_to_swp_entry ( * pmd ) ) ;
if ( ! get_page_unless_zero ( page ) )
goto unlock ;
spin_unlock ( ptl ) ;
wait_on_page_locked ( page ) ;
put_page ( page ) ;
return ;
unlock :
spin_unlock ( ptl ) ;
}
# endif
2012-01-13 05:19:34 +04:00
# ifdef CONFIG_BLOCK
/* Returns true if all buffers are successfully locked */
2012-01-13 05:19:43 +04:00
static bool buffer_migrate_lock_buffers ( struct buffer_head * head ,
enum migrate_mode mode )
2012-01-13 05:19:34 +04:00
{
struct buffer_head * bh = head ;
/* Simple case, sync compaction */
2012-01-13 05:19:43 +04:00
if ( mode ! = MIGRATE_ASYNC ) {
2012-01-13 05:19:34 +04:00
do {
get_bh ( bh ) ;
lock_buffer ( bh ) ;
bh = bh - > b_this_page ;
} while ( bh ! = head ) ;
return true ;
}
/* async case, we cannot block on lock_buffer so use trylock_buffer */
do {
get_bh ( bh ) ;
if ( ! trylock_buffer ( bh ) ) {
/*
* We failed to lock the buffer and cannot stall in
* async migration . Release the taken locks
*/
struct buffer_head * failed_bh = bh ;
put_bh ( failed_bh ) ;
bh = head ;
while ( bh ! = failed_bh ) {
unlock_buffer ( bh ) ;
put_bh ( bh ) ;
bh = bh - > b_this_page ;
}
return false ;
}
bh = bh - > b_this_page ;
} while ( bh ! = head ) ;
return true ;
}
# else
static inline bool buffer_migrate_lock_buffers ( struct buffer_head * head ,
2012-01-13 05:19:43 +04:00
enum migrate_mode mode )
2012-01-13 05:19:34 +04:00
{
return true ;
}
# endif /* CONFIG_BLOCK */
2006-03-22 11:09:12 +03:00
/*
2006-06-23 13:03:32 +04:00
* Replace the page in the mapping .
2006-06-23 13:03:29 +04:00
*
* The number of remaining references must be :
* 1 for anonymous pages without a mapping
* 2 for pages with a mapping
2009-04-03 19:42:36 +04:00
* 3 for pages with a mapping and PagePrivate / PagePrivate2 set .
2006-03-22 11:09:12 +03:00
*/
2013-07-16 13:56:16 +04:00
int migrate_page_move_mapping ( struct address_space * mapping ,
2012-01-13 05:19:34 +04:00
struct page * newpage , struct page * page ,
2013-12-22 02:56:08 +04:00
struct buffer_head * head , enum migrate_mode mode ,
int extra_count )
2006-03-22 11:09:12 +03:00
{
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
struct zone * oldzone , * newzone ;
int dirty ;
2013-12-22 02:56:08 +04:00
int expected_count = 1 + extra_count ;
2006-12-07 07:33:44 +03:00
void * * pslot ;
2006-03-22 11:09:12 +03:00
2017-09-09 02:12:09 +03:00
/*
2017-09-09 02:12:24 +03:00
* Device public or private pages have an extra refcount as they are
* ZONE_DEVICE pages .
2017-09-09 02:12:09 +03:00
*/
2017-09-09 02:12:24 +03:00
expected_count + = is_device_private_page ( page ) ;
expected_count + = is_device_public_page ( page ) ;
2017-09-09 02:12:09 +03:00
2006-06-23 13:03:37 +04:00
if ( ! mapping ) {
2007-04-24 01:41:09 +04:00
/* Anonymous page without mapping */
2013-12-22 02:56:08 +04:00
if ( page_count ( page ) ! = expected_count )
2006-06-23 13:03:37 +04:00
return - EAGAIN ;
2015-11-06 05:50:02 +03:00
/* No turning back from here */
newpage - > index = page - > index ;
newpage - > mapping = page - > mapping ;
if ( PageSwapBacked ( page ) )
2016-05-20 03:12:41 +03:00
__SetPageSwapBacked ( newpage ) ;
2015-11-06 05:50:02 +03:00
2012-12-12 04:02:31 +04:00
return MIGRATEPAGE_SUCCESS ;
2006-06-23 13:03:37 +04:00
}
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
oldzone = page_zone ( page ) ;
newzone = page_zone ( newpage ) ;
2008-07-26 06:45:32 +04:00
spin_lock_irq ( & mapping - > tree_lock ) ;
2006-03-22 11:09:12 +03:00
2006-12-07 07:33:44 +03:00
pslot = radix_tree_lookup_slot ( & mapping - > page_tree ,
page_index ( page ) ) ;
2006-03-22 11:09:12 +03:00
2013-12-22 02:56:08 +04:00
expected_count + = 1 + page_has_private ( page ) ;
2008-07-26 06:45:30 +04:00
if ( page_count ( page ) ! = expected_count | |
2011-01-14 02:47:21 +03:00
radix_tree_deref_slot_protected ( pslot , & mapping - > tree_lock ) ! = page ) {
2008-07-26 06:45:32 +04:00
spin_unlock_irq ( & mapping - > tree_lock ) ;
2006-04-11 09:52:57 +04:00
return - EAGAIN ;
2006-03-22 11:09:12 +03:00
}
2016-03-18 00:19:26 +03:00
if ( ! page_ref_freeze ( page , expected_count ) ) {
2008-07-26 06:45:32 +04:00
spin_unlock_irq ( & mapping - > tree_lock ) ;
2008-07-26 06:45:30 +04:00
return - EAGAIN ;
}
2012-01-13 05:19:34 +04:00
/*
* In the async migration case of moving a page with buffers , lock the
* buffers using trylock before the mapping is moved . If the mapping
* was moved , we later failed to lock the buffers and could not move
* the mapping back due to an elevated page count , we would have to
* block waiting on other references to be dropped .
*/
2012-01-13 05:19:43 +04:00
if ( mode = = MIGRATE_ASYNC & & head & &
! buffer_migrate_lock_buffers ( head , mode ) ) {
2016-03-18 00:19:26 +03:00
page_ref_unfreeze ( page , expected_count ) ;
2012-01-13 05:19:34 +04:00
spin_unlock_irq ( & mapping - > tree_lock ) ;
return - EAGAIN ;
}
2006-03-22 11:09:12 +03:00
/*
2015-11-06 05:50:02 +03:00
* Now we know that no one else is looking at the page :
* no turning back from here .
2006-03-22 11:09:12 +03:00
*/
2015-11-06 05:50:02 +03:00
newpage - > index = page - > index ;
newpage - > mapping = page - > mapping ;
2006-12-07 07:33:44 +03:00
get_page ( newpage ) ; /* add cache reference */
2016-12-25 06:00:29 +03:00
if ( PageSwapBacked ( page ) ) {
__SetPageSwapBacked ( newpage ) ;
if ( PageSwapCache ( page ) ) {
SetPageSwapCache ( newpage ) ;
set_page_private ( newpage , page_private ( page ) ) ;
}
} else {
VM_BUG_ON_PAGE ( PageSwapCache ( page ) , page ) ;
2006-03-22 11:09:12 +03:00
}
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
/* Move dirty while page refs frozen and newpage not yet exposed */
dirty = PageDirty ( page ) ;
if ( dirty ) {
ClearPageDirty ( page ) ;
SetPageDirty ( newpage ) ;
}
2016-12-13 03:43:43 +03:00
radix_tree_replace_slot ( & mapping - > page_tree , pslot , newpage ) ;
2006-12-07 07:33:44 +03:00
/*
2012-01-11 03:07:11 +04:00
* Drop cache reference from old page by unfreezing
* to one less reference .
2006-12-07 07:33:44 +03:00
* We know this isn ' t the last reference .
*/
2016-03-18 00:19:26 +03:00
page_ref_unfreeze ( page , expected_count - 1 ) ;
2006-12-07 07:33:44 +03:00
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
spin_unlock ( & mapping - > tree_lock ) ;
/* Leave irq disabled to prevent preemption while updating stats */
2007-04-24 01:41:09 +04:00
/*
* If moved to a different zone then also account
* the page for that zone . Other VM counters will be
* taken care of when we establish references to the
* new page and drop references to the old page .
*
* Note that anonymous pages are accounted for
2016-07-29 01:46:17 +03:00
* via NR_FILE_PAGES and NR_ANON_MAPPED if they
2007-04-24 01:41:09 +04:00
* are mapped to swap space .
*/
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
if ( newzone ! = oldzone ) {
2016-07-29 01:46:20 +03:00
__dec_node_state ( oldzone - > zone_pgdat , NR_FILE_PAGES ) ;
__inc_node_state ( newzone - > zone_pgdat , NR_FILE_PAGES ) ;
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
if ( PageSwapBacked ( page ) & & ! PageSwapCache ( page ) ) {
2016-07-29 01:46:20 +03:00
__dec_node_state ( oldzone - > zone_pgdat , NR_SHMEM ) ;
__inc_node_state ( newzone - > zone_pgdat , NR_SHMEM ) ;
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
}
if ( dirty & & mapping_cap_account_dirty ( mapping ) ) {
2016-07-29 01:46:20 +03:00
__dec_node_state ( oldzone - > zone_pgdat , NR_FILE_DIRTY ) ;
2016-07-29 01:47:31 +03:00
__dec_zone_state ( oldzone , NR_ZONE_WRITE_PENDING ) ;
2016-07-29 01:46:20 +03:00
__inc_node_state ( newzone - > zone_pgdat , NR_FILE_DIRTY ) ;
2016-07-29 01:47:31 +03:00
__inc_zone_state ( newzone , NR_ZONE_WRITE_PENDING ) ;
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
}
2009-09-22 04:01:33 +04:00
}
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
local_irq_enable ( ) ;
2006-03-22 11:09:12 +03:00
2012-12-12 04:02:31 +04:00
return MIGRATEPAGE_SUCCESS ;
2006-03-22 11:09:12 +03:00
}
2016-06-17 00:26:14 +03:00
EXPORT_SYMBOL ( migrate_page_move_mapping ) ;
2006-03-22 11:09:12 +03:00
2010-09-08 05:19:35 +04:00
/*
* The expected number of remaining references is the same as that
* of migrate_page_move_mapping ( ) .
*/
int migrate_huge_page_move_mapping ( struct address_space * mapping ,
struct page * newpage , struct page * page )
{
int expected_count ;
void * * pslot ;
spin_lock_irq ( & mapping - > tree_lock ) ;
pslot = radix_tree_lookup_slot ( & mapping - > page_tree ,
page_index ( page ) ) ;
expected_count = 2 + page_has_private ( page ) ;
if ( page_count ( page ) ! = expected_count | |
2011-01-14 02:47:21 +03:00
radix_tree_deref_slot_protected ( pslot , & mapping - > tree_lock ) ! = page ) {
2010-09-08 05:19:35 +04:00
spin_unlock_irq ( & mapping - > tree_lock ) ;
return - EAGAIN ;
}
2016-03-18 00:19:26 +03:00
if ( ! page_ref_freeze ( page , expected_count ) ) {
2010-09-08 05:19:35 +04:00
spin_unlock_irq ( & mapping - > tree_lock ) ;
return - EAGAIN ;
}
2015-11-06 05:50:02 +03:00
newpage - > index = page - > index ;
newpage - > mapping = page - > mapping ;
2016-03-16 00:57:19 +03:00
2010-09-08 05:19:35 +04:00
get_page ( newpage ) ;
2016-12-13 03:43:43 +03:00
radix_tree_replace_slot ( & mapping - > page_tree , pslot , newpage ) ;
2010-09-08 05:19:35 +04:00
2016-03-18 00:19:26 +03:00
page_ref_unfreeze ( page , expected_count - 1 ) ;
2010-09-08 05:19:35 +04:00
spin_unlock_irq ( & mapping - > tree_lock ) ;
2016-03-16 00:57:19 +03:00
2012-12-12 04:02:31 +04:00
return MIGRATEPAGE_SUCCESS ;
2010-09-08 05:19:35 +04:00
}
2013-11-22 02:31:58 +04:00
/*
* Gigantic pages are so large that we do not guarantee that page + + pointer
* arithmetic will work across the entire page . We need something more
* specialized .
*/
static void __copy_gigantic_page ( struct page * dst , struct page * src ,
int nr_pages )
{
int i ;
struct page * dst_base = dst ;
struct page * src_base = src ;
for ( i = 0 ; i < nr_pages ; ) {
cond_resched ( ) ;
copy_highpage ( dst , src ) ;
i + + ;
dst = mem_map_next ( dst , dst_base , i ) ;
src = mem_map_next ( src , src_base , i ) ;
}
}
static void copy_huge_page ( struct page * dst , struct page * src )
{
int i ;
int nr_pages ;
if ( PageHuge ( src ) ) {
/* hugetlbfs page */
struct hstate * h = page_hstate ( src ) ;
nr_pages = pages_per_huge_page ( h ) ;
if ( unlikely ( nr_pages > MAX_ORDER_NR_PAGES ) ) {
__copy_gigantic_page ( dst , src , nr_pages ) ;
return ;
}
} else {
/* thp page */
BUG_ON ( ! PageTransHuge ( src ) ) ;
nr_pages = hpage_nr_pages ( src ) ;
}
for ( i = 0 ; i < nr_pages ; i + + ) {
cond_resched ( ) ;
copy_highpage ( dst + i , src + i ) ;
}
}
2006-03-22 11:09:12 +03:00
/*
* Copy the page to its new location
*/
2017-09-09 02:12:06 +03:00
void migrate_page_states ( struct page * newpage , struct page * page )
2006-03-22 11:09:12 +03:00
{
2013-10-07 14:29:23 +04:00
int cpupid ;
2006-03-22 11:09:12 +03:00
if ( PageError ( page ) )
SetPageError ( newpage ) ;
if ( PageReferenced ( page ) )
SetPageReferenced ( newpage ) ;
if ( PageUptodate ( page ) )
SetPageUptodate ( newpage ) ;
Unevictable LRU Infrastructure
When the system contains lots of mlocked or otherwise unevictable pages,
the pageout code (kswapd) can spend lots of time scanning over these
pages. Worse still, the presence of lots of unevictable pages can confuse
kswapd into thinking that more aggressive pageout modes are required,
resulting in all kinds of bad behaviour.
Infrastructure to manage pages excluded from reclaim--i.e., hidden from
vmscan. Based on a patch by Larry Woodman of Red Hat. Reworked to
maintain "unevictable" pages on a separate per-zone LRU list, to "hide"
them from vmscan.
Kosaki Motohiro added the support for the memory controller unevictable
lru list.
Pages on the unevictable list have both PG_unevictable and PG_lru set.
Thus, PG_unevictable is analogous to and mutually exclusive with
PG_active--it specifies which LRU list the page is on.
The unevictable infrastructure is enabled by a new mm Kconfig option
[CONFIG_]UNEVICTABLE_LRU.
A new function 'page_evictable(page, vma)' in vmscan.c tests whether or
not a page may be evictable. Subsequent patches will add the various
!evictable tests. We'll want to keep these tests light-weight for use in
shrink_active_list() and, possibly, the fault path.
To avoid races between tasks putting pages [back] onto an LRU list and
tasks that might be moving the page from non-evictable to evictable state,
the new function 'putback_lru_page()' -- inverse to 'isolate_lru_page()'
-- tests the "evictability" of a page after placing it on the LRU, before
dropping the reference. If the page has become unevictable,
putback_lru_page() will redo the 'putback', thus moving the page to the
unevictable list. This way, we avoid "stranding" evictable pages on the
unevictable list.
[akpm@linux-foundation.org: fix fallout from out-of-order merge]
[riel@redhat.com: fix UNEVICTABLE_LRU and !PROC_PAGE_MONITOR build]
[nishimura@mxp.nes.nec.co.jp: remove redundant mapping check]
[kosaki.motohiro@jp.fujitsu.com: unevictable-lru-infrastructure: putback_lru_page()/unevictable page handling rework]
[kosaki.motohiro@jp.fujitsu.com: kill unnecessary lock_page() in vmscan.c]
[kosaki.motohiro@jp.fujitsu.com: revert migration change of unevictable lru infrastructure]
[kosaki.motohiro@jp.fujitsu.com: revert to unevictable-lru-infrastructure-kconfig-fix.patch]
[kosaki.motohiro@jp.fujitsu.com: restore patch failure of vmstat-unevictable-and-mlocked-pages-vm-events.patch]
Signed-off-by: Lee Schermerhorn <lee.schermerhorn@hp.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Debugged-by: Benjamin Kidwell <benjkidwell@yahoo.com>
Signed-off-by: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-10-19 07:26:39 +04:00
if ( TestClearPageActive ( page ) ) {
2014-01-24 03:52:54 +04:00
VM_BUG_ON_PAGE ( PageUnevictable ( page ) , page ) ;
2006-03-22 11:09:12 +03:00
SetPageActive ( newpage ) ;
2009-12-15 04:59:54 +03:00
} else if ( TestClearPageUnevictable ( page ) )
SetPageUnevictable ( newpage ) ;
2006-03-22 11:09:12 +03:00
if ( PageChecked ( page ) )
SetPageChecked ( newpage ) ;
if ( PageMappedToDisk ( page ) )
SetPageMappedToDisk ( newpage ) ;
mm: migrate dirty page without clear_page_dirty_for_io etc
clear_page_dirty_for_io() has accumulated writeback and memcg subtleties
since v2.6.16 first introduced page migration; and the set_page_dirty()
which completed its migration of PageDirty, later had to be moderated to
__set_page_dirty_nobuffers(); then PageSwapBacked had to skip that too.
No actual problems seen with this procedure recently, but if you look into
what the clear_page_dirty_for_io(page)+set_page_dirty(newpage) is actually
achieving, it turns out to be nothing more than moving the PageDirty flag,
and its NR_FILE_DIRTY stat from one zone to another.
It would be good to avoid a pile of irrelevant decrementations and
incrementations, and improper event counting, and unnecessary descent of
the radix_tree under tree_lock (to set the PAGECACHE_TAG_DIRTY which
radix_tree_replace_slot() left in place anyway).
Do the NR_FILE_DIRTY movement, like the other stats movements, while
interrupts still disabled in migrate_page_move_mapping(); and don't even
bother if the zone is the same. Do the PageDirty movement there under
tree_lock too, where old page is frozen and newpage not yet visible:
bearing in mind that as soon as newpage becomes visible in radix_tree, an
un-page-locked set_page_dirty() might interfere (or perhaps that's just
not possible: anything doing so should already hold an additional
reference to the old page, preventing its migration; but play safe).
But we do still need to transfer PageDirty in migrate_page_copy(), for
those who don't go the mapping route through migrate_page_move_mapping().
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-11-06 05:50:05 +03:00
/* Move dirty on pages not done by migrate_page_move_mapping() */
if ( PageDirty ( page ) )
SetPageDirty ( newpage ) ;
2006-03-22 11:09:12 +03:00
mm: introduce idle page tracking
Knowing the portion of memory that is not used by a certain application or
memory cgroup (idle memory) can be useful for partitioning the system
efficiently, e.g. by setting memory cgroup limits appropriately.
Currently, the only means to estimate the amount of idle memory provided
by the kernel is /proc/PID/{clear_refs,smaps}: the user can clear the
access bit for all pages mapped to a particular process by writing 1 to
clear_refs, wait for some time, and then count smaps:Referenced. However,
this method has two serious shortcomings:
- it does not count unmapped file pages
- it affects the reclaimer logic
To overcome these drawbacks, this patch introduces two new page flags,
Idle and Young, and a new sysfs file, /sys/kernel/mm/page_idle/bitmap.
A page's Idle flag can only be set from userspace by setting bit in
/sys/kernel/mm/page_idle/bitmap at the offset corresponding to the page,
and it is cleared whenever the page is accessed either through page tables
(it is cleared in page_referenced() in this case) or using the read(2)
system call (mark_page_accessed()). Thus by setting the Idle flag for
pages of a particular workload, which can be found e.g. by reading
/proc/PID/pagemap, waiting for some time to let the workload access its
working set, and then reading the bitmap file, one can estimate the amount
of pages that are not used by the workload.
The Young page flag is used to avoid interference with the memory
reclaimer. A page's Young flag is set whenever the Access bit of a page
table entry pointing to the page is cleared by writing to the bitmap file.
If page_referenced() is called on a Young page, it will add 1 to its
return value, therefore concealing the fact that the Access bit was
cleared.
Note, since there is no room for extra page flags on 32 bit, this feature
uses extended page flags when compiled on 32 bit.
[akpm@linux-foundation.org: fix build]
[akpm@linux-foundation.org: kpageidle requires an MMU]
[akpm@linux-foundation.org: decouple from page-flags rework]
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Reviewed-by: Andres Lagar-Cavilla <andreslc@google.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Raghavendra K T <raghavendra.kt@linux.vnet.ibm.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Greg Thelen <gthelen@google.com>
Cc: Michel Lespinasse <walken@google.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Pavel Emelyanov <xemul@parallels.com>
Cc: Cyrill Gorcunov <gorcunov@openvz.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-09-10 01:35:45 +03:00
if ( page_is_young ( page ) )
set_page_young ( newpage ) ;
if ( page_is_idle ( page ) )
set_page_idle ( newpage ) ;
2013-10-07 14:29:23 +04:00
/*
* Copy NUMA information to the new page , to prevent over - eager
* future migrations of this same page .
*/
cpupid = page_cpupid_xchg_last ( page , - 1 ) ;
page_cpupid_xchg_last ( newpage , cpupid ) ;
ksm: rmap_walk to remove_migation_ptes
A side-effect of making ksm pages swappable is that they have to be placed
on the LRUs: which then exposes them to isolate_lru_page() and hence to
page migration.
Add rmap_walk() for remove_migration_ptes() to use: rmap_walk_anon() and
rmap_walk_file() in rmap.c, but rmap_walk_ksm() in ksm.c. Perhaps some
consolidation with existing code is possible, but don't attempt that yet
(try_to_unmap needs to handle nonlinears, but migration pte removal does
not).
rmap_walk() is sadly less general than it appears: rmap_walk_anon(), like
remove_anon_migration_ptes() which it replaces, avoids calling
page_lock_anon_vma(), because that includes a page_mapped() test which
fails when all migration ptes are in place. That was valid when NUMA page
migration was introduced (holding mmap_sem provided the missing guarantee
that anon_vma's slab had not already been destroyed), but I believe not
valid in the memory hotremove case added since.
For now do the same as before, and consider the best way to fix that
unlikely race later on. When fixed, we can probably use rmap_walk() on
hwpoisoned ksm pages too: for now, they remain among hwpoison's various
exceptions (its PageKsm test comes before the page is locked, but its
page_lock_anon_vma fails safely if an anon gets upgraded).
Signed-off-by: Hugh Dickins <hugh.dickins@tiscali.co.uk>
Cc: Izik Eidus <ieidus@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Chris Wright <chrisw@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-15 04:59:31 +03:00
ksm_migrate_page ( newpage , page ) ;
ksm: make KSM page migration possible
KSM page migration is already supported in the case of memory hotremove,
which takes the ksm_thread_mutex across all its migrations to keep life
simple.
But the new KSM NUMA merge_across_nodes knob introduces a problem, when
it's set to non-default 0: if a KSM page is migrated to a different NUMA
node, how do we migrate its stable node to the right tree? And what if
that collides with an existing stable node?
So far there's no provision for that, and this patch does not attempt to
deal with it either. But how will I test a solution, when I don't know
how to hotremove memory? The best answer is to enable KSM page migration
in all cases now, and test more common cases. With THP and compaction
added since KSM came in, page migration is now mainstream, and it's a
shame that a KSM page can frustrate freeing a page block.
Without worrying about merge_across_nodes 0 for now, this patch gets KSM
page migration working reliably for default merge_across_nodes 1 (but
leave the patch enabling it until near the end of the series).
It's much simpler than I'd originally imagined, and does not require an
additional tier of locking: page migration relies on the page lock, KSM
page reclaim relies on the page lock, the page lock is enough for KSM page
migration too.
Almost all the care has to be in get_ksm_page(): that's the function which
worries about when a stable node is stale and should be freed, now it also
has to worry about the KSM page being migrated.
The only new overhead is an additional put/get/lock/unlock_page when
stable_tree_search() arrives at a matching node: to make sure migration
respects the raised page count, and so does not migrate the page while
we're busy with it here. That's probably avoidable, either by changing
internal interfaces from using kpage to stable_node, or by moving the
ksm_migrate_page() callsite into a page_freeze_refs() section (even if not
swapcache); but this works well, I've no urge to pull it apart now.
(Descents of the stable tree may pass through nodes whose KSM pages are
under migration: being unlocked, the raised page count does not prevent
that, nor need it: it's safe to memcmp against either old or new page.)
You might worry about mremap, and whether page migration's rmap_walk to
remove migration entries will find all the KSM locations where it inserted
earlier: that should already be handled, by the satisfyingly heavy hammer
of move_vma()'s call to ksm_madvise(,,,MADV_UNMERGEABLE,).
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Petr Holasek <pholasek@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Izik Eidus <izik.eidus@ravellosystems.com>
Cc: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-23 04:35:10 +04:00
/*
* Please do not reorder this without considering how mm / ksm . c ' s
* get_ksm_page ( ) depends upon ksm_migrate_page ( ) and PageSwapCache ( ) .
*/
2015-04-16 02:13:15 +03:00
if ( PageSwapCache ( page ) )
ClearPageSwapCache ( page ) ;
2006-03-22 11:09:12 +03:00
ClearPagePrivate ( page ) ;
set_page_private ( page , 0 ) ;
/*
* If any waiters have accumulated on the new page then
* wake them up .
*/
if ( PageWriteback ( newpage ) )
end_page_writeback ( newpage ) ;
2016-03-16 00:56:15 +03:00
copy_page_owner ( page , newpage ) ;
2016-03-16 00:57:54 +03:00
mem_cgroup_migrate ( page , newpage ) ;
2006-03-22 11:09:12 +03:00
}
2017-09-09 02:12:06 +03:00
EXPORT_SYMBOL ( migrate_page_states ) ;
void migrate_page_copy ( struct page * newpage , struct page * page )
{
if ( PageHuge ( page ) | | PageTransHuge ( page ) )
copy_huge_page ( newpage , page ) ;
else
copy_highpage ( newpage , page ) ;
migrate_page_states ( newpage , page ) ;
}
2016-06-17 00:26:14 +03:00
EXPORT_SYMBOL ( migrate_page_copy ) ;
2006-03-22 11:09:12 +03:00
2006-06-23 13:03:28 +04:00
/************************************************************
* Migration functions
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2006-03-22 11:09:12 +03:00
/*
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
* Common logic to directly migrate a single LRU page suitable for
2009-04-03 19:42:36 +04:00
* pages that do not use PagePrivate / PagePrivate2 .
2006-03-22 11:09:12 +03:00
*
* Pages are locked upon entry and exit .
*/
2006-06-23 13:03:33 +04:00
int migrate_page ( struct address_space * mapping ,
2012-01-13 05:19:43 +04:00
struct page * newpage , struct page * page ,
enum migrate_mode mode )
2006-03-22 11:09:12 +03:00
{
int rc ;
BUG_ON ( PageWriteback ( page ) ) ; /* Writeback must be complete */
2013-12-22 02:56:08 +04:00
rc = migrate_page_move_mapping ( mapping , newpage , page , NULL , mode , 0 ) ;
2006-03-22 11:09:12 +03:00
2012-12-12 04:02:31 +04:00
if ( rc ! = MIGRATEPAGE_SUCCESS )
2006-03-22 11:09:12 +03:00
return rc ;
2017-09-09 02:12:06 +03:00
if ( mode ! = MIGRATE_SYNC_NO_COPY )
migrate_page_copy ( newpage , page ) ;
else
migrate_page_states ( newpage , page ) ;
2012-12-12 04:02:31 +04:00
return MIGRATEPAGE_SUCCESS ;
2006-03-22 11:09:12 +03:00
}
EXPORT_SYMBOL ( migrate_page ) ;
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 22:45:40 +04:00
# ifdef CONFIG_BLOCK
2006-06-23 13:03:28 +04:00
/*
* Migration function for pages with buffers . This function can only be used
* if the underlying filesystem guarantees that no other references to " page "
* exist .
*/
2006-06-23 13:03:33 +04:00
int buffer_migrate_page ( struct address_space * mapping ,
2012-01-13 05:19:43 +04:00
struct page * newpage , struct page * page , enum migrate_mode mode )
2006-06-23 13:03:28 +04:00
{
struct buffer_head * bh , * head ;
int rc ;
if ( ! page_has_buffers ( page ) )
2012-01-13 05:19:43 +04:00
return migrate_page ( mapping , newpage , page , mode ) ;
2006-06-23 13:03:28 +04:00
head = page_buffers ( page ) ;
2013-12-22 02:56:08 +04:00
rc = migrate_page_move_mapping ( mapping , newpage , page , head , mode , 0 ) ;
2006-06-23 13:03:28 +04:00
2012-12-12 04:02:31 +04:00
if ( rc ! = MIGRATEPAGE_SUCCESS )
2006-06-23 13:03:28 +04:00
return rc ;
2012-01-13 05:19:34 +04:00
/*
* In the async case , migrate_page_move_mapping locked the buffers
* with an IRQ - safe spinlock held . In the sync case , the buffers
* need to be locked now
*/
2012-01-13 05:19:43 +04:00
if ( mode ! = MIGRATE_ASYNC )
BUG_ON ( ! buffer_migrate_lock_buffers ( head , mode ) ) ;
2006-06-23 13:03:28 +04:00
ClearPagePrivate ( page ) ;
set_page_private ( newpage , page_private ( page ) ) ;
set_page_private ( page , 0 ) ;
put_page ( page ) ;
get_page ( newpage ) ;
bh = head ;
do {
set_bh_page ( bh , newpage , bh_offset ( bh ) ) ;
bh = bh - > b_this_page ;
} while ( bh ! = head ) ;
SetPagePrivate ( newpage ) ;
2017-09-09 02:12:06 +03:00
if ( mode ! = MIGRATE_SYNC_NO_COPY )
migrate_page_copy ( newpage , page ) ;
else
migrate_page_states ( newpage , page ) ;
2006-06-23 13:03:28 +04:00
bh = head ;
do {
unlock_buffer ( bh ) ;
2017-09-09 02:12:06 +03:00
put_bh ( bh ) ;
2006-06-23 13:03:28 +04:00
bh = bh - > b_this_page ;
} while ( bh ! = head ) ;
2012-12-12 04:02:31 +04:00
return MIGRATEPAGE_SUCCESS ;
2006-06-23 13:03:28 +04:00
}
EXPORT_SYMBOL ( buffer_migrate_page ) ;
[PATCH] BLOCK: Make it possible to disable the block layer [try #6]
Make it possible to disable the block layer. Not all embedded devices require
it, some can make do with just JFFS2, NFS, ramfs, etc - none of which require
the block layer to be present.
This patch does the following:
(*) Introduces CONFIG_BLOCK to disable the block layer, buffering and blockdev
support.
(*) Adds dependencies on CONFIG_BLOCK to any configuration item that controls
an item that uses the block layer. This includes:
(*) Block I/O tracing.
(*) Disk partition code.
(*) All filesystems that are block based, eg: Ext3, ReiserFS, ISOFS.
(*) The SCSI layer. As far as I can tell, even SCSI chardevs use the
block layer to do scheduling. Some drivers that use SCSI facilities -
such as USB storage - end up disabled indirectly from this.
(*) Various block-based device drivers, such as IDE and the old CDROM
drivers.
(*) MTD blockdev handling and FTL.
(*) JFFS - which uses set_bdev_super(), something it could avoid doing by
taking a leaf out of JFFS2's book.
(*) Makes most of the contents of linux/blkdev.h, linux/buffer_head.h and
linux/elevator.h contingent on CONFIG_BLOCK being set. sector_div() is,
however, still used in places, and so is still available.
(*) Also made contingent are the contents of linux/mpage.h, linux/genhd.h and
parts of linux/fs.h.
(*) Makes a number of files in fs/ contingent on CONFIG_BLOCK.
(*) Makes mm/bounce.c (bounce buffering) contingent on CONFIG_BLOCK.
(*) set_page_dirty() doesn't call __set_page_dirty_buffers() if CONFIG_BLOCK
is not enabled.
(*) fs/no-block.c is created to hold out-of-line stubs and things that are
required when CONFIG_BLOCK is not set:
(*) Default blockdev file operations (to give error ENODEV on opening).
(*) Makes some /proc changes:
(*) /proc/devices does not list any blockdevs.
(*) /proc/diskstats and /proc/partitions are contingent on CONFIG_BLOCK.
(*) Makes some compat ioctl handling contingent on CONFIG_BLOCK.
(*) If CONFIG_BLOCK is not defined, makes sys_quotactl() return -ENODEV if
given command other than Q_SYNC or if a special device is specified.
(*) In init/do_mounts.c, no reference is made to the blockdev routines if
CONFIG_BLOCK is not defined. This does not prohibit NFS roots or JFFS2.
(*) The bdflush, ioprio_set and ioprio_get syscalls can now be absent (return
error ENOSYS by way of cond_syscall if so).
(*) The seclvl_bd_claim() and seclvl_bd_release() security calls do nothing if
CONFIG_BLOCK is not set, since they can't then happen.
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2006-09-30 22:45:40 +04:00
# endif
2006-06-23 13:03:28 +04:00
2006-06-23 13:03:38 +04:00
/*
* Writeback a page to clean the dirty state
*/
static int writeout ( struct address_space * mapping , struct page * page )
2006-06-23 13:03:33 +04:00
{
2006-06-23 13:03:38 +04:00
struct writeback_control wbc = {
. sync_mode = WB_SYNC_NONE ,
. nr_to_write = 1 ,
. range_start = 0 ,
. range_end = LLONG_MAX ,
. for_reclaim = 1
} ;
int rc ;
if ( ! mapping - > a_ops - > writepage )
/* No write method for the address space */
return - EINVAL ;
if ( ! clear_page_dirty_for_io ( page ) )
/* Someone else already triggered a write */
return - EAGAIN ;
2006-06-23 13:03:33 +04:00
/*
2006-06-23 13:03:38 +04:00
* A dirty page may imply that the underlying filesystem has
* the page on some queue . So the page must be clean for
* migration . Writeout may mean we loose the lock and the
* page state is no longer what we checked for earlier .
* At this point we know that the migration attempt cannot
* be successful .
2006-06-23 13:03:33 +04:00
*/
2016-03-18 00:20:07 +03:00
remove_migration_ptes ( page , page , false ) ;
2006-06-23 13:03:33 +04:00
2006-06-23 13:03:38 +04:00
rc = mapping - > a_ops - > writepage ( page , & wbc ) ;
2006-06-23 13:03:33 +04:00
2006-06-23 13:03:38 +04:00
if ( rc ! = AOP_WRITEPAGE_ACTIVATE )
/* unlocked. Relock */
lock_page ( page ) ;
2008-11-20 02:36:36 +03:00
return ( rc < 0 ) ? - EIO : - EAGAIN ;
2006-06-23 13:03:38 +04:00
}
/*
* Default handling if a filesystem does not provide a migration function .
*/
static int fallback_migrate_page ( struct address_space * mapping ,
2012-01-13 05:19:43 +04:00
struct page * newpage , struct page * page , enum migrate_mode mode )
2006-06-23 13:03:38 +04:00
{
2012-01-13 05:19:34 +04:00
if ( PageDirty ( page ) ) {
2012-01-13 05:19:43 +04:00
/* Only writeback pages in full synchronous migration */
2017-09-09 02:12:06 +03:00
switch ( mode ) {
case MIGRATE_SYNC :
case MIGRATE_SYNC_NO_COPY :
break ;
default :
2012-01-13 05:19:34 +04:00
return - EBUSY ;
2017-09-09 02:12:06 +03:00
}
2006-06-23 13:03:38 +04:00
return writeout ( mapping , page ) ;
2012-01-13 05:19:34 +04:00
}
2006-06-23 13:03:33 +04:00
/*
* Buffers may be managed in a filesystem specific way .
* We must have no buffers or drop them .
*/
2009-04-03 19:42:36 +04:00
if ( page_has_private ( page ) & &
2006-06-23 13:03:33 +04:00
! try_to_release_page ( page , GFP_KERNEL ) )
return - EAGAIN ;
2012-01-13 05:19:43 +04:00
return migrate_page ( mapping , newpage , page , mode ) ;
2006-06-23 13:03:33 +04:00
}
2006-06-23 13:03:51 +04:00
/*
* Move a page to a newly allocated page
* The page is locked and all ptes have been successfully removed .
*
* The new page will have replaced the old page if this function
* is successful .
Unevictable LRU Infrastructure
When the system contains lots of mlocked or otherwise unevictable pages,
the pageout code (kswapd) can spend lots of time scanning over these
pages. Worse still, the presence of lots of unevictable pages can confuse
kswapd into thinking that more aggressive pageout modes are required,
resulting in all kinds of bad behaviour.
Infrastructure to manage pages excluded from reclaim--i.e., hidden from
vmscan. Based on a patch by Larry Woodman of Red Hat. Reworked to
maintain "unevictable" pages on a separate per-zone LRU list, to "hide"
them from vmscan.
Kosaki Motohiro added the support for the memory controller unevictable
lru list.
Pages on the unevictable list have both PG_unevictable and PG_lru set.
Thus, PG_unevictable is analogous to and mutually exclusive with
PG_active--it specifies which LRU list the page is on.
The unevictable infrastructure is enabled by a new mm Kconfig option
[CONFIG_]UNEVICTABLE_LRU.
A new function 'page_evictable(page, vma)' in vmscan.c tests whether or
not a page may be evictable. Subsequent patches will add the various
!evictable tests. We'll want to keep these tests light-weight for use in
shrink_active_list() and, possibly, the fault path.
To avoid races between tasks putting pages [back] onto an LRU list and
tasks that might be moving the page from non-evictable to evictable state,
the new function 'putback_lru_page()' -- inverse to 'isolate_lru_page()'
-- tests the "evictability" of a page after placing it on the LRU, before
dropping the reference. If the page has become unevictable,
putback_lru_page() will redo the 'putback', thus moving the page to the
unevictable list. This way, we avoid "stranding" evictable pages on the
unevictable list.
[akpm@linux-foundation.org: fix fallout from out-of-order merge]
[riel@redhat.com: fix UNEVICTABLE_LRU and !PROC_PAGE_MONITOR build]
[nishimura@mxp.nes.nec.co.jp: remove redundant mapping check]
[kosaki.motohiro@jp.fujitsu.com: unevictable-lru-infrastructure: putback_lru_page()/unevictable page handling rework]
[kosaki.motohiro@jp.fujitsu.com: kill unnecessary lock_page() in vmscan.c]
[kosaki.motohiro@jp.fujitsu.com: revert migration change of unevictable lru infrastructure]
[kosaki.motohiro@jp.fujitsu.com: revert to unevictable-lru-infrastructure-kconfig-fix.patch]
[kosaki.motohiro@jp.fujitsu.com: restore patch failure of vmstat-unevictable-and-mlocked-pages-vm-events.patch]
Signed-off-by: Lee Schermerhorn <lee.schermerhorn@hp.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Debugged-by: Benjamin Kidwell <benjkidwell@yahoo.com>
Signed-off-by: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-10-19 07:26:39 +04:00
*
* Return value :
* < 0 - error code
2012-12-12 04:02:31 +04:00
* MIGRATEPAGE_SUCCESS - success
2006-06-23 13:03:51 +04:00
*/
2010-05-25 01:32:20 +04:00
static int move_to_new_page ( struct page * newpage , struct page * page ,
2015-11-06 05:49:53 +03:00
enum migrate_mode mode )
2006-06-23 13:03:51 +04:00
{
struct address_space * mapping ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
int rc = - EAGAIN ;
bool is_lru = ! __PageMovable ( page ) ;
2006-06-23 13:03:51 +04:00
2015-11-06 05:49:49 +03:00
VM_BUG_ON_PAGE ( ! PageLocked ( page ) , page ) ;
VM_BUG_ON_PAGE ( ! PageLocked ( newpage ) , newpage ) ;
2006-06-23 13:03:51 +04:00
mapping = page_mapping ( page ) ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
if ( likely ( is_lru ) ) {
if ( ! mapping )
rc = migrate_page ( mapping , newpage , page , mode ) ;
else if ( mapping - > a_ops - > migratepage )
/*
* Most pages have a mapping and most filesystems
* provide a migratepage callback . Anonymous pages
* are part of swap space which also has its own
* migratepage callback . This is the most common path
* for page migration .
*/
rc = mapping - > a_ops - > migratepage ( mapping , newpage ,
page , mode ) ;
else
rc = fallback_migrate_page ( mapping , newpage ,
page , mode ) ;
} else {
2006-06-23 13:03:51 +04:00
/*
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
* In case of non - lru page , it could be released after
* isolation step . In that case , we shouldn ' t try migration .
2006-06-23 13:03:51 +04:00
*/
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
VM_BUG_ON_PAGE ( ! PageIsolated ( page ) , page ) ;
if ( ! PageMovable ( page ) ) {
rc = MIGRATEPAGE_SUCCESS ;
__ClearPageIsolated ( page ) ;
goto out ;
}
rc = mapping - > a_ops - > migratepage ( mapping , newpage ,
page , mode ) ;
WARN_ON_ONCE ( rc = = MIGRATEPAGE_SUCCESS & &
! PageIsolated ( page ) ) ;
}
2006-06-23 13:03:51 +04:00
2015-11-06 05:49:53 +03:00
/*
* When successful , old pagecache page - > mapping must be cleared before
* page is freed ; but stats require that PageAnon be left as PageAnon .
*/
if ( rc = = MIGRATEPAGE_SUCCESS ) {
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
if ( __PageMovable ( page ) ) {
VM_BUG_ON_PAGE ( ! PageIsolated ( page ) , page ) ;
/*
* We clear PG_movable under page_lock so any compactor
* cannot try to migrate this page .
*/
__ClearPageIsolated ( page ) ;
}
/*
* Anonymous and movable page - > mapping will be cleard by
* free_pages_prepare so don ' t reset it here for keeping
* the type to work PageAnon , for example .
*/
if ( ! PageMappingFlags ( page ) )
2015-11-06 05:49:53 +03:00
page - > mapping = NULL ;
2010-05-25 01:32:20 +04:00
}
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
out :
2006-06-23 13:03:51 +04:00
return rc ;
}
2011-11-01 04:06:57 +04:00
static int __unmap_and_move ( struct page * page , struct page * newpage ,
2013-02-23 04:35:14 +04:00
int force , enum migrate_mode mode )
2006-06-23 13:03:51 +04:00
{
2011-11-01 04:06:57 +04:00
int rc = - EAGAIN ;
2014-12-13 03:56:19 +03:00
int page_was_mapped = 0 ;
mm: migration: take a reference to the anon_vma before migrating
This patchset is a memory compaction mechanism that reduces external
fragmentation memory by moving GFP_MOVABLE pages to a fewer number of
pageblocks. The term "compaction" was chosen as there are is a number of
mechanisms that are not mutually exclusive that can be used to defragment
memory. For example, lumpy reclaim is a form of defragmentation as was
slub "defragmentation" (really a form of targeted reclaim). Hence, this
is called "compaction" to distinguish it from other forms of
defragmentation.
In this implementation, a full compaction run involves two scanners
operating within a zone - a migration and a free scanner. The migration
scanner starts at the beginning of a zone and finds all movable pages
within one pageblock_nr_pages-sized area and isolates them on a
migratepages list. The free scanner begins at the end of the zone and
searches on a per-area basis for enough free pages to migrate all the
pages on the migratepages list. As each area is respectively migrated or
exhausted of free pages, the scanners are advanced one area. A compaction
run completes within a zone when the two scanners meet.
This method is a bit primitive but is easy to understand and greater
sophistication would require maintenance of counters on a per-pageblock
basis. This would have a big impact on allocator fast-paths to improve
compaction which is a poor trade-off.
It also does not try relocate virtually contiguous pages to be physically
contiguous. However, assuming transparent hugepages were in use, a
hypothetical khugepaged might reuse compaction code to isolate free pages,
split them and relocate userspace pages for promotion.
Memory compaction can be triggered in one of three ways. It may be
triggered explicitly by writing any value to /proc/sys/vm/compact_memory
and compacting all of memory. It can be triggered on a per-node basis by
writing any value to /sys/devices/system/node/nodeN/compact where N is the
node ID to be compacted. When a process fails to allocate a high-order
page, it may compact memory in an attempt to satisfy the allocation
instead of entering direct reclaim. Explicit compaction does not finish
until the two scanners meet and direct compaction ends if a suitable page
becomes available that would meet watermarks.
The series is in 14 patches. The first three are not "core" to the series
but are important pre-requisites.
Patch 1 reference counts anon_vma for rmap_walk_anon(). Without this
patch, it's possible to use anon_vma after free if the caller is
not holding a VMA or mmap_sem for the pages in question. While
there should be no existing user that causes this problem,
it's a requirement for memory compaction to be stable. The patch
is at the start of the series for bisection reasons.
Patch 2 merges the KSM and migrate counts. It could be merged with patch 1
but would be slightly harder to review.
Patch 3 skips over unmapped anon pages during migration as there are no
guarantees about the anon_vma existing. There is a window between
when a page was isolated and migration started during which anon_vma
could disappear.
Patch 4 notes that PageSwapCache pages can still be migrated even if they
are unmapped.
Patch 5 allows CONFIG_MIGRATION to be set without CONFIG_NUMA
Patch 6 exports a "unusable free space index" via debugfs. It's
a measure of external fragmentation that takes the size of the
allocation request into account. It can also be calculated from
userspace so can be dropped if requested
Patch 7 exports a "fragmentation index" which only has meaning when an
allocation request fails. It determines if an allocation failure
would be due to a lack of memory or external fragmentation.
Patch 8 moves the definition for LRU isolation modes for use by compaction
Patch 9 is the compaction mechanism although it's unreachable at this point
Patch 10 adds a means of compacting all of memory with a proc trgger
Patch 11 adds a means of compacting a specific node with a sysfs trigger
Patch 12 adds "direct compaction" before "direct reclaim" if it is
determined there is a good chance of success.
Patch 13 adds a sysctl that allows tuning of the threshold at which the
kernel will compact or direct reclaim
Patch 14 temporarily disables compaction if an allocation failure occurs
after compaction.
Testing of compaction was in three stages. For the test, debugging,
preempt, the sleep watchdog and lockdep were all enabled but nothing nasty
popped out. min_free_kbytes was tuned as recommended by hugeadm to help
fragmentation avoidance and high-order allocations. It was tested on X86,
X86-64 and PPC64.
Ths first test represents one of the easiest cases that can be faced for
lumpy reclaim or memory compaction.
1. Machine freshly booted and configured for hugepage usage with
a) hugeadm --create-global-mounts
b) hugeadm --pool-pages-max DEFAULT:8G
c) hugeadm --set-recommended-min_free_kbytes
d) hugeadm --set-recommended-shmmax
The min_free_kbytes here is important. Anti-fragmentation works best
when pageblocks don't mix. hugeadm knows how to calculate a value that
will significantly reduce the worst of external-fragmentation-related
events as reported by the mm_page_alloc_extfrag tracepoint.
2. Load up memory
a) Start updatedb
b) Create in parallel a X files of pagesize*128 in size. Wait
until files are created. By parallel, I mean that 4096 instances
of dd were launched, one after the other using &. The crude
objective being to mix filesystem metadata allocations with
the buffer cache.
c) Delete every second file so that pageblocks are likely to
have holes
d) kill updatedb if it's still running
At this point, the system is quiet, memory is full but it's full with
clean filesystem metadata and clean buffer cache that is unmapped.
This is readily migrated or discarded so you'd expect lumpy reclaim
to have no significant advantage over compaction but this is at
the POC stage.
3. In increments, attempt to allocate 5% of memory as hugepages.
Measure how long it took, how successful it was, how many
direct reclaims took place and how how many compactions. Note
the compaction figures might not fully add up as compactions
can take place for orders other than the hugepage size
X86 vanilla compaction
Final page count 913 916 (attempted 1002)
pages reclaimed 68296 9791
X86-64 vanilla compaction
Final page count: 901 902 (attempted 1002)
Total pages reclaimed: 112599 53234
PPC64 vanilla compaction
Final page count: 93 94 (attempted 110)
Total pages reclaimed: 103216 61838
There was not a dramatic improvement in success rates but it wouldn't be
expected in this case either. What was important is that fewer pages were
reclaimed in all cases reducing the amount of IO required to satisfy a
huge page allocation.
The second tests were all performance related - kernbench, netperf, iozone
and sysbench. None showed anything too remarkable.
The last test was a high-order allocation stress test. Many kernel
compiles are started to fill memory with a pressured mix of unmovable and
movable allocations. During this, an attempt is made to allocate 90% of
memory as huge pages - one at a time with small delays between attempts to
avoid flooding the IO queue.
vanilla compaction
Percentage of request allocated X86 98 99
Percentage of request allocated X86-64 95 98
Percentage of request allocated PPC64 55 70
This patch:
rmap_walk_anon() does not use page_lock_anon_vma() for looking up and
locking an anon_vma and it does not appear to have sufficient locking to
ensure the anon_vma does not disappear from under it.
This patch copies an approach used by KSM to take a reference on the
anon_vma while pages are being migrated. This should prevent rmap_walk()
running into nasty surprises later because anon_vma has been freed.
Signed-off-by: Mel Gorman <mel@csn.ul.ie>
Acked-by: Rik van Riel <riel@redhat.com>
Cc: Minchan Kim <minchan.kim@gmail.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Christoph Lameter <cl@linux-foundation.org>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-05-25 01:32:17 +04:00
struct anon_vma * anon_vma = NULL ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
bool is_lru = ! __PageMovable ( page ) ;
2006-06-23 13:03:53 +04:00
2008-08-02 14:01:03 +04:00
if ( ! trylock_page ( page ) ) {
2012-01-13 05:19:43 +04:00
if ( ! force | | mode = = MIGRATE_ASYNC )
2011-11-01 04:06:57 +04:00
goto out ;
2011-01-14 02:45:56 +03:00
/*
* It ' s not safe for direct compaction to call lock_page .
* For example , during page readahead pages are added locked
* to the LRU . Later , when the IO completes the pages are
* marked uptodate and unlocked . However , the queueing
* could be merging multiple pages for one bio ( e . g .
* mpage_readpages ) . If an allocation happens for the
* second or third page , the process can end up locking
* the same page twice and deadlocking . Rather than
* trying to be clever about what pages can be locked ,
* avoid the use of lock_page for direct compaction
* altogether .
*/
if ( current - > flags & PF_MEMALLOC )
2011-11-01 04:06:57 +04:00
goto out ;
2011-01-14 02:45:56 +03:00
2006-06-23 13:03:51 +04:00
lock_page ( page ) ;
}
if ( PageWriteback ( page ) ) {
2011-03-23 02:33:11 +03:00
/*
2013-04-30 02:07:58 +04:00
* Only in the case of a full synchronous migration is it
2012-01-13 05:19:43 +04:00
* necessary to wait for PageWriteback . In the async case ,
* the retry loop is too short and in the sync - light case ,
* the overhead of stalling is too much
2011-03-23 02:33:11 +03:00
*/
2017-09-09 02:12:06 +03:00
switch ( mode ) {
case MIGRATE_SYNC :
case MIGRATE_SYNC_NO_COPY :
break ;
default :
2011-03-23 02:33:11 +03:00
rc = - EBUSY ;
mm: memcontrol: rewrite uncharge API
The memcg uncharging code that is involved towards the end of a page's
lifetime - truncation, reclaim, swapout, migration - is impressively
complicated and fragile.
Because anonymous and file pages were always charged before they had their
page->mapping established, uncharges had to happen when the page type
could still be known from the context; as in unmap for anonymous, page
cache removal for file and shmem pages, and swap cache truncation for swap
pages. However, these operations happen well before the page is actually
freed, and so a lot of synchronization is necessary:
- Charging, uncharging, page migration, and charge migration all need
to take a per-page bit spinlock as they could race with uncharging.
- Swap cache truncation happens during both swap-in and swap-out, and
possibly repeatedly before the page is actually freed. This means
that the memcg swapout code is called from many contexts that make
no sense and it has to figure out the direction from page state to
make sure memory and memory+swap are always correctly charged.
- On page migration, the old page might be unmapped but then reused,
so memcg code has to prevent untimely uncharging in that case.
Because this code - which should be a simple charge transfer - is so
special-cased, it is not reusable for replace_page_cache().
But now that charged pages always have a page->mapping, introduce
mem_cgroup_uncharge(), which is called after the final put_page(), when we
know for sure that nobody is looking at the page anymore.
For page migration, introduce mem_cgroup_migrate(), which is called after
the migration is successful and the new page is fully rmapped. Because
the old page is no longer uncharged after migration, prevent double
charges by decoupling the page's memcg association (PCG_USED and
pc->mem_cgroup) from the page holding an actual charge. The new bits
PCG_MEM and PCG_MEMSW represent the respective charges and are transferred
to the new page during migration.
mem_cgroup_migrate() is suitable for replace_page_cache() as well,
which gets rid of mem_cgroup_replace_page_cache(). However, care
needs to be taken because both the source and the target page can
already be charged and on the LRU when fuse is splicing: grab the page
lock on the charge moving side to prevent changing pc->mem_cgroup of a
page under migration. Also, the lruvecs of both pages change as we
uncharge the old and charge the new during migration, and putback may
race with us, so grab the lru lock and isolate the pages iff on LRU to
prevent races and ensure the pages are on the right lruvec afterward.
Swap accounting is massively simplified: because the page is no longer
uncharged as early as swap cache deletion, a new mem_cgroup_swapout() can
transfer the page's memory+swap charge (PCG_MEMSW) to the swap entry
before the final put_page() in page reclaim.
Finally, page_cgroup changes are now protected by whatever protection the
page itself offers: anonymous pages are charged under the page table lock,
whereas page cache insertions, swapin, and migration hold the page lock.
Uncharging happens under full exclusion with no outstanding references.
Charging and uncharging also ensure that the page is off-LRU, which
serializes against charge migration. Remove the very costly page_cgroup
lock and set pc->flags non-atomically.
[mhocko@suse.cz: mem_cgroup_charge_statistics needs preempt_disable]
[vdavydov@parallels.com: fix flags definition]
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Vladimir Davydov <vdavydov@parallels.com>
Tested-by: Jet Chen <jet.chen@intel.com>
Acked-by: Michal Hocko <mhocko@suse.cz>
Tested-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-09 01:19:22 +04:00
goto out_unlock ;
2011-03-23 02:33:11 +03:00
}
if ( ! force )
mm: memcontrol: rewrite uncharge API
The memcg uncharging code that is involved towards the end of a page's
lifetime - truncation, reclaim, swapout, migration - is impressively
complicated and fragile.
Because anonymous and file pages were always charged before they had their
page->mapping established, uncharges had to happen when the page type
could still be known from the context; as in unmap for anonymous, page
cache removal for file and shmem pages, and swap cache truncation for swap
pages. However, these operations happen well before the page is actually
freed, and so a lot of synchronization is necessary:
- Charging, uncharging, page migration, and charge migration all need
to take a per-page bit spinlock as they could race with uncharging.
- Swap cache truncation happens during both swap-in and swap-out, and
possibly repeatedly before the page is actually freed. This means
that the memcg swapout code is called from many contexts that make
no sense and it has to figure out the direction from page state to
make sure memory and memory+swap are always correctly charged.
- On page migration, the old page might be unmapped but then reused,
so memcg code has to prevent untimely uncharging in that case.
Because this code - which should be a simple charge transfer - is so
special-cased, it is not reusable for replace_page_cache().
But now that charged pages always have a page->mapping, introduce
mem_cgroup_uncharge(), which is called after the final put_page(), when we
know for sure that nobody is looking at the page anymore.
For page migration, introduce mem_cgroup_migrate(), which is called after
the migration is successful and the new page is fully rmapped. Because
the old page is no longer uncharged after migration, prevent double
charges by decoupling the page's memcg association (PCG_USED and
pc->mem_cgroup) from the page holding an actual charge. The new bits
PCG_MEM and PCG_MEMSW represent the respective charges and are transferred
to the new page during migration.
mem_cgroup_migrate() is suitable for replace_page_cache() as well,
which gets rid of mem_cgroup_replace_page_cache(). However, care
needs to be taken because both the source and the target page can
already be charged and on the LRU when fuse is splicing: grab the page
lock on the charge moving side to prevent changing pc->mem_cgroup of a
page under migration. Also, the lruvecs of both pages change as we
uncharge the old and charge the new during migration, and putback may
race with us, so grab the lru lock and isolate the pages iff on LRU to
prevent races and ensure the pages are on the right lruvec afterward.
Swap accounting is massively simplified: because the page is no longer
uncharged as early as swap cache deletion, a new mem_cgroup_swapout() can
transfer the page's memory+swap charge (PCG_MEMSW) to the swap entry
before the final put_page() in page reclaim.
Finally, page_cgroup changes are now protected by whatever protection the
page itself offers: anonymous pages are charged under the page table lock,
whereas page cache insertions, swapin, and migration hold the page lock.
Uncharging happens under full exclusion with no outstanding references.
Charging and uncharging also ensure that the page is off-LRU, which
serializes against charge migration. Remove the very costly page_cgroup
lock and set pc->flags non-atomically.
[mhocko@suse.cz: mem_cgroup_charge_statistics needs preempt_disable]
[vdavydov@parallels.com: fix flags definition]
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Vladimir Davydov <vdavydov@parallels.com>
Tested-by: Jet Chen <jet.chen@intel.com>
Acked-by: Michal Hocko <mhocko@suse.cz>
Tested-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-08-09 01:19:22 +04:00
goto out_unlock ;
2006-06-23 13:03:51 +04:00
wait_on_page_writeback ( page ) ;
}
2015-11-06 05:49:56 +03:00
2006-06-23 13:03:51 +04:00
/*
2007-07-26 21:41:07 +04:00
* By try_to_unmap ( ) , page - > mapcount goes down to 0 here . In this case ,
* we cannot notice that anon_vma is freed while we migrates a page .
2011-01-14 02:47:30 +03:00
* This get_anon_vma ( ) delays freeing anon_vma pointer until the end
2007-07-26 21:41:07 +04:00
* of migration . File cache pages are no problem because of page_lock ( )
2007-08-31 10:56:21 +04:00
* File Caches may use write_page ( ) or lock_page ( ) in migration , then ,
* just care Anon page here .
2015-11-06 05:49:56 +03:00
*
* Only page_get_anon_vma ( ) understands the subtleties of
* getting a hold on an anon_vma from outside one of its mms .
* But if we cannot get anon_vma , then we won ' t need it anyway ,
* because that implies that the anon page is no longer mapped
* ( and cannot be remapped so long as we hold the page lock ) .
2007-07-26 21:41:07 +04:00
*/
2015-11-06 05:49:56 +03:00
if ( PageAnon ( page ) & & ! PageKsm ( page ) )
2011-05-25 04:12:10 +04:00
anon_vma = page_get_anon_vma ( page ) ;
2008-02-05 09:29:33 +03:00
2015-11-06 05:49:49 +03:00
/*
* Block others from accessing the new page when we get around to
* establishing additional references . We are usually the only one
* holding a reference to newpage at this point . We used to have a BUG
* here if trylock_page ( newpage ) fails , but would like to allow for
* cases where there might be a race with the previous use of newpage .
* This is much like races on refcount of oldpage : just don ' t BUG ( ) .
*/
if ( unlikely ( ! trylock_page ( newpage ) ) )
goto out_unlock ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
if ( unlikely ( ! is_lru ) ) {
rc = move_to_new_page ( newpage , page , mode ) ;
goto out_unlock_both ;
}
2007-07-26 21:41:07 +04:00
/*
2008-02-05 09:29:33 +03:00
* Corner case handling :
* 1. When a new swap - cache page is read into , it is added to the LRU
* and treated as swapcache but it has no rmap yet .
* Calling try_to_unmap ( ) against a page - > mapping = = NULL page will
* trigger a BUG . So handle it here .
* 2. An orphaned page ( see truncate_complete_page ) might have
* fs - private metadata . The page can be picked up due to memory
* offlining . Everywhere else except page reclaim , the page is
* invisible to the vm , so the page can not be migrated . So try to
* free the metadata , so the page can be freed .
2006-06-23 13:03:51 +04:00
*/
2008-02-05 09:29:33 +03:00
if ( ! page - > mapping ) {
2014-01-24 03:52:54 +04:00
VM_BUG_ON_PAGE ( PageAnon ( page ) , page ) ;
2011-01-14 02:47:30 +03:00
if ( page_has_private ( page ) ) {
2008-02-05 09:29:33 +03:00
try_to_free_buffers ( page ) ;
2015-11-06 05:49:49 +03:00
goto out_unlock_both ;
2008-02-05 09:29:33 +03:00
}
2015-11-06 05:49:49 +03:00
} else if ( page_mapped ( page ) ) {
/* Establish migration ptes */
2015-11-06 05:49:56 +03:00
VM_BUG_ON_PAGE ( PageAnon ( page ) & & ! PageKsm ( page ) & & ! anon_vma ,
page ) ;
2014-12-13 03:56:19 +03:00
try_to_unmap ( page ,
mm/hwpoison: fix race between soft_offline_page and unpoison_memory
Wanpeng Li reported a race between soft_offline_page() and
unpoison_memory(), which causes the following kernel panic:
BUG: Bad page state in process bash pfn:97000
page:ffffea00025c0000 count:0 mapcount:1 mapping: (null) index:0x7f4fdbe00
flags: 0x1fffff80080048(uptodate|active|swapbacked)
page dumped because: PAGE_FLAGS_CHECK_AT_FREE flag(s) set
bad because of flags:
flags: 0x40(active)
Modules linked in: snd_hda_codec_hdmi i915 rpcsec_gss_krb5 nfsv4 dns_resolver bnep rfcomm nfsd bluetooth auth_rpcgss nfs_acl nfs rfkill lockd grace sunrpc i2c_algo_bit drm_kms_helper snd_hda_codec_realtek snd_hda_codec_generic drm snd_hda_intel fscache snd_hda_codec x86_pkg_temp_thermal coretemp kvm_intel snd_hda_core snd_hwdep kvm snd_pcm snd_seq_dummy snd_seq_oss crct10dif_pclmul snd_seq_midi crc32_pclmul snd_seq_midi_event ghash_clmulni_intel snd_rawmidi aesni_intel lrw gf128mul snd_seq glue_helper ablk_helper snd_seq_device cryptd fuse snd_timer dcdbas serio_raw mei_me parport_pc snd mei ppdev i2c_core video lp soundcore parport lpc_ich shpchp mfd_core ext4 mbcache jbd2 sd_mod e1000e ahci ptp libahci crc32c_intel libata pps_core
CPU: 3 PID: 2211 Comm: bash Not tainted 4.2.0-rc5-mm1+ #45
Hardware name: Dell Inc. OptiPlex 7020/0F5C5X, BIOS A03 01/08/2015
Call Trace:
dump_stack+0x48/0x5c
bad_page+0xe6/0x140
free_pages_prepare+0x2f9/0x320
? uncharge_list+0xdd/0x100
free_hot_cold_page+0x40/0x170
__put_single_page+0x20/0x30
put_page+0x25/0x40
unmap_and_move+0x1a6/0x1f0
migrate_pages+0x100/0x1d0
? kill_procs+0x100/0x100
? unlock_page+0x6f/0x90
__soft_offline_page+0x127/0x2a0
soft_offline_page+0xa6/0x200
This race is explained like below:
CPU0 CPU1
soft_offline_page
__soft_offline_page
TestSetPageHWPoison
unpoison_memory
PageHWPoison check (true)
TestClearPageHWPoison
put_page -> release refcount held by get_hwpoison_page in unpoison_memory
put_page -> release refcount held by isolate_lru_page in __soft_offline_page
migrate_pages
The second put_page() releases refcount held by isolate_lru_page() which
will lead to unmap_and_move() releases the last refcount of page and w/
mapcount still 1 since try_to_unmap() is not called if there is only one
user map the page. Anyway, the page refcount and mapcount will still
mess if the page is mapped by multiple users.
This race was introduced by commit 4491f71260 ("mm/memory-failure: set
PageHWPoison before migrate_pages()"), which focuses on preventing the
reuse of successfully migrated page. Before this commit we prevent the
reuse by changing the migratetype to MIGRATE_ISOLATE during soft
offlining, which has the following problems, so simply reverting the
commit is not a best option:
1) it doesn't eliminate the reuse completely, because
set_migratetype_isolate() can fail to set MIGRATE_ISOLATE to the
target page if the pageblock of the page contains one or more
unmovable pages (i.e. has_unmovable_pages() returns true).
2) the original code changes migratetype to MIGRATE_ISOLATE
forcibly, and sets it to MIGRATE_MOVABLE forcibly after soft offline,
regardless of the original migratetype state, which could impact
other subsystems like memory hotplug or compaction.
This patch moves PageSetHWPoison just after put_page() in
unmap_and_move(), which closes up the reported race window and minimizes
another race window b/w SetPageHWPoison and reallocation (which causes
the reuse of soft-offlined page.) The latter race window still exists
but it's acceptable, because it's rare and effectively the same as
ordinary "containment failure" case even if it happens, so keep the
window open is acceptable.
Fixes: 4491f71260 ("mm/memory-failure: set PageHWPoison before migrate_pages()")
Signed-off-by: Wanpeng Li <wanpeng.li@hotmail.com>
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Reported-by: Wanpeng Li <wanpeng.li@hotmail.com>
Tested-by: Wanpeng Li <wanpeng.li@hotmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-09-09 01:03:27 +03:00
TTU_MIGRATION | TTU_IGNORE_MLOCK | TTU_IGNORE_ACCESS ) ;
2014-12-13 03:56:19 +03:00
page_was_mapped = 1 ;
}
2007-07-26 21:41:07 +04:00
2006-06-25 16:46:49 +04:00
if ( ! page_mapped ( page ) )
2015-11-06 05:49:53 +03:00
rc = move_to_new_page ( newpage , page , mode ) ;
2006-06-23 13:03:51 +04:00
2015-11-06 05:49:53 +03:00
if ( page_was_mapped )
remove_migration_ptes ( page ,
2016-03-18 00:20:07 +03:00
rc = = MIGRATEPAGE_SUCCESS ? newpage : page , false ) ;
mm: migration: take a reference to the anon_vma before migrating
This patchset is a memory compaction mechanism that reduces external
fragmentation memory by moving GFP_MOVABLE pages to a fewer number of
pageblocks. The term "compaction" was chosen as there are is a number of
mechanisms that are not mutually exclusive that can be used to defragment
memory. For example, lumpy reclaim is a form of defragmentation as was
slub "defragmentation" (really a form of targeted reclaim). Hence, this
is called "compaction" to distinguish it from other forms of
defragmentation.
In this implementation, a full compaction run involves two scanners
operating within a zone - a migration and a free scanner. The migration
scanner starts at the beginning of a zone and finds all movable pages
within one pageblock_nr_pages-sized area and isolates them on a
migratepages list. The free scanner begins at the end of the zone and
searches on a per-area basis for enough free pages to migrate all the
pages on the migratepages list. As each area is respectively migrated or
exhausted of free pages, the scanners are advanced one area. A compaction
run completes within a zone when the two scanners meet.
This method is a bit primitive but is easy to understand and greater
sophistication would require maintenance of counters on a per-pageblock
basis. This would have a big impact on allocator fast-paths to improve
compaction which is a poor trade-off.
It also does not try relocate virtually contiguous pages to be physically
contiguous. However, assuming transparent hugepages were in use, a
hypothetical khugepaged might reuse compaction code to isolate free pages,
split them and relocate userspace pages for promotion.
Memory compaction can be triggered in one of three ways. It may be
triggered explicitly by writing any value to /proc/sys/vm/compact_memory
and compacting all of memory. It can be triggered on a per-node basis by
writing any value to /sys/devices/system/node/nodeN/compact where N is the
node ID to be compacted. When a process fails to allocate a high-order
page, it may compact memory in an attempt to satisfy the allocation
instead of entering direct reclaim. Explicit compaction does not finish
until the two scanners meet and direct compaction ends if a suitable page
becomes available that would meet watermarks.
The series is in 14 patches. The first three are not "core" to the series
but are important pre-requisites.
Patch 1 reference counts anon_vma for rmap_walk_anon(). Without this
patch, it's possible to use anon_vma after free if the caller is
not holding a VMA or mmap_sem for the pages in question. While
there should be no existing user that causes this problem,
it's a requirement for memory compaction to be stable. The patch
is at the start of the series for bisection reasons.
Patch 2 merges the KSM and migrate counts. It could be merged with patch 1
but would be slightly harder to review.
Patch 3 skips over unmapped anon pages during migration as there are no
guarantees about the anon_vma existing. There is a window between
when a page was isolated and migration started during which anon_vma
could disappear.
Patch 4 notes that PageSwapCache pages can still be migrated even if they
are unmapped.
Patch 5 allows CONFIG_MIGRATION to be set without CONFIG_NUMA
Patch 6 exports a "unusable free space index" via debugfs. It's
a measure of external fragmentation that takes the size of the
allocation request into account. It can also be calculated from
userspace so can be dropped if requested
Patch 7 exports a "fragmentation index" which only has meaning when an
allocation request fails. It determines if an allocation failure
would be due to a lack of memory or external fragmentation.
Patch 8 moves the definition for LRU isolation modes for use by compaction
Patch 9 is the compaction mechanism although it's unreachable at this point
Patch 10 adds a means of compacting all of memory with a proc trgger
Patch 11 adds a means of compacting a specific node with a sysfs trigger
Patch 12 adds "direct compaction" before "direct reclaim" if it is
determined there is a good chance of success.
Patch 13 adds a sysctl that allows tuning of the threshold at which the
kernel will compact or direct reclaim
Patch 14 temporarily disables compaction if an allocation failure occurs
after compaction.
Testing of compaction was in three stages. For the test, debugging,
preempt, the sleep watchdog and lockdep were all enabled but nothing nasty
popped out. min_free_kbytes was tuned as recommended by hugeadm to help
fragmentation avoidance and high-order allocations. It was tested on X86,
X86-64 and PPC64.
Ths first test represents one of the easiest cases that can be faced for
lumpy reclaim or memory compaction.
1. Machine freshly booted and configured for hugepage usage with
a) hugeadm --create-global-mounts
b) hugeadm --pool-pages-max DEFAULT:8G
c) hugeadm --set-recommended-min_free_kbytes
d) hugeadm --set-recommended-shmmax
The min_free_kbytes here is important. Anti-fragmentation works best
when pageblocks don't mix. hugeadm knows how to calculate a value that
will significantly reduce the worst of external-fragmentation-related
events as reported by the mm_page_alloc_extfrag tracepoint.
2. Load up memory
a) Start updatedb
b) Create in parallel a X files of pagesize*128 in size. Wait
until files are created. By parallel, I mean that 4096 instances
of dd were launched, one after the other using &. The crude
objective being to mix filesystem metadata allocations with
the buffer cache.
c) Delete every second file so that pageblocks are likely to
have holes
d) kill updatedb if it's still running
At this point, the system is quiet, memory is full but it's full with
clean filesystem metadata and clean buffer cache that is unmapped.
This is readily migrated or discarded so you'd expect lumpy reclaim
to have no significant advantage over compaction but this is at
the POC stage.
3. In increments, attempt to allocate 5% of memory as hugepages.
Measure how long it took, how successful it was, how many
direct reclaims took place and how how many compactions. Note
the compaction figures might not fully add up as compactions
can take place for orders other than the hugepage size
X86 vanilla compaction
Final page count 913 916 (attempted 1002)
pages reclaimed 68296 9791
X86-64 vanilla compaction
Final page count: 901 902 (attempted 1002)
Total pages reclaimed: 112599 53234
PPC64 vanilla compaction
Final page count: 93 94 (attempted 110)
Total pages reclaimed: 103216 61838
There was not a dramatic improvement in success rates but it wouldn't be
expected in this case either. What was important is that fewer pages were
reclaimed in all cases reducing the amount of IO required to satisfy a
huge page allocation.
The second tests were all performance related - kernbench, netperf, iozone
and sysbench. None showed anything too remarkable.
The last test was a high-order allocation stress test. Many kernel
compiles are started to fill memory with a pressured mix of unmovable and
movable allocations. During this, an attempt is made to allocate 90% of
memory as huge pages - one at a time with small delays between attempts to
avoid flooding the IO queue.
vanilla compaction
Percentage of request allocated X86 98 99
Percentage of request allocated X86-64 95 98
Percentage of request allocated PPC64 55 70
This patch:
rmap_walk_anon() does not use page_lock_anon_vma() for looking up and
locking an anon_vma and it does not appear to have sufficient locking to
ensure the anon_vma does not disappear from under it.
This patch copies an approach used by KSM to take a reference on the
anon_vma while pages are being migrated. This should prevent rmap_walk()
running into nasty surprises later because anon_vma has been freed.
Signed-off-by: Mel Gorman <mel@csn.ul.ie>
Acked-by: Rik van Riel <riel@redhat.com>
Cc: Minchan Kim <minchan.kim@gmail.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Christoph Lameter <cl@linux-foundation.org>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-05-25 01:32:17 +04:00
2015-11-06 05:49:49 +03:00
out_unlock_both :
unlock_page ( newpage ) ;
out_unlock :
mm: migration: take a reference to the anon_vma before migrating
This patchset is a memory compaction mechanism that reduces external
fragmentation memory by moving GFP_MOVABLE pages to a fewer number of
pageblocks. The term "compaction" was chosen as there are is a number of
mechanisms that are not mutually exclusive that can be used to defragment
memory. For example, lumpy reclaim is a form of defragmentation as was
slub "defragmentation" (really a form of targeted reclaim). Hence, this
is called "compaction" to distinguish it from other forms of
defragmentation.
In this implementation, a full compaction run involves two scanners
operating within a zone - a migration and a free scanner. The migration
scanner starts at the beginning of a zone and finds all movable pages
within one pageblock_nr_pages-sized area and isolates them on a
migratepages list. The free scanner begins at the end of the zone and
searches on a per-area basis for enough free pages to migrate all the
pages on the migratepages list. As each area is respectively migrated or
exhausted of free pages, the scanners are advanced one area. A compaction
run completes within a zone when the two scanners meet.
This method is a bit primitive but is easy to understand and greater
sophistication would require maintenance of counters on a per-pageblock
basis. This would have a big impact on allocator fast-paths to improve
compaction which is a poor trade-off.
It also does not try relocate virtually contiguous pages to be physically
contiguous. However, assuming transparent hugepages were in use, a
hypothetical khugepaged might reuse compaction code to isolate free pages,
split them and relocate userspace pages for promotion.
Memory compaction can be triggered in one of three ways. It may be
triggered explicitly by writing any value to /proc/sys/vm/compact_memory
and compacting all of memory. It can be triggered on a per-node basis by
writing any value to /sys/devices/system/node/nodeN/compact where N is the
node ID to be compacted. When a process fails to allocate a high-order
page, it may compact memory in an attempt to satisfy the allocation
instead of entering direct reclaim. Explicit compaction does not finish
until the two scanners meet and direct compaction ends if a suitable page
becomes available that would meet watermarks.
The series is in 14 patches. The first three are not "core" to the series
but are important pre-requisites.
Patch 1 reference counts anon_vma for rmap_walk_anon(). Without this
patch, it's possible to use anon_vma after free if the caller is
not holding a VMA or mmap_sem for the pages in question. While
there should be no existing user that causes this problem,
it's a requirement for memory compaction to be stable. The patch
is at the start of the series for bisection reasons.
Patch 2 merges the KSM and migrate counts. It could be merged with patch 1
but would be slightly harder to review.
Patch 3 skips over unmapped anon pages during migration as there are no
guarantees about the anon_vma existing. There is a window between
when a page was isolated and migration started during which anon_vma
could disappear.
Patch 4 notes that PageSwapCache pages can still be migrated even if they
are unmapped.
Patch 5 allows CONFIG_MIGRATION to be set without CONFIG_NUMA
Patch 6 exports a "unusable free space index" via debugfs. It's
a measure of external fragmentation that takes the size of the
allocation request into account. It can also be calculated from
userspace so can be dropped if requested
Patch 7 exports a "fragmentation index" which only has meaning when an
allocation request fails. It determines if an allocation failure
would be due to a lack of memory or external fragmentation.
Patch 8 moves the definition for LRU isolation modes for use by compaction
Patch 9 is the compaction mechanism although it's unreachable at this point
Patch 10 adds a means of compacting all of memory with a proc trgger
Patch 11 adds a means of compacting a specific node with a sysfs trigger
Patch 12 adds "direct compaction" before "direct reclaim" if it is
determined there is a good chance of success.
Patch 13 adds a sysctl that allows tuning of the threshold at which the
kernel will compact or direct reclaim
Patch 14 temporarily disables compaction if an allocation failure occurs
after compaction.
Testing of compaction was in three stages. For the test, debugging,
preempt, the sleep watchdog and lockdep were all enabled but nothing nasty
popped out. min_free_kbytes was tuned as recommended by hugeadm to help
fragmentation avoidance and high-order allocations. It was tested on X86,
X86-64 and PPC64.
Ths first test represents one of the easiest cases that can be faced for
lumpy reclaim or memory compaction.
1. Machine freshly booted and configured for hugepage usage with
a) hugeadm --create-global-mounts
b) hugeadm --pool-pages-max DEFAULT:8G
c) hugeadm --set-recommended-min_free_kbytes
d) hugeadm --set-recommended-shmmax
The min_free_kbytes here is important. Anti-fragmentation works best
when pageblocks don't mix. hugeadm knows how to calculate a value that
will significantly reduce the worst of external-fragmentation-related
events as reported by the mm_page_alloc_extfrag tracepoint.
2. Load up memory
a) Start updatedb
b) Create in parallel a X files of pagesize*128 in size. Wait
until files are created. By parallel, I mean that 4096 instances
of dd were launched, one after the other using &. The crude
objective being to mix filesystem metadata allocations with
the buffer cache.
c) Delete every second file so that pageblocks are likely to
have holes
d) kill updatedb if it's still running
At this point, the system is quiet, memory is full but it's full with
clean filesystem metadata and clean buffer cache that is unmapped.
This is readily migrated or discarded so you'd expect lumpy reclaim
to have no significant advantage over compaction but this is at
the POC stage.
3. In increments, attempt to allocate 5% of memory as hugepages.
Measure how long it took, how successful it was, how many
direct reclaims took place and how how many compactions. Note
the compaction figures might not fully add up as compactions
can take place for orders other than the hugepage size
X86 vanilla compaction
Final page count 913 916 (attempted 1002)
pages reclaimed 68296 9791
X86-64 vanilla compaction
Final page count: 901 902 (attempted 1002)
Total pages reclaimed: 112599 53234
PPC64 vanilla compaction
Final page count: 93 94 (attempted 110)
Total pages reclaimed: 103216 61838
There was not a dramatic improvement in success rates but it wouldn't be
expected in this case either. What was important is that fewer pages were
reclaimed in all cases reducing the amount of IO required to satisfy a
huge page allocation.
The second tests were all performance related - kernbench, netperf, iozone
and sysbench. None showed anything too remarkable.
The last test was a high-order allocation stress test. Many kernel
compiles are started to fill memory with a pressured mix of unmovable and
movable allocations. During this, an attempt is made to allocate 90% of
memory as huge pages - one at a time with small delays between attempts to
avoid flooding the IO queue.
vanilla compaction
Percentage of request allocated X86 98 99
Percentage of request allocated X86-64 95 98
Percentage of request allocated PPC64 55 70
This patch:
rmap_walk_anon() does not use page_lock_anon_vma() for looking up and
locking an anon_vma and it does not appear to have sufficient locking to
ensure the anon_vma does not disappear from under it.
This patch copies an approach used by KSM to take a reference on the
anon_vma while pages are being migrated. This should prevent rmap_walk()
running into nasty surprises later because anon_vma has been freed.
Signed-off-by: Mel Gorman <mel@csn.ul.ie>
Acked-by: Rik van Riel <riel@redhat.com>
Cc: Minchan Kim <minchan.kim@gmail.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Christoph Lameter <cl@linux-foundation.org>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-05-25 01:32:17 +04:00
/* Drop an anon_vma reference if we took one */
2010-08-10 04:18:41 +04:00
if ( anon_vma )
2011-03-23 02:32:46 +03:00
put_anon_vma ( anon_vma ) ;
2006-06-23 13:03:51 +04:00
unlock_page ( page ) ;
2011-11-01 04:06:57 +04:00
out :
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
/*
* If migration is successful , decrease refcount of the newpage
* which will not free the page because new page owner increased
* refcounter . As well , if it is LRU page , add the page to LRU
* list in here .
*/
if ( rc = = MIGRATEPAGE_SUCCESS ) {
2016-07-27 01:23:09 +03:00
if ( unlikely ( __PageMovable ( newpage ) ) )
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
put_page ( newpage ) ;
else
putback_lru_page ( newpage ) ;
}
2011-11-01 04:06:57 +04:00
return rc ;
}
2006-06-23 13:03:53 +04:00
2015-04-15 01:44:22 +03:00
/*
* gcc 4.7 and 4.8 on arm get an ICEs when inlining unmap_and_move ( ) . Work
* around it .
*/
# if (GCC_VERSION >= 40700 && GCC_VERSION < 40900) && defined(CONFIG_ARM)
# define ICE_noinline noinline
# else
# define ICE_noinline
# endif
2011-11-01 04:06:57 +04:00
/*
* Obtain the lock on page , remove all ptes and migrate the page
* to the newly allocated page in newpage .
*/
2015-04-15 01:44:22 +03:00
static ICE_noinline int unmap_and_move ( new_page_t get_new_page ,
free_page_t put_new_page ,
unsigned long private , struct page * page ,
mm: soft-offline: don't free target page in successful page migration
Stress testing showed that soft offline events for a process iterating
"mmap-pagefault-munmap" loop can trigger
VM_BUG_ON(PAGE_FLAGS_CHECK_AT_PREP) in __free_one_page():
Soft offlining page 0x70fe1 at 0x70100008d000
Soft offlining page 0x705fb at 0x70300008d000
page:ffffea0001c3f840 count:0 mapcount:0 mapping: (null) index:0x2
flags: 0x1fffff80800000(hwpoison)
page dumped because: VM_BUG_ON_PAGE(page->flags & ((1 << 25) - 1))
------------[ cut here ]------------
kernel BUG at /src/linux-dev/mm/page_alloc.c:585!
invalid opcode: 0000 [#1] SMP DEBUG_PAGEALLOC
Modules linked in: cfg80211 rfkill crc32c_intel microcode ppdev parport_pc pcspkr serio_raw virtio_balloon parport i2c_piix4 virtio_blk virtio_net ata_generic pata_acpi floppy
CPU: 3 PID: 1779 Comm: test_base_madv_ Not tainted 4.0.0-v4.0-150511-1451-00009-g82360a3730e6 #139
RIP: free_pcppages_bulk+0x52a/0x6f0
Call Trace:
drain_pages_zone+0x3d/0x50
drain_local_pages+0x1d/0x30
on_each_cpu_mask+0x46/0x80
drain_all_pages+0x14b/0x1e0
soft_offline_page+0x432/0x6e0
SyS_madvise+0x73c/0x780
system_call_fastpath+0x12/0x17
Code: ff 89 45 b4 48 8b 45 c0 48 83 b8 a8 00 00 00 00 0f 85 e3 fb ff ff 0f 1f 00 0f 0b 48 8b 7d 90 48 c7 c6 e8 95 a6 81 e8 e6 32 02 00 <0f> 0b 8b 45 cc 49 89 47 30 41 8b 47 18 83 f8 ff 0f 85 10 ff ff
RIP [<ffffffff811a806a>] free_pcppages_bulk+0x52a/0x6f0
RSP <ffff88007a117d28>
---[ end trace 53926436e76d1f35 ]---
When soft offline successfully migrates page, the source page is supposed
to be freed. But there is a race condition where a source page looks
isolated (i.e. the refcount is 0 and the PageHWPoison is set) but
somewhat linked to pcplist. Then another soft offline event calls
drain_all_pages() and tries to free such hwpoisoned page, which is
forbidden.
This odd page state seems to happen due to the race between put_page() in
putback_lru_page() and __pagevec_lru_add_fn(). But I don't want to play
with tweaking drain code as done in commit 9ab3b598d2df "mm: hwpoison:
drop lru_add_drain_all() in __soft_offline_page()", or to change page
freeing code for this soft offline's purpose.
Instead, let's think about the difference between hard offline and soft
offline. There is an interesting difference in how to isolate the in-use
page between these, that is, hard offline marks PageHWPoison of the target
page at first, and doesn't free it by keeping its refcount 1. OTOH, soft
offline tries to free the target page then marks PageHWPoison. This
difference might be the source of complexity and result in bugs like the
above. So making soft offline isolate with keeping refcount can be a
solution for this problem.
We can pass to page migration code the "reason" which shows the caller, so
let's use this more to avoid calling putback_lru_page() when called from
soft offline, which effectively does the isolation for soft offline. With
this change, target pages of soft offline never be reused without changing
migratetype, so this patch also removes the related code.
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Tony Luck <tony.luck@intel.com>
Cc: "Kirill A. Shutemov" <kirill@shutemov.name>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-06-25 02:56:50 +03:00
int force , enum migrate_mode mode ,
enum migrate_reason reason )
2011-11-01 04:06:57 +04:00
{
2015-11-06 05:49:46 +03:00
int rc = MIGRATEPAGE_SUCCESS ;
struct page * newpage ;
2011-11-01 04:06:57 +04:00
2018-04-11 02:30:03 +03:00
newpage = get_new_page ( page , private ) ;
2011-11-01 04:06:57 +04:00
if ( ! newpage )
return - ENOMEM ;
if ( page_count ( page ) = = 1 ) {
/* page was freed from under us. So we are done. */
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
ClearPageActive ( page ) ;
ClearPageUnevictable ( page ) ;
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
if ( unlikely ( __PageMovable ( page ) ) ) {
lock_page ( page ) ;
if ( ! PageMovable ( page ) )
__ClearPageIsolated ( page ) ;
unlock_page ( page ) ;
}
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
if ( put_new_page )
put_new_page ( newpage , private ) ;
else
put_page ( newpage ) ;
2011-11-01 04:06:57 +04:00
goto out ;
}
2017-09-09 02:10:57 +03:00
if ( unlikely ( PageTransHuge ( page ) & & ! PageTransHuge ( newpage ) ) ) {
2016-01-16 03:54:00 +03:00
lock_page ( page ) ;
rc = split_huge_page ( page ) ;
unlock_page ( page ) ;
if ( rc )
2011-11-01 04:06:57 +04:00
goto out ;
2016-01-16 03:54:00 +03:00
}
2011-11-01 04:06:57 +04:00
2013-02-23 04:35:14 +04:00
rc = __unmap_and_move ( page , newpage , force , mode ) ;
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
if ( rc = = MIGRATEPAGE_SUCCESS )
2016-03-16 00:56:18 +03:00
set_page_owner_migrate_reason ( newpage , reason ) ;
2012-12-12 04:02:42 +04:00
2011-11-01 04:06:57 +04:00
out :
2006-06-23 13:03:51 +04:00
if ( rc ! = - EAGAIN ) {
2011-11-01 04:06:57 +04:00
/*
* A page that has been migrated has all references
* removed and will be freed . A page that has not been
* migrated will have kepts its references and be
* restored .
*/
list_del ( & page - > lru ) ;
2016-12-13 03:42:26 +03:00
/*
* Compaction can migrate also non - LRU pages which are
* not accounted to NR_ISOLATED_ * . They can be recognized
* as __PageMovable
*/
if ( likely ( ! __PageMovable ( page ) ) )
2017-09-09 02:11:12 +03:00
mod_node_page_state ( page_pgdat ( page ) , NR_ISOLATED_ANON +
page_is_file_cache ( page ) , - hpage_nr_pages ( page ) ) ;
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
}
/*
* If migration is successful , releases reference grabbed during
* isolation . Otherwise , restore the page to right list unless
* we want to retry .
*/
if ( rc = = MIGRATEPAGE_SUCCESS ) {
put_page ( page ) ;
if ( reason = = MR_MEMORY_FAILURE ) {
2016-04-29 02:18:44 +03:00
/*
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
* Set PG_HWPoison on just freed page
* intentionally . Although it ' s rather weird ,
* it ' s how HWPoison flag works at the moment .
2016-04-29 02:18:44 +03:00
*/
mm/hwpoison: fix race between soft_offline_page and unpoison_memory
Wanpeng Li reported a race between soft_offline_page() and
unpoison_memory(), which causes the following kernel panic:
BUG: Bad page state in process bash pfn:97000
page:ffffea00025c0000 count:0 mapcount:1 mapping: (null) index:0x7f4fdbe00
flags: 0x1fffff80080048(uptodate|active|swapbacked)
page dumped because: PAGE_FLAGS_CHECK_AT_FREE flag(s) set
bad because of flags:
flags: 0x40(active)
Modules linked in: snd_hda_codec_hdmi i915 rpcsec_gss_krb5 nfsv4 dns_resolver bnep rfcomm nfsd bluetooth auth_rpcgss nfs_acl nfs rfkill lockd grace sunrpc i2c_algo_bit drm_kms_helper snd_hda_codec_realtek snd_hda_codec_generic drm snd_hda_intel fscache snd_hda_codec x86_pkg_temp_thermal coretemp kvm_intel snd_hda_core snd_hwdep kvm snd_pcm snd_seq_dummy snd_seq_oss crct10dif_pclmul snd_seq_midi crc32_pclmul snd_seq_midi_event ghash_clmulni_intel snd_rawmidi aesni_intel lrw gf128mul snd_seq glue_helper ablk_helper snd_seq_device cryptd fuse snd_timer dcdbas serio_raw mei_me parport_pc snd mei ppdev i2c_core video lp soundcore parport lpc_ich shpchp mfd_core ext4 mbcache jbd2 sd_mod e1000e ahci ptp libahci crc32c_intel libata pps_core
CPU: 3 PID: 2211 Comm: bash Not tainted 4.2.0-rc5-mm1+ #45
Hardware name: Dell Inc. OptiPlex 7020/0F5C5X, BIOS A03 01/08/2015
Call Trace:
dump_stack+0x48/0x5c
bad_page+0xe6/0x140
free_pages_prepare+0x2f9/0x320
? uncharge_list+0xdd/0x100
free_hot_cold_page+0x40/0x170
__put_single_page+0x20/0x30
put_page+0x25/0x40
unmap_and_move+0x1a6/0x1f0
migrate_pages+0x100/0x1d0
? kill_procs+0x100/0x100
? unlock_page+0x6f/0x90
__soft_offline_page+0x127/0x2a0
soft_offline_page+0xa6/0x200
This race is explained like below:
CPU0 CPU1
soft_offline_page
__soft_offline_page
TestSetPageHWPoison
unpoison_memory
PageHWPoison check (true)
TestClearPageHWPoison
put_page -> release refcount held by get_hwpoison_page in unpoison_memory
put_page -> release refcount held by isolate_lru_page in __soft_offline_page
migrate_pages
The second put_page() releases refcount held by isolate_lru_page() which
will lead to unmap_and_move() releases the last refcount of page and w/
mapcount still 1 since try_to_unmap() is not called if there is only one
user map the page. Anyway, the page refcount and mapcount will still
mess if the page is mapped by multiple users.
This race was introduced by commit 4491f71260 ("mm/memory-failure: set
PageHWPoison before migrate_pages()"), which focuses on preventing the
reuse of successfully migrated page. Before this commit we prevent the
reuse by changing the migratetype to MIGRATE_ISOLATE during soft
offlining, which has the following problems, so simply reverting the
commit is not a best option:
1) it doesn't eliminate the reuse completely, because
set_migratetype_isolate() can fail to set MIGRATE_ISOLATE to the
target page if the pageblock of the page contains one or more
unmovable pages (i.e. has_unmovable_pages() returns true).
2) the original code changes migratetype to MIGRATE_ISOLATE
forcibly, and sets it to MIGRATE_MOVABLE forcibly after soft offline,
regardless of the original migratetype state, which could impact
other subsystems like memory hotplug or compaction.
This patch moves PageSetHWPoison just after put_page() in
unmap_and_move(), which closes up the reported race window and minimizes
another race window b/w SetPageHWPoison and reallocation (which causes
the reuse of soft-offlined page.) The latter race window still exists
but it's acceptable, because it's rare and effectively the same as
ordinary "containment failure" case even if it happens, so keep the
window open is acceptable.
Fixes: 4491f71260 ("mm/memory-failure: set PageHWPoison before migrate_pages()")
Signed-off-by: Wanpeng Li <wanpeng.li@hotmail.com>
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Reported-by: Wanpeng Li <wanpeng.li@hotmail.com>
Tested-by: Wanpeng Li <wanpeng.li@hotmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-09-09 01:03:27 +03:00
if ( ! test_set_page_hwpoison ( page ) )
num_poisoned_pages_inc ( ) ;
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
}
} else {
mm: migrate: support non-lru movable page migration
We have allowed migration for only LRU pages until now and it was enough
to make high-order pages. But recently, embedded system(e.g., webOS,
android) uses lots of non-movable pages(e.g., zram, GPU memory) so we
have seen several reports about troubles of small high-order allocation.
For fixing the problem, there were several efforts (e,g,. enhance
compaction algorithm, SLUB fallback to 0-order page, reserved memory,
vmalloc and so on) but if there are lots of non-movable pages in system,
their solutions are void in the long run.
So, this patch is to support facility to change non-movable pages with
movable. For the feature, this patch introduces functions related to
migration to address_space_operations as well as some page flags.
If a driver want to make own pages movable, it should define three
functions which are function pointers of struct
address_space_operations.
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
What VM expects on isolate_page function of driver is to return *true*
if driver isolates page successfully. On returing true, VM marks the
page as PG_isolated so concurrent isolation in several CPUs skip the
page for isolation. If a driver cannot isolate the page, it should
return *false*.
Once page is successfully isolated, VM uses page.lru fields so driver
shouldn't expect to preserve values in that fields.
2. int (*migratepage) (struct address_space *mapping,
struct page *newpage, struct page *oldpage, enum migrate_mode);
After isolation, VM calls migratepage of driver with isolated page. The
function of migratepage is to move content of the old page to new page
and set up fields of struct page newpage. Keep in mind that you should
indicate to the VM the oldpage is no longer movable via
__ClearPageMovable() under page_lock if you migrated the oldpage
successfully and returns 0. If driver cannot migrate the page at the
moment, driver can return -EAGAIN. On -EAGAIN, VM will retry page
migration in a short time because VM interprets -EAGAIN as "temporal
migration failure". On returning any error except -EAGAIN, VM will give
up the page migration without retrying in this time.
Driver shouldn't touch page.lru field VM using in the functions.
3. void (*putback_page)(struct page *);
If migration fails on isolated page, VM should return the isolated page
to the driver so VM calls driver's putback_page with migration failed
page. In this function, driver should put the isolated page back to the
own data structure.
4. non-lru movable page flags
There are two page flags for supporting non-lru movable page.
* PG_movable
Driver should use the below function to make page movable under
page_lock.
void __SetPageMovable(struct page *page, struct address_space *mapping)
It needs argument of address_space for registering migration family
functions which will be called by VM. Exactly speaking, PG_movable is
not a real flag of struct page. Rather than, VM reuses page->mapping's
lower bits to represent it.
#define PAGE_MAPPING_MOVABLE 0x2
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
so driver shouldn't access page->mapping directly. Instead, driver
should use page_mapping which mask off the low two bits of page->mapping
so it can get right struct address_space.
For testing of non-lru movable page, VM supports __PageMovable function.
However, it doesn't guarantee to identify non-lru movable page because
page->mapping field is unified with other variables in struct page. As
well, if driver releases the page after isolation by VM, page->mapping
doesn't have stable value although it has PAGE_MAPPING_MOVABLE (Look at
__ClearPageMovable). But __PageMovable is cheap to catch whether page
is LRU or non-lru movable once the page has been isolated. Because LRU
pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
good for just peeking to test non-lru movable pages before more
expensive checking with lock_page in pfn scanning to select victim.
For guaranteeing non-lru movable page, VM provides PageMovable function.
Unlike __PageMovable, PageMovable functions validates page->mapping and
mapping->a_ops->isolate_page under lock_page. The lock_page prevents
sudden destroying of page->mapping.
Driver using __SetPageMovable should clear the flag via
__ClearMovablePage under page_lock before the releasing the page.
* PG_isolated
To prevent concurrent isolation among several CPUs, VM marks isolated
page as PG_isolated under lock_page. So if a CPU encounters PG_isolated
non-lru movable page, it can skip it. Driver doesn't need to manipulate
the flag because VM will set/clear it automatically. Keep in mind that
if driver sees PG_isolated page, it means the page have been isolated by
VM so it shouldn't touch page.lru field. PG_isolated is alias with
PG_reclaim flag so driver shouldn't use the flag for own purpose.
[opensource.ganesh@gmail.com: mm/compaction: remove local variable is_lru]
Link: http://lkml.kernel.org/r/20160618014841.GA7422@leo-test
Link: http://lkml.kernel.org/r/1464736881-24886-3-git-send-email-minchan@kernel.org
Signed-off-by: Gioh Kim <gi-oh.kim@profitbricks.com>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Signed-off-by: Ganesh Mahendran <opensource.ganesh@gmail.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Rafael Aquini <aquini@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: John Einar Reitan <john.reitan@foss.arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:05 +03:00
if ( rc ! = - EAGAIN ) {
if ( likely ( ! __PageMovable ( page ) ) ) {
putback_lru_page ( page ) ;
goto put_new ;
}
lock_page ( page ) ;
if ( PageMovable ( page ) )
putback_movable_page ( page ) ;
else
__ClearPageIsolated ( page ) ;
unlock_page ( page ) ;
put_page ( page ) ;
}
put_new :
mm: use put_page() to free page instead of putback_lru_page()
Recently, I got many reports about perfermance degradation in embedded
system(Android mobile phone, webOS TV and so on) and easy fork fail.
The problem was fragmentation caused by zram and GPU driver mainly.
With memory pressure, their pages were spread out all of pageblock and
it cannot be migrated with current compaction algorithm which supports
only LRU pages. In the end, compaction cannot work well so reclaimer
shrinks all of working set pages. It made system very slow and even to
fail to fork easily which requires order-[2 or 3] allocations.
Other pain point is that they cannot use CMA memory space so when OOM
kill happens, I can see many free pages in CMA area, which is not memory
efficient. In our product which has big CMA memory, it reclaims zones
too exccessively to allocate GPU and zram page although there are lots
of free space in CMA so system becomes very slow easily.
To solve these problem, this patch tries to add facility to migrate
non-lru pages via introducing new functions and page flags to help
migration.
struct address_space_operations {
..
..
bool (*isolate_page)(struct page *, isolate_mode_t);
void (*putback_page)(struct page *);
..
}
new page flags
PG_movable
PG_isolated
For details, please read description in "mm: migrate: support non-lru
movable page migration".
Originally, Gioh Kim had tried to support this feature but he moved so I
took over the work. I took many code from his work and changed a little
bit and Konstantin Khlebnikov helped Gioh a lot so he should deserve to
have many credit, too.
And I should mention Chulmin who have tested this patchset heavily so I
can find many bugs from him. :)
Thanks, Gioh, Konstantin and Chulmin!
This patchset consists of five parts.
1. clean up migration
mm: use put_page to free page instead of putback_lru_page
2. add non-lru page migration feature
mm: migrate: support non-lru movable page migration
3. rework KVM memory-ballooning
mm: balloon: use general non-lru movable page feature
4. zsmalloc refactoring for preparing page migration
zsmalloc: keep max_object in size_class
zsmalloc: use bit_spin_lock
zsmalloc: use accessor
zsmalloc: factor page chain functionality out
zsmalloc: introduce zspage structure
zsmalloc: separate free_zspage from putback_zspage
zsmalloc: use freeobj for index
5. zsmalloc page migration
zsmalloc: page migration support
zram: use __GFP_MOVABLE for memory allocation
This patch (of 12):
Procedure of page migration is as follows:
First of all, it should isolate a page from LRU and try to migrate the
page. If it is successful, it releases the page for freeing.
Otherwise, it should put the page back to LRU list.
For LRU pages, we have used putback_lru_page for both freeing and
putback to LRU list. It's okay because put_page is aware of LRU list so
if it releases last refcount of the page, it removes the page from LRU
list. However, It makes unnecessary operations (e.g., lru_cache_add,
pagevec and flags operations. It would be not significant but no worth
to do) and harder to support new non-lru page migration because put_page
isn't aware of non-lru page's data structure.
To solve the problem, we can add new hook in put_page with PageMovable
flags check but it can increase overhead in hot path and needs new
locking scheme to stabilize the flag check with put_page.
So, this patch cleans it up to divide two semantic(ie, put and putback).
If migration is successful, use put_page instead of putback_lru_page and
use putback_lru_page only on failure. That makes code more readable and
doesn't add overhead in put_page.
Comment from Vlastimil
"Yeah, and compaction (perhaps also other migration users) has to drain
the lru pvec... Getting rid of this stuff is worth even by itself."
Link: http://lkml.kernel.org/r/1464736881-24886-2-git-send-email-minchan@kernel.org
Signed-off-by: Minchan Kim <minchan@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-27 01:23:02 +03:00
if ( put_new_page )
put_new_page ( newpage , private ) ;
else
put_page ( newpage ) ;
2006-06-23 13:03:51 +04:00
}
2014-06-05 03:08:25 +04:00
2006-06-23 13:03:51 +04:00
return rc ;
}
2010-09-08 05:19:35 +04:00
/*
* Counterpart of unmap_and_move_page ( ) for hugepage migration .
*
* This function doesn ' t wait the completion of hugepage I / O
* because there is no race between I / O and migration for hugepage .
* Note that currently hugepage I / O occurs only in direct I / O
* where no lock is held and PG_writeback is irrelevant ,
* and writeback status of all subpages are counted in the reference
* count of the head page ( i . e . if all subpages of a 2 MB hugepage are
* under direct I / O , the reference of the head page is 512 and a bit more . )
* This means that when we try to migrate hugepage whose subpages are
* doing direct I / O , some references remain after try_to_unmap ( ) and
* hugepage migration fails without data corruption .
*
* There is also no race when direct I / O is issued on the page under migration ,
* because then pte is replaced with migration swap entry and direct I / O code
* will wait in the page fault for migration to complete .
*/
static int unmap_and_move_huge_page ( new_page_t get_new_page ,
2014-06-05 03:08:25 +04:00
free_page_t put_new_page , unsigned long private ,
struct page * hpage , int force ,
2016-03-16 00:56:18 +03:00
enum migrate_mode mode , int reason )
2010-09-08 05:19:35 +04:00
{
2015-11-06 05:49:46 +03:00
int rc = - EAGAIN ;
2014-12-13 03:56:19 +03:00
int page_was_mapped = 0 ;
2014-01-22 03:51:15 +04:00
struct page * new_hpage ;
2010-09-08 05:19:35 +04:00
struct anon_vma * anon_vma = NULL ;
2013-09-12 01:22:11 +04:00
/*
* Movability of hugepages depends on architectures and hugepage size .
* This check is necessary because some callers of hugepage migration
* like soft offline and memory hotremove don ' t walk through page
* tables or check whether the hugepage is pmd - based or not before
* kicking migration .
*/
2014-06-05 03:10:56 +04:00
if ( ! hugepage_migration_supported ( page_hstate ( hpage ) ) ) {
2014-01-22 03:51:15 +04:00
putback_active_hugepage ( hpage ) ;
2013-09-12 01:22:11 +04:00
return - ENOSYS ;
2014-01-22 03:51:15 +04:00
}
2013-09-12 01:22:11 +04:00
2018-04-11 02:30:03 +03:00
new_hpage = get_new_page ( hpage , private ) ;
2010-09-08 05:19:35 +04:00
if ( ! new_hpage )
return - ENOMEM ;
if ( ! trylock_page ( hpage ) ) {
2017-09-09 02:12:06 +03:00
if ( ! force )
2010-09-08 05:19:35 +04:00
goto out ;
2017-09-09 02:12:06 +03:00
switch ( mode ) {
case MIGRATE_SYNC :
case MIGRATE_SYNC_NO_COPY :
break ;
default :
goto out ;
}
2010-09-08 05:19:35 +04:00
lock_page ( hpage ) ;
}
2011-05-25 04:12:10 +04:00
if ( PageAnon ( hpage ) )
anon_vma = page_get_anon_vma ( hpage ) ;
2010-09-08 05:19:35 +04:00
2015-11-06 05:49:49 +03:00
if ( unlikely ( ! trylock_page ( new_hpage ) ) )
goto put_anon ;
2014-12-13 03:56:19 +03:00
if ( page_mapped ( hpage ) ) {
try_to_unmap ( hpage ,
TTU_MIGRATION | TTU_IGNORE_MLOCK | TTU_IGNORE_ACCESS ) ;
page_was_mapped = 1 ;
}
2010-09-08 05:19:35 +04:00
if ( ! page_mapped ( hpage ) )
2015-11-06 05:49:53 +03:00
rc = move_to_new_page ( new_hpage , hpage , mode ) ;
2010-09-08 05:19:35 +04:00
2015-11-06 05:49:53 +03:00
if ( page_was_mapped )
remove_migration_ptes ( hpage ,
2016-03-18 00:20:07 +03:00
rc = = MIGRATEPAGE_SUCCESS ? new_hpage : hpage , false ) ;
2010-09-08 05:19:35 +04:00
2015-11-06 05:49:49 +03:00
unlock_page ( new_hpage ) ;
put_anon :
2011-01-14 02:47:31 +03:00
if ( anon_vma )
2011-03-23 02:32:46 +03:00
put_anon_vma ( anon_vma ) ;
2012-08-01 03:42:27 +04:00
2015-11-06 05:49:46 +03:00
if ( rc = = MIGRATEPAGE_SUCCESS ) {
2018-02-01 03:20:48 +03:00
move_hugetlb_state ( hpage , new_hpage , reason ) ;
2015-11-06 05:49:46 +03:00
put_new_page = NULL ;
}
2012-08-01 03:42:27 +04:00
2010-09-08 05:19:35 +04:00
unlock_page ( hpage ) ;
2011-12-09 02:34:20 +04:00
out :
2013-09-12 01:22:01 +04:00
if ( rc ! = - EAGAIN )
putback_active_hugepage ( hpage ) ;
2017-07-11 01:47:41 +03:00
if ( reason = = MR_MEMORY_FAILURE & & ! test_set_page_hwpoison ( hpage ) )
num_poisoned_pages_inc ( ) ;
2014-06-05 03:08:25 +04:00
/*
* If migration was not successful and there ' s a freeing callback , use
* it . Otherwise , put_page ( ) will drop the reference grabbed during
* isolation .
*/
2015-11-06 05:49:46 +03:00
if ( put_new_page )
2014-06-05 03:08:25 +04:00
put_new_page ( new_hpage , private ) ;
else
2015-09-23 00:59:14 +03:00
putback_active_hugepage ( new_hpage ) ;
2014-06-05 03:08:25 +04:00
2010-09-08 05:19:35 +04:00
return rc ;
}
2006-03-22 11:09:12 +03:00
/*
2013-04-30 02:08:16 +04:00
* migrate_pages - migrate the pages specified in a list , to the free pages
* supplied as the target for the page migration
2006-03-22 11:09:12 +03:00
*
2013-04-30 02:08:16 +04:00
* @ from : The list of pages to be migrated .
* @ get_new_page : The function used to allocate free pages to be used
* as the target of the page migration .
2014-06-05 03:08:25 +04:00
* @ put_new_page : The function used to free target pages if migration
* fails , or NULL if no special handling is necessary .
2013-04-30 02:08:16 +04:00
* @ private : Private data to be passed on to get_new_page ( )
* @ mode : The migration mode that specifies the constraints for
* page migration , if any .
* @ reason : The reason for page migration .
2006-03-22 11:09:12 +03:00
*
2013-04-30 02:08:16 +04:00
* The function returns after 10 attempts or if no pages are movable any more
* because the list has become empty or no retryable pages exist any more .
2015-11-06 05:49:43 +03:00
* The caller should call putback_movable_pages ( ) to return pages to the LRU
2011-01-26 02:07:26 +03:00
* or free list only if ret ! = 0.
2006-03-22 11:09:12 +03:00
*
2013-04-30 02:08:16 +04:00
* Returns the number of pages that were not migrated , or an error code .
2006-03-22 11:09:12 +03:00
*/
2013-02-23 04:35:14 +04:00
int migrate_pages ( struct list_head * from , new_page_t get_new_page ,
2014-06-05 03:08:25 +04:00
free_page_t put_new_page , unsigned long private ,
enum migrate_mode mode , int reason )
2006-03-22 11:09:12 +03:00
{
2006-06-23 13:03:51 +04:00
int retry = 1 ;
2006-03-22 11:09:12 +03:00
int nr_failed = 0 ;
2012-10-19 13:46:20 +04:00
int nr_succeeded = 0 ;
2006-03-22 11:09:12 +03:00
int pass = 0 ;
struct page * page ;
struct page * page2 ;
int swapwrite = current - > flags & PF_SWAPWRITE ;
int rc ;
if ( ! swapwrite )
current - > flags | = PF_SWAPWRITE ;
2006-06-23 13:03:51 +04:00
for ( pass = 0 ; pass < 10 & & retry ; pass + + ) {
retry = 0 ;
2006-03-22 11:09:12 +03:00
2006-06-23 13:03:51 +04:00
list_for_each_entry_safe ( page , page2 , from , lru ) {
cond_resched ( ) ;
2006-06-23 13:03:33 +04:00
mm: migrate: make core migration code aware of hugepage
Currently hugepage migration is available only for soft offlining, but
it's also useful for some other users of page migration (clearly because
users of hugepage can enjoy the benefit of mempolicy and memory hotplug.)
So this patchset tries to extend such users to support hugepage migration.
The target of this patchset is to enable hugepage migration for NUMA
related system calls (migrate_pages(2), move_pages(2), and mbind(2)), and
memory hotplug.
This patchset does not add hugepage migration for memory compaction,
because users of memory compaction mainly expect to construct thp by
arranging raw pages, and there's little or no need to compact hugepages.
CMA, another user of page migration, can have benefit from hugepage
migration, but is not enabled to support it for now (just because of lack
of testing and expertise in CMA.)
Hugepage migration of non pmd-based hugepage (for example 1GB hugepage in
x86_64, or hugepages in architectures like ia64) is not enabled for now
(again, because of lack of testing.)
As for how these are achived, I extended the API (migrate_pages()) to
handle hugepage (with patch 1 and 2) and adjusted code of each caller to
check and collect movable hugepages (with patch 3-7). Remaining 2 patches
are kind of miscellaneous ones to avoid unexpected behavior. Patch 8 is
about making sure that we only migrate pmd-based hugepages. And patch 9
is about choosing appropriate zone for hugepage allocation.
My test is mainly functional one, simply kicking hugepage migration via
each entry point and confirm that migration is done correctly. Test code
is available here:
git://github.com/Naoya-Horiguchi/test_hugepage_migration_extension.git
And I always run libhugetlbfs test when changing hugetlbfs's code. With
this patchset, no regression was found in the test.
This patch (of 9):
Before enabling each user of page migration to support hugepage,
this patch enables the list of pages for migration to link not only
LRU pages, but also hugepages. As a result, putback_movable_pages()
and migrate_pages() can handle both of LRU pages and hugepages.
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Reviewed-by: Wanpeng Li <liwanp@linux.vnet.ibm.com>
Acked-by: Hillf Danton <dhillf@gmail.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-09-12 01:21:59 +04:00
if ( PageHuge ( page ) )
rc = unmap_and_move_huge_page ( get_new_page ,
2014-06-05 03:08:25 +04:00
put_new_page , private , page ,
2016-03-16 00:56:18 +03:00
pass > 2 , mode , reason ) ;
mm: migrate: make core migration code aware of hugepage
Currently hugepage migration is available only for soft offlining, but
it's also useful for some other users of page migration (clearly because
users of hugepage can enjoy the benefit of mempolicy and memory hotplug.)
So this patchset tries to extend such users to support hugepage migration.
The target of this patchset is to enable hugepage migration for NUMA
related system calls (migrate_pages(2), move_pages(2), and mbind(2)), and
memory hotplug.
This patchset does not add hugepage migration for memory compaction,
because users of memory compaction mainly expect to construct thp by
arranging raw pages, and there's little or no need to compact hugepages.
CMA, another user of page migration, can have benefit from hugepage
migration, but is not enabled to support it for now (just because of lack
of testing and expertise in CMA.)
Hugepage migration of non pmd-based hugepage (for example 1GB hugepage in
x86_64, or hugepages in architectures like ia64) is not enabled for now
(again, because of lack of testing.)
As for how these are achived, I extended the API (migrate_pages()) to
handle hugepage (with patch 1 and 2) and adjusted code of each caller to
check and collect movable hugepages (with patch 3-7). Remaining 2 patches
are kind of miscellaneous ones to avoid unexpected behavior. Patch 8 is
about making sure that we only migrate pmd-based hugepages. And patch 9
is about choosing appropriate zone for hugepage allocation.
My test is mainly functional one, simply kicking hugepage migration via
each entry point and confirm that migration is done correctly. Test code
is available here:
git://github.com/Naoya-Horiguchi/test_hugepage_migration_extension.git
And I always run libhugetlbfs test when changing hugetlbfs's code. With
this patchset, no regression was found in the test.
This patch (of 9):
Before enabling each user of page migration to support hugepage,
this patch enables the list of pages for migration to link not only
LRU pages, but also hugepages. As a result, putback_movable_pages()
and migrate_pages() can handle both of LRU pages and hugepages.
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Reviewed-by: Wanpeng Li <liwanp@linux.vnet.ibm.com>
Acked-by: Hillf Danton <dhillf@gmail.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Hugh Dickins <hughd@google.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-09-12 01:21:59 +04:00
else
2014-06-05 03:08:25 +04:00
rc = unmap_and_move ( get_new_page , put_new_page ,
mm: soft-offline: don't free target page in successful page migration
Stress testing showed that soft offline events for a process iterating
"mmap-pagefault-munmap" loop can trigger
VM_BUG_ON(PAGE_FLAGS_CHECK_AT_PREP) in __free_one_page():
Soft offlining page 0x70fe1 at 0x70100008d000
Soft offlining page 0x705fb at 0x70300008d000
page:ffffea0001c3f840 count:0 mapcount:0 mapping: (null) index:0x2
flags: 0x1fffff80800000(hwpoison)
page dumped because: VM_BUG_ON_PAGE(page->flags & ((1 << 25) - 1))
------------[ cut here ]------------
kernel BUG at /src/linux-dev/mm/page_alloc.c:585!
invalid opcode: 0000 [#1] SMP DEBUG_PAGEALLOC
Modules linked in: cfg80211 rfkill crc32c_intel microcode ppdev parport_pc pcspkr serio_raw virtio_balloon parport i2c_piix4 virtio_blk virtio_net ata_generic pata_acpi floppy
CPU: 3 PID: 1779 Comm: test_base_madv_ Not tainted 4.0.0-v4.0-150511-1451-00009-g82360a3730e6 #139
RIP: free_pcppages_bulk+0x52a/0x6f0
Call Trace:
drain_pages_zone+0x3d/0x50
drain_local_pages+0x1d/0x30
on_each_cpu_mask+0x46/0x80
drain_all_pages+0x14b/0x1e0
soft_offline_page+0x432/0x6e0
SyS_madvise+0x73c/0x780
system_call_fastpath+0x12/0x17
Code: ff 89 45 b4 48 8b 45 c0 48 83 b8 a8 00 00 00 00 0f 85 e3 fb ff ff 0f 1f 00 0f 0b 48 8b 7d 90 48 c7 c6 e8 95 a6 81 e8 e6 32 02 00 <0f> 0b 8b 45 cc 49 89 47 30 41 8b 47 18 83 f8 ff 0f 85 10 ff ff
RIP [<ffffffff811a806a>] free_pcppages_bulk+0x52a/0x6f0
RSP <ffff88007a117d28>
---[ end trace 53926436e76d1f35 ]---
When soft offline successfully migrates page, the source page is supposed
to be freed. But there is a race condition where a source page looks
isolated (i.e. the refcount is 0 and the PageHWPoison is set) but
somewhat linked to pcplist. Then another soft offline event calls
drain_all_pages() and tries to free such hwpoisoned page, which is
forbidden.
This odd page state seems to happen due to the race between put_page() in
putback_lru_page() and __pagevec_lru_add_fn(). But I don't want to play
with tweaking drain code as done in commit 9ab3b598d2df "mm: hwpoison:
drop lru_add_drain_all() in __soft_offline_page()", or to change page
freeing code for this soft offline's purpose.
Instead, let's think about the difference between hard offline and soft
offline. There is an interesting difference in how to isolate the in-use
page between these, that is, hard offline marks PageHWPoison of the target
page at first, and doesn't free it by keeping its refcount 1. OTOH, soft
offline tries to free the target page then marks PageHWPoison. This
difference might be the source of complexity and result in bugs like the
above. So making soft offline isolate with keeping refcount can be a
solution for this problem.
We can pass to page migration code the "reason" which shows the caller, so
let's use this more to avoid calling putback_lru_page() when called from
soft offline, which effectively does the isolation for soft offline. With
this change, target pages of soft offline never be reused without changing
migratetype, so this patch also removes the related code.
Signed-off-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Tony Luck <tony.luck@intel.com>
Cc: "Kirill A. Shutemov" <kirill@shutemov.name>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-06-25 02:56:50 +03:00
private , page , pass > 2 , mode ,
reason ) ;
2006-06-23 13:03:33 +04:00
2006-06-23 13:03:51 +04:00
switch ( rc ) {
2006-06-23 13:03:53 +04:00
case - ENOMEM :
2016-05-21 02:59:05 +03:00
nr_failed + + ;
2006-06-23 13:03:53 +04:00
goto out ;
2006-06-23 13:03:51 +04:00
case - EAGAIN :
2006-06-23 13:03:33 +04:00
retry + + ;
2006-06-23 13:03:51 +04:00
break ;
2012-12-12 04:02:31 +04:00
case MIGRATEPAGE_SUCCESS :
2012-10-19 13:46:20 +04:00
nr_succeeded + + ;
2006-06-23 13:03:51 +04:00
break ;
default :
2014-01-22 03:51:14 +04:00
/*
* Permanent failure ( - EBUSY , - ENOSYS , etc . ) :
* unlike - EAGAIN case , the failed page is
* removed from migration page list and not
* retried in the next outer loop .
*/
2006-06-23 13:03:33 +04:00
nr_failed + + ;
2006-06-23 13:03:51 +04:00
break ;
2006-06-23 13:03:33 +04:00
}
2006-03-22 11:09:12 +03:00
}
}
2015-11-06 05:47:03 +03:00
nr_failed + = retry ;
rc = nr_failed ;
2006-06-23 13:03:53 +04:00
out :
2012-10-19 13:46:20 +04:00
if ( nr_succeeded )
count_vm_events ( PGMIGRATE_SUCCESS , nr_succeeded ) ;
if ( nr_failed )
count_vm_events ( PGMIGRATE_FAIL , nr_failed ) ;
2012-10-19 17:07:31 +04:00
trace_mm_migrate_pages ( nr_succeeded , nr_failed , mode , reason ) ;
2006-03-22 11:09:12 +03:00
if ( ! swapwrite )
current - > flags & = ~ PF_SWAPWRITE ;
2012-12-12 04:02:31 +04:00
return rc ;
2006-03-22 11:09:12 +03:00
}
2006-06-23 13:03:53 +04:00
2006-06-23 13:03:55 +04:00
# ifdef CONFIG_NUMA
2018-04-11 02:29:59 +03:00
static int store_status ( int __user * status , int start , int value , int nr )
2006-06-23 13:03:55 +04:00
{
2018-04-11 02:29:59 +03:00
while ( nr - - > 0 ) {
if ( put_user ( value , status + start ) )
return - EFAULT ;
start + + ;
}
return 0 ;
}
static int do_move_pages_to_node ( struct mm_struct * mm ,
struct list_head * pagelist , int node )
{
int err ;
if ( list_empty ( pagelist ) )
return 0 ;
err = migrate_pages ( pagelist , alloc_new_node_page , NULL , node ,
MIGRATE_SYNC , MR_SYSCALL ) ;
if ( err )
putback_movable_pages ( pagelist ) ;
return err ;
2006-06-23 13:03:55 +04:00
}
/*
2018-04-11 02:29:59 +03:00
* Resolves the given address to a struct page , isolates it from the LRU and
* puts it to the given pagelist .
* Returns - errno if the page cannot be found / isolated or 0 when it has been
* queued or the page doesn ' t need to be migrated because it is already on
* the target node
2006-06-23 13:03:55 +04:00
*/
2018-04-11 02:29:59 +03:00
static int add_page_for_migration ( struct mm_struct * mm , unsigned long addr ,
int node , struct list_head * pagelist , bool migrate_all )
2006-06-23 13:03:55 +04:00
{
2018-04-11 02:29:59 +03:00
struct vm_area_struct * vma ;
struct page * page ;
unsigned int follflags ;
2006-06-23 13:03:55 +04:00
int err ;
down_read ( & mm - > mmap_sem ) ;
2018-04-11 02:29:59 +03:00
err = - EFAULT ;
vma = find_vma ( mm , addr ) ;
if ( ! vma | | addr < vma - > vm_start | | ! vma_migratable ( vma ) )
goto out ;
2006-06-23 13:03:55 +04:00
2018-04-11 02:29:59 +03:00
/* FOLL_DUMP to ignore special (like zero) pages */
follflags = FOLL_GET | FOLL_DUMP ;
if ( ! thp_migration_supported ( ) )
follflags | = FOLL_SPLIT ;
page = follow_page ( vma , addr , follflags ) ;
2008-06-20 22:18:25 +04:00
2018-04-11 02:29:59 +03:00
err = PTR_ERR ( page ) ;
if ( IS_ERR ( page ) )
goto out ;
2008-06-20 22:18:25 +04:00
2018-04-11 02:29:59 +03:00
err = - ENOENT ;
if ( ! page )
goto out ;
2006-06-23 13:03:55 +04:00
2018-04-11 02:29:59 +03:00
err = 0 ;
if ( page_to_nid ( page ) = = node )
goto out_putpage ;
2006-06-23 13:03:55 +04:00
2018-04-11 02:29:59 +03:00
err = - EACCES ;
if ( page_mapcount ( page ) > 1 & & ! migrate_all )
goto out_putpage ;
2006-06-23 13:03:55 +04:00
2018-04-11 02:29:59 +03:00
if ( PageHuge ( page ) ) {
if ( PageHead ( page ) ) {
isolate_huge_page ( page , pagelist ) ;
err = 0 ;
2013-09-12 01:22:04 +04:00
}
2018-04-11 02:29:59 +03:00
} else {
struct page * head ;
2013-09-12 01:22:04 +04:00
2017-09-09 02:11:12 +03:00
head = compound_head ( page ) ;
err = isolate_lru_page ( head ) ;
2010-10-27 01:21:29 +04:00
if ( err )
2018-04-11 02:29:59 +03:00
goto out_putpage ;
2006-06-23 13:03:55 +04:00
2018-04-11 02:29:59 +03:00
err = 0 ;
list_add_tail ( & head - > lru , pagelist ) ;
mod_node_page_state ( page_pgdat ( head ) ,
NR_ISOLATED_ANON + page_is_file_cache ( head ) ,
hpage_nr_pages ( head ) ) ;
}
out_putpage :
/*
* Either remove the duplicate refcount from
* isolate_lru_page ( ) or drop the page ref if it was
* not isolated .
*/
put_page ( page ) ;
out :
2006-06-23 13:03:55 +04:00
up_read ( & mm - > mmap_sem ) ;
return err ;
}
2008-10-19 07:27:17 +04:00
/*
* Migrate an array of page address onto an array of nodes and fill
* the corresponding array of status .
*/
2012-03-22 03:34:06 +04:00
static int do_pages_move ( struct mm_struct * mm , nodemask_t task_nodes ,
2008-10-19 07:27:17 +04:00
unsigned long nr_pages ,
const void __user * __user * pages ,
const int __user * nodes ,
int __user * status , int flags )
{
2018-04-11 02:29:59 +03:00
int current_node = NUMA_NO_NODE ;
LIST_HEAD ( pagelist ) ;
int start , i ;
int err = 0 , err1 ;
2009-06-17 02:32:43 +04:00
migrate_prep ( ) ;
2018-04-11 02:29:59 +03:00
for ( i = start = 0 ; i < nr_pages ; i + + ) {
const void __user * p ;
unsigned long addr ;
int node ;
2009-01-07 01:38:57 +03:00
2018-04-11 02:29:59 +03:00
err = - EFAULT ;
if ( get_user ( p , pages + i ) )
goto out_flush ;
if ( get_user ( node , nodes + i ) )
goto out_flush ;
addr = ( unsigned long ) p ;
err = - ENODEV ;
if ( node < 0 | | node > = MAX_NUMNODES )
goto out_flush ;
if ( ! node_state ( node , N_MEMORY ) )
goto out_flush ;
2008-10-19 07:27:17 +04:00
2018-04-11 02:29:59 +03:00
err = - EACCES ;
if ( ! node_isset ( node , task_nodes ) )
goto out_flush ;
if ( current_node = = NUMA_NO_NODE ) {
current_node = node ;
start = i ;
} else if ( node ! = current_node ) {
err = do_move_pages_to_node ( mm , & pagelist , current_node ) ;
if ( err )
goto out ;
err = store_status ( status , start , current_node , i - start ) ;
if ( err )
goto out ;
start = i ;
current_node = node ;
2009-01-07 01:38:57 +03:00
}
2018-04-11 02:29:59 +03:00
/*
* Errors in the page lookup or isolation are not fatal and we simply
* report them via status
*/
err = add_page_for_migration ( mm , addr , current_node ,
& pagelist , flags & MPOL_MF_MOVE_ALL ) ;
if ( ! err )
continue ;
2009-01-07 01:38:57 +03:00
2018-04-11 02:29:59 +03:00
err = store_status ( status , i , err , 1 ) ;
if ( err )
goto out_flush ;
2008-10-19 07:27:17 +04:00
2018-04-11 02:29:59 +03:00
err = do_move_pages_to_node ( mm , & pagelist , current_node ) ;
if ( err )
goto out ;
if ( i > start ) {
err = store_status ( status , start , current_node , i - start ) ;
if ( err )
goto out ;
}
current_node = NUMA_NO_NODE ;
2009-01-07 01:38:57 +03:00
}
2018-04-11 02:29:59 +03:00
out_flush :
/* Make sure we do not overwrite the existing error */
err1 = do_move_pages_to_node ( mm , & pagelist , current_node ) ;
if ( ! err1 )
err1 = store_status ( status , start , current_node , i - start ) ;
if ( ! err )
err = err1 ;
2008-10-19 07:27:17 +04:00
out :
return err ;
}
2006-06-23 13:03:55 +04:00
/*
2008-10-19 07:27:16 +04:00
* Determine the nodes of an array of pages and store it in an array of status .
2006-06-23 13:03:55 +04:00
*/
2008-12-10 00:14:23 +03:00
static void do_pages_stat_array ( struct mm_struct * mm , unsigned long nr_pages ,
const void __user * * pages , int * status )
2006-06-23 13:03:55 +04:00
{
2008-10-19 07:27:16 +04:00
unsigned long i ;
2006-06-23 13:03:55 +04:00
down_read ( & mm - > mmap_sem ) ;
2008-10-19 07:27:16 +04:00
for ( i = 0 ; i < nr_pages ; i + + ) {
2008-12-10 00:14:23 +03:00
unsigned long addr = ( unsigned long ) ( * pages ) ;
2006-06-23 13:03:55 +04:00
struct vm_area_struct * vma ;
struct page * page ;
2008-12-16 10:06:43 +03:00
int err = - EFAULT ;
2008-10-19 07:27:16 +04:00
vma = find_vma ( mm , addr ) ;
2010-10-27 01:22:07 +04:00
if ( ! vma | | addr < vma - > vm_start )
2006-06-23 13:03:55 +04:00
goto set_status ;
2015-09-05 01:47:53 +03:00
/* FOLL_DUMP to ignore special (like zero) pages */
page = follow_page ( vma , addr , FOLL_DUMP ) ;
2008-06-20 22:18:25 +04:00
err = PTR_ERR ( page ) ;
if ( IS_ERR ( page ) )
goto set_status ;
2015-09-05 01:47:53 +03:00
err = page ? page_to_nid ( page ) : - ENOENT ;
2006-06-23 13:03:55 +04:00
set_status :
2008-12-10 00:14:23 +03:00
* status = err ;
pages + + ;
status + + ;
}
up_read ( & mm - > mmap_sem ) ;
}
/*
* Determine the nodes of a user array of pages and store it in
* a user array of status .
*/
static int do_pages_stat ( struct mm_struct * mm , unsigned long nr_pages ,
const void __user * __user * pages ,
int __user * status )
{
# define DO_PAGES_STAT_CHUNK_NR 16
const void __user * chunk_pages [ DO_PAGES_STAT_CHUNK_NR ] ;
int chunk_status [ DO_PAGES_STAT_CHUNK_NR ] ;
2010-02-19 03:13:40 +03:00
while ( nr_pages ) {
unsigned long chunk_nr ;
2008-12-10 00:14:23 +03:00
2010-02-19 03:13:40 +03:00
chunk_nr = nr_pages ;
if ( chunk_nr > DO_PAGES_STAT_CHUNK_NR )
chunk_nr = DO_PAGES_STAT_CHUNK_NR ;
if ( copy_from_user ( chunk_pages , pages , chunk_nr * sizeof ( * chunk_pages ) ) )
break ;
2008-12-10 00:14:23 +03:00
do_pages_stat_array ( mm , chunk_nr , chunk_pages , chunk_status ) ;
2010-02-19 03:13:40 +03:00
if ( copy_to_user ( status , chunk_status , chunk_nr * sizeof ( * status ) ) )
break ;
2006-06-23 13:03:55 +04:00
2010-02-19 03:13:40 +03:00
pages + = chunk_nr ;
status + = chunk_nr ;
nr_pages - = chunk_nr ;
}
return nr_pages ? - EFAULT : 0 ;
2006-06-23 13:03:55 +04:00
}
/*
* Move a list of pages in the address space of the currently executing
* process .
*/
2018-03-17 18:08:03 +03:00
static int kernel_move_pages ( pid_t pid , unsigned long nr_pages ,
const void __user * __user * pages ,
const int __user * nodes ,
int __user * status , int flags )
2006-06-23 13:03:55 +04:00
{
struct task_struct * task ;
struct mm_struct * mm ;
2008-10-19 07:27:17 +04:00
int err ;
2012-03-22 03:34:06 +04:00
nodemask_t task_nodes ;
2006-06-23 13:03:55 +04:00
/* Check flags */
if ( flags & ~ ( MPOL_MF_MOVE | MPOL_MF_MOVE_ALL ) )
return - EINVAL ;
if ( ( flags & MPOL_MF_MOVE_ALL ) & & ! capable ( CAP_SYS_NICE ) )
return - EPERM ;
/* Find the mm_struct */
2011-02-26 01:44:13 +03:00
rcu_read_lock ( ) ;
2007-10-19 10:40:16 +04:00
task = pid ? find_task_by_vpid ( pid ) : current ;
2006-06-23 13:03:55 +04:00
if ( ! task ) {
2011-02-26 01:44:13 +03:00
rcu_read_unlock ( ) ;
2006-06-23 13:03:55 +04:00
return - ESRCH ;
}
2012-03-22 03:34:06 +04:00
get_task_struct ( task ) ;
2006-06-23 13:03:55 +04:00
/*
* Check if this process has the right to modify the specified
2017-08-20 23:26:27 +03:00
* process . Use the regular " ptrace_may_access() " checks .
2006-06-23 13:03:55 +04:00
*/
2017-08-20 23:26:27 +03:00
if ( ! ptrace_may_access ( task , PTRACE_MODE_READ_REALCREDS ) ) {
2008-11-14 02:39:19 +03:00
rcu_read_unlock ( ) ;
2006-06-23 13:03:55 +04:00
err = - EPERM ;
2008-10-19 07:27:17 +04:00
goto out ;
2006-06-23 13:03:55 +04:00
}
2008-11-14 02:39:19 +03:00
rcu_read_unlock ( ) ;
2006-06-23 13:03:55 +04:00
2006-06-23 13:04:02 +04:00
err = security_task_movememory ( task ) ;
if ( err )
2008-10-19 07:27:17 +04:00
goto out ;
2006-06-23 13:04:02 +04:00
2012-03-22 03:34:06 +04:00
task_nodes = cpuset_mems_allowed ( task ) ;
mm = get_task_mm ( task ) ;
put_task_struct ( task ) ;
2012-04-26 03:01:53 +04:00
if ( ! mm )
return - EINVAL ;
if ( nodes )
err = do_pages_move ( mm , task_nodes , nr_pages , pages ,
nodes , status , flags ) ;
else
err = do_pages_stat ( mm , nr_pages , pages , status ) ;
2006-06-23 13:03:55 +04:00
mmput ( mm ) ;
return err ;
2012-03-22 03:34:06 +04:00
out :
put_task_struct ( task ) ;
return err ;
2006-06-23 13:03:55 +04:00
}
2018-03-17 18:08:03 +03:00
SYSCALL_DEFINE6 ( move_pages , pid_t , pid , unsigned long , nr_pages ,
const void __user * __user * , pages ,
const int __user * , nodes ,
int __user * , status , int , flags )
{
return kernel_move_pages ( pid , nr_pages , pages , nodes , status , flags ) ;
}
# ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE6 ( move_pages , pid_t , pid , compat_ulong_t , nr_pages ,
compat_uptr_t __user * , pages32 ,
const int __user * , nodes ,
int __user * , status ,
int , flags )
{
const void __user * __user * pages ;
int i ;
pages = compat_alloc_user_space ( nr_pages * sizeof ( void * ) ) ;
for ( i = 0 ; i < nr_pages ; i + + ) {
compat_uptr_t p ;
if ( get_user ( p , pages32 + i ) | |
put_user ( compat_ptr ( p ) , pages + i ) )
return - EFAULT ;
}
return kernel_move_pages ( pid , nr_pages , pages , nodes , status , flags ) ;
}
# endif /* CONFIG_COMPAT */
2012-10-25 16:16:34 +04:00
# ifdef CONFIG_NUMA_BALANCING
/*
* Returns true if this is a safe migration target node for misplaced NUMA
* pages . Currently it only checks the watermarks which crude
*/
static bool migrate_balanced_pgdat ( struct pglist_data * pgdat ,
2013-02-23 04:34:27 +04:00
unsigned long nr_migrate_pages )
2012-10-25 16:16:34 +04:00
{
int z ;
2016-07-29 01:45:31 +03:00
2012-10-25 16:16:34 +04:00
for ( z = pgdat - > nr_zones - 1 ; z > = 0 ; z - - ) {
struct zone * zone = pgdat - > node_zones + z ;
if ( ! populated_zone ( zone ) )
continue ;
/* Avoid waking kswapd by allocating pages_to_migrate pages. */
if ( ! zone_watermark_ok ( zone , 0 ,
high_wmark_pages ( zone ) +
nr_migrate_pages ,
0 , 0 ) )
continue ;
return true ;
}
return false ;
}
static struct page * alloc_misplaced_dst_page ( struct page * page ,
2018-04-11 02:30:03 +03:00
unsigned long data )
2012-10-25 16:16:34 +04:00
{
int nid = ( int ) data ;
struct page * newpage ;
mm: rename alloc_pages_exact_node() to __alloc_pages_node()
alloc_pages_exact_node() was introduced in commit 6484eb3e2a81 ("page
allocator: do not check NUMA node ID when the caller knows the node is
valid") as an optimized variant of alloc_pages_node(), that doesn't
fallback to current node for nid == NUMA_NO_NODE. Unfortunately the
name of the function can easily suggest that the allocation is
restricted to the given node and fails otherwise. In truth, the node is
only preferred, unless __GFP_THISNODE is passed among the gfp flags.
The misleading name has lead to mistakes in the past, see for example
commits 5265047ac301 ("mm, thp: really limit transparent hugepage
allocation to local node") and b360edb43f8e ("mm, mempolicy:
migrate_to_node should only migrate to node").
Another issue with the name is that there's a family of
alloc_pages_exact*() functions where 'exact' means exact size (instead
of page order), which leads to more confusion.
To prevent further mistakes, this patch effectively renames
alloc_pages_exact_node() to __alloc_pages_node() to better convey that
it's an optimized variant of alloc_pages_node() not intended for general
usage. Both functions get described in comments.
It has been also considered to really provide a convenience function for
allocations restricted to a node, but the major opinion seems to be that
__GFP_THISNODE already provides that functionality and we shouldn't
duplicate the API needlessly. The number of users would be small
anyway.
Existing callers of alloc_pages_exact_node() are simply converted to
call __alloc_pages_node(), with the exception of sba_alloc_coherent()
which open-codes the check for NUMA_NO_NODE, so it is converted to use
alloc_pages_node() instead. This means it no longer performs some
VM_BUG_ON checks, and since the current check for nid in
alloc_pages_node() uses a 'nid < 0' comparison (which includes
NUMA_NO_NODE), it may hide wrong values which would be previously
exposed.
Both differences will be rectified by the next patch.
To sum up, this patch makes no functional changes, except temporarily
hiding potentially buggy callers. Restricting the checks in
alloc_pages_node() is left for the next patch which can in turn expose
more existing buggy callers.
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Robin Holt <robinmholt@gmail.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Acked-by: Christoph Lameter <cl@linux.com>
Acked-by: Michael Ellerman <mpe@ellerman.id.au>
Cc: Mel Gorman <mgorman@suse.de>
Cc: David Rientjes <rientjes@google.com>
Cc: Greg Thelen <gthelen@google.com>
Cc: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Gleb Natapov <gleb@kernel.org>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Cliff Whickman <cpw@sgi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-09-09 01:03:50 +03:00
newpage = __alloc_pages_node ( nid ,
2014-03-11 02:49:43 +04:00
( GFP_HIGHUSER_MOVABLE |
__GFP_THISNODE | __GFP_NOMEMALLOC |
__GFP_NORETRY | __GFP_NOWARN ) &
2016-02-27 02:19:31 +03:00
~ __GFP_RECLAIM , 0 ) ;
2012-11-27 18:46:24 +04:00
2012-10-25 16:16:34 +04:00
return newpage ;
}
2012-11-15 01:41:46 +04:00
/*
* page migration rate limiting control .
* Do not migrate more than @ pages_to_migrate in a @ migrate_interval_millisecs
* window of time . Default here says do not migrate more than 1280 M per second .
*/
static unsigned int migrate_interval_millisecs __read_mostly = 100 ;
static unsigned int ratelimit_pages __read_mostly = 128 < < ( 20 - PAGE_SHIFT ) ;
2012-11-19 16:35:47 +04:00
/* Returns true if the node is migrate rate-limited after the update */
2014-01-22 03:50:58 +04:00
static bool numamigrate_update_ratelimit ( pg_data_t * pgdat ,
unsigned long nr_pages )
2012-10-25 16:16:34 +04:00
{
2012-11-15 01:41:46 +04:00
/*
* Rate - limit the amount of data that is being migrated to a node .
* Optimal placement is no good if the memory bus is saturated and
* all the time is being spent migrating !
*/
if ( time_after ( jiffies , pgdat - > numabalancing_migrate_next_window ) ) {
2014-01-22 03:50:59 +04:00
spin_lock ( & pgdat - > numabalancing_migrate_lock ) ;
2012-11-15 01:41:46 +04:00
pgdat - > numabalancing_migrate_nr_pages = 0 ;
pgdat - > numabalancing_migrate_next_window = jiffies +
msecs_to_jiffies ( migrate_interval_millisecs ) ;
2014-01-22 03:50:59 +04:00
spin_unlock ( & pgdat - > numabalancing_migrate_lock ) ;
2012-11-15 01:41:46 +04:00
}
2014-01-22 03:51:01 +04:00
if ( pgdat - > numabalancing_migrate_nr_pages > ratelimit_pages ) {
trace_mm_numa_migrate_ratelimit ( current , pgdat - > node_id ,
nr_pages ) ;
2014-01-22 03:50:59 +04:00
return true ;
2014-01-22 03:51:01 +04:00
}
2014-01-22 03:50:59 +04:00
/*
* This is an unlocked non - atomic update so errors are possible .
* The consequences are failing to migrate when we potentiall should
* have which is not severe enough to warrant locking . If it is ever
* a problem , it can be converted to a per - cpu counter .
*/
pgdat - > numabalancing_migrate_nr_pages + = nr_pages ;
return false ;
2012-11-19 16:35:47 +04:00
}
2014-01-22 03:50:58 +04:00
static int numamigrate_isolate_page ( pg_data_t * pgdat , struct page * page )
2012-11-19 16:35:47 +04:00
{
2013-02-23 04:34:33 +04:00
int page_lru ;
2012-11-15 01:41:46 +04:00
2014-01-24 03:52:54 +04:00
VM_BUG_ON_PAGE ( compound_order ( page ) & & ! PageTransHuge ( page ) , page ) ;
2013-02-23 04:34:27 +04:00
2012-10-25 16:16:34 +04:00
/* Avoid migrating to a node that is nearly full */
2013-02-23 04:34:33 +04:00
if ( ! migrate_balanced_pgdat ( pgdat , 1UL < < compound_order ( page ) ) )
return 0 ;
2012-10-25 16:16:34 +04:00
2013-02-23 04:34:33 +04:00
if ( isolate_lru_page ( page ) )
return 0 ;
2012-10-25 16:16:34 +04:00
2013-02-23 04:34:33 +04:00
/*
* migrate_misplaced_transhuge_page ( ) skips page migration ' s usual
* check on page_count ( ) , so we must do it here , now that the page
* has been isolated : a GUP pin , or any other pin , prevents migration .
* The expected page count is 3 : 1 for page ' s mapcount and 1 for the
* caller ' s pin and 1 for the reference taken by isolate_lru_page ( ) .
*/
if ( PageTransHuge ( page ) & & page_count ( page ) ! = 3 ) {
putback_lru_page ( page ) ;
return 0 ;
2012-10-25 16:16:34 +04:00
}
2013-02-23 04:34:33 +04:00
page_lru = page_is_file_cache ( page ) ;
2016-07-29 01:45:31 +03:00
mod_node_page_state ( page_pgdat ( page ) , NR_ISOLATED_ANON + page_lru ,
2013-02-23 04:34:33 +04:00
hpage_nr_pages ( page ) ) ;
2012-11-27 18:03:05 +04:00
/*
2013-02-23 04:34:33 +04:00
* Isolating the page has taken another reference , so the
* caller ' s reference can be safely dropped without the page
* disappearing underneath us during migration .
2012-11-27 18:03:05 +04:00
*/
put_page ( page ) ;
2013-02-23 04:34:33 +04:00
return 1 ;
2012-11-19 16:35:47 +04:00
}
2013-12-19 05:08:42 +04:00
bool pmd_trans_migrating ( pmd_t pmd )
{
struct page * page = pmd_page ( pmd ) ;
return PageLocked ( page ) ;
}
2012-11-19 16:35:47 +04:00
/*
* Attempt to migrate a misplaced page to the specified destination
* node . Caller is expected to have an elevated reference count on
* the page that will be dropped by this function before returning .
*/
2013-10-07 14:29:05 +04:00
int migrate_misplaced_page ( struct page * page , struct vm_area_struct * vma ,
int node )
2012-11-19 16:35:47 +04:00
{
pg_data_t * pgdat = NODE_DATA ( node ) ;
2013-02-23 04:34:33 +04:00
int isolated ;
2012-11-19 16:35:47 +04:00
int nr_remaining ;
LIST_HEAD ( migratepages ) ;
/*
2013-10-07 14:29:05 +04:00
* Don ' t migrate file pages that are mapped in multiple processes
* with execute permissions as they are probably shared libraries .
2012-11-19 16:35:47 +04:00
*/
2013-10-07 14:29:05 +04:00
if ( page_mapcount ( page ) ! = 1 & & page_is_file_cache ( page ) & &
( vma - > vm_flags & VM_EXEC ) )
2012-11-19 16:35:47 +04:00
goto out ;
2018-04-11 02:29:20 +03:00
/*
* Also do not migrate dirty pages as not all filesystems can move
* dirty pages in MIGRATE_ASYNC mode which is a waste of cycles .
*/
if ( page_is_file_cache ( page ) & & PageDirty ( page ) )
goto out ;
2012-11-19 16:35:47 +04:00
/*
* Rate - limit the amount of data that is being migrated to a node .
* Optimal placement is no good if the memory bus is saturated and
* all the time is being spent migrating !
*/
2013-02-23 04:34:33 +04:00
if ( numamigrate_update_ratelimit ( pgdat , 1 ) )
2012-11-19 16:35:47 +04:00
goto out ;
isolated = numamigrate_isolate_page ( pgdat , page ) ;
if ( ! isolated )
goto out ;
list_add ( & page - > lru , & migratepages ) ;
2013-02-23 04:35:14 +04:00
nr_remaining = migrate_pages ( & migratepages , alloc_misplaced_dst_page ,
2014-06-05 03:08:25 +04:00
NULL , node , MIGRATE_ASYNC ,
MR_NUMA_MISPLACED ) ;
2012-11-19 16:35:47 +04:00
if ( nr_remaining ) {
2014-01-22 03:51:17 +04:00
if ( ! list_empty ( & migratepages ) ) {
list_del ( & page - > lru ) ;
2016-07-29 01:45:31 +03:00
dec_node_page_state ( page , NR_ISOLATED_ANON +
2014-01-22 03:51:17 +04:00
page_is_file_cache ( page ) ) ;
putback_lru_page ( page ) ;
}
2012-11-19 16:35:47 +04:00
isolated = 0 ;
} else
count_vm_numa_event ( NUMA_PAGE_MIGRATE ) ;
2012-10-25 16:16:34 +04:00
BUG_ON ( ! list_empty ( & migratepages ) ) ;
return isolated ;
2013-02-23 04:34:33 +04:00
out :
put_page ( page ) ;
return 0 ;
2012-10-25 16:16:34 +04:00
}
2012-12-05 13:32:56 +04:00
# endif /* CONFIG_NUMA_BALANCING */
2012-11-19 16:35:47 +04:00
2012-12-05 13:32:56 +04:00
# if defined(CONFIG_NUMA_BALANCING) && defined(CONFIG_TRANSPARENT_HUGEPAGE)
2013-02-23 04:34:33 +04:00
/*
* Migrates a THP to a given target node . page must be locked and is unlocked
* before returning .
*/
2012-11-19 16:35:47 +04:00
int migrate_misplaced_transhuge_page ( struct mm_struct * mm ,
struct vm_area_struct * vma ,
pmd_t * pmd , pmd_t entry ,
unsigned long address ,
struct page * page , int node )
{
2013-11-15 02:31:04 +04:00
spinlock_t * ptl ;
2012-11-19 16:35:47 +04:00
pg_data_t * pgdat = NODE_DATA ( node ) ;
int isolated = 0 ;
struct page * new_page = NULL ;
int page_lru = page_is_file_cache ( page ) ;
2013-12-19 05:08:33 +04:00
unsigned long mmun_start = address & HPAGE_PMD_MASK ;
unsigned long mmun_end = mmun_start + HPAGE_PMD_SIZE ;
2012-11-19 16:35:47 +04:00
/*
* Rate - limit the amount of data that is being migrated to a node .
* Optimal placement is no good if the memory bus is saturated and
* all the time is being spent migrating !
*/
2012-11-29 13:24:36 +04:00
if ( numamigrate_update_ratelimit ( pgdat , HPAGE_PMD_NR ) )
2012-11-19 16:35:47 +04:00
goto out_dropref ;
new_page = alloc_pages_node ( node ,
mm, thp: remove __GFP_NORETRY from khugepaged and madvised allocations
After the previous patch, we can distinguish costly allocations that
should be really lightweight, such as THP page faults, with
__GFP_NORETRY. This means we don't need to recognize khugepaged
allocations via PF_KTHREAD anymore. We can also change THP page faults
in areas where madvise(MADV_HUGEPAGE) was used to try as hard as
khugepaged, as the process has indicated that it benefits from THP's and
is willing to pay some initial latency costs.
We can also make the flags handling less cryptic by distinguishing
GFP_TRANSHUGE_LIGHT (no reclaim at all, default mode in page fault) from
GFP_TRANSHUGE (only direct reclaim, khugepaged default). Adding
__GFP_NORETRY or __GFP_KSWAPD_RECLAIM is done where needed.
The patch effectively changes the current GFP_TRANSHUGE users as
follows:
* get_huge_zero_page() - the zero page lifetime should be relatively
long and it's shared by multiple users, so it's worth spending some
effort on it. We use GFP_TRANSHUGE, and __GFP_NORETRY is not added.
This also restores direct reclaim to this allocation, which was
unintentionally removed by commit e4a49efe4e7e ("mm: thp: set THP defrag
by default to madvise and add a stall-free defrag option")
* alloc_hugepage_khugepaged_gfpmask() - this is khugepaged, so latency
is not an issue. So if khugepaged "defrag" is enabled (the default), do
reclaim via GFP_TRANSHUGE without __GFP_NORETRY. We can remove the
PF_KTHREAD check from page alloc.
As a side-effect, khugepaged will now no longer check if the initial
compaction was deferred or contended. This is OK, as khugepaged sleep
times between collapsion attempts are long enough to prevent noticeable
disruption, so we should allow it to spend some effort.
* migrate_misplaced_transhuge_page() - already was masking out
__GFP_RECLAIM, so just convert to GFP_TRANSHUGE_LIGHT which is
equivalent.
* alloc_hugepage_direct_gfpmask() - vma's with VM_HUGEPAGE (via madvise)
are now allocating without __GFP_NORETRY. Other vma's keep using
__GFP_NORETRY if direct reclaim/compaction is at all allowed (by default
it's allowed only for madvised vma's). The rest is conversion to
GFP_TRANSHUGE(_LIGHT).
[mhocko@suse.com: suggested GFP_TRANSHUGE_LIGHT]
Link: http://lkml.kernel.org/r/20160721073614.24395-7-vbabka@suse.cz
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: Michal Hocko <mhocko@suse.com>
Acked-by: Mel Gorman <mgorman@techsingularity.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-07-29 01:49:25 +03:00
( GFP_TRANSHUGE_LIGHT | __GFP_THISNODE ) ,
2014-03-11 02:49:43 +04:00
HPAGE_PMD_ORDER ) ;
2013-02-23 04:34:33 +04:00
if ( ! new_page )
goto out_fail ;
2016-01-16 03:54:17 +03:00
prep_transhuge_page ( new_page ) ;
2013-02-23 04:34:33 +04:00
2012-11-19 16:35:47 +04:00
isolated = numamigrate_isolate_page ( pgdat , page ) ;
2013-02-23 04:34:33 +04:00
if ( ! isolated ) {
2012-11-19 16:35:47 +04:00
put_page ( new_page ) ;
2013-02-23 04:34:33 +04:00
goto out_fail ;
2012-11-19 16:35:47 +04:00
}
2013-12-19 05:08:46 +04:00
2012-11-19 16:35:47 +04:00
/* Prepare a page as a migration target */
2016-01-16 03:51:24 +03:00
__SetPageLocked ( new_page ) ;
2017-05-04 00:52:26 +03:00
if ( PageSwapBacked ( page ) )
__SetPageSwapBacked ( new_page ) ;
2012-11-19 16:35:47 +04:00
/* anon mapping, we can simply copy page->mapping to the new page: */
new_page - > mapping = page - > mapping ;
new_page - > index = page - > index ;
migrate_page_copy ( new_page , page ) ;
WARN_ON ( PageLRU ( new_page ) ) ;
/* Recheck the target PMD */
2013-12-19 05:08:33 +04:00
mmu_notifier_invalidate_range_start ( mm , mmun_start , mmun_end ) ;
2013-11-15 02:31:04 +04:00
ptl = pmd_lock ( mm , pmd ) ;
2017-07-11 01:48:31 +03:00
if ( unlikely ( ! pmd_same ( * pmd , entry ) | | ! page_ref_freeze ( page , 2 ) ) ) {
2013-11-15 02:31:04 +04:00
spin_unlock ( ptl ) ;
2013-12-19 05:08:33 +04:00
mmu_notifier_invalidate_range_end ( mm , mmun_start , mmun_end ) ;
2012-11-19 16:35:47 +04:00
/* Reverse changes made by migrate_page_copy() */
if ( TestClearPageActive ( new_page ) )
SetPageActive ( page ) ;
if ( TestClearPageUnevictable ( new_page ) )
SetPageUnevictable ( page ) ;
unlock_page ( new_page ) ;
put_page ( new_page ) ; /* Free it */
2013-10-07 14:28:46 +04:00
/* Retake the callers reference and putback on LRU */
get_page ( page ) ;
2012-11-19 16:35:47 +04:00
putback_lru_page ( page ) ;
2016-07-29 01:45:31 +03:00
mod_node_page_state ( page_pgdat ( page ) ,
2013-10-07 14:28:46 +04:00
NR_ISOLATED_ANON + page_lru , - HPAGE_PMD_NR ) ;
2013-12-19 05:08:39 +04:00
goto out_unlock ;
2012-11-19 16:35:47 +04:00
}
2016-07-27 01:25:29 +03:00
entry = mk_huge_pmd ( new_page , vma - > vm_page_prot ) ;
2017-11-29 20:01:01 +03:00
entry = maybe_pmd_mkwrite ( pmd_mkdirty ( entry ) , vma ) ;
2012-11-19 16:35:47 +04:00
2013-12-19 05:08:32 +04:00
/*
* Clear the old entry under pagetable lock and establish the new PTE .
* Any parallel GUP will either observe the old page blocking on the
* page lock , block on the page table lock or observe the new page .
* The SetPageUptodate on the new page and page_add_new_anon_rmap
* guarantee the copy is visible before the pagetable update .
*/
2013-12-19 05:08:33 +04:00
flush_cache_range ( vma , mmun_start , mmun_end ) ;
2016-01-16 03:52:16 +03:00
page_add_anon_rmap ( new_page , vma , mmun_start , true ) ;
2015-06-25 02:57:44 +03:00
pmdp_huge_clear_flush_notify ( vma , mmun_start , pmd ) ;
2013-12-19 05:08:33 +04:00
set_pmd_at ( mm , mmun_start , pmd , entry ) ;
2012-12-10 12:50:57 +04:00
update_mmu_cache_pmd ( vma , address , & entry ) ;
2013-12-19 05:08:32 +04:00
2017-07-11 01:48:31 +03:00
page_ref_unfreeze ( page , 2 ) ;
2015-11-06 05:49:37 +03:00
mlock_migrate_page ( new_page , page ) ;
2016-01-16 03:52:16 +03:00
page_remove_rmap ( page , true ) ;
2016-03-16 00:56:18 +03:00
set_page_owner_migrate_reason ( new_page , MR_NUMA_MISPLACED ) ;
2013-12-19 05:08:32 +04:00
2013-11-15 02:31:04 +04:00
spin_unlock ( ptl ) ;
2017-11-16 04:34:11 +03:00
/*
* No need to double call mmu_notifier - > invalidate_range ( ) callback as
* the above pmdp_huge_clear_flush_notify ( ) did already call it .
*/
mmu_notifier_invalidate_range_only_end ( mm , mmun_start , mmun_end ) ;
2012-11-19 16:35:47 +04:00
2014-06-05 03:07:41 +04:00
/* Take an "isolate" reference and put new page on the LRU. */
get_page ( new_page ) ;
putback_lru_page ( new_page ) ;
2012-11-19 16:35:47 +04:00
unlock_page ( new_page ) ;
unlock_page ( page ) ;
put_page ( page ) ; /* Drop the rmap reference */
put_page ( page ) ; /* Drop the LRU isolation reference */
count_vm_events ( PGMIGRATE_SUCCESS , HPAGE_PMD_NR ) ;
count_vm_numa_events ( NUMA_PAGE_MIGRATE , HPAGE_PMD_NR ) ;
2016-07-29 01:45:31 +03:00
mod_node_page_state ( page_pgdat ( page ) ,
2012-11-19 16:35:47 +04:00
NR_ISOLATED_ANON + page_lru ,
- HPAGE_PMD_NR ) ;
return isolated ;
2013-02-23 04:34:33 +04:00
out_fail :
count_vm_events ( PGMIGRATE_FAIL , HPAGE_PMD_NR ) ;
2012-11-19 16:35:47 +04:00
out_dropref :
2013-12-19 05:08:32 +04:00
ptl = pmd_lock ( mm , pmd ) ;
if ( pmd_same ( * pmd , entry ) ) {
2015-02-13 01:58:28 +03:00
entry = pmd_modify ( entry , vma - > vm_page_prot ) ;
2013-12-19 05:08:33 +04:00
set_pmd_at ( mm , mmun_start , pmd , entry ) ;
2013-12-19 05:08:32 +04:00
update_mmu_cache_pmd ( vma , address , & entry ) ;
}
spin_unlock ( ptl ) ;
2013-10-07 14:28:46 +04:00
2013-12-19 05:08:39 +04:00
out_unlock :
2013-02-23 04:34:33 +04:00
unlock_page ( page ) ;
2012-11-19 16:35:47 +04:00
put_page ( page ) ;
return 0 ;
}
2012-10-25 16:16:34 +04:00
# endif /* CONFIG_NUMA_BALANCING */
# endif /* CONFIG_NUMA */
2017-09-09 02:12:09 +03:00
2017-09-09 02:12:32 +03:00
# if defined(CONFIG_MIGRATE_VMA_HELPER)
2017-09-09 02:12:09 +03:00
struct migrate_vma {
struct vm_area_struct * vma ;
unsigned long * dst ;
unsigned long * src ;
unsigned long cpages ;
unsigned long npages ;
unsigned long start ;
unsigned long end ;
} ;
static int migrate_vma_collect_hole ( unsigned long start ,
unsigned long end ,
struct mm_walk * walk )
{
struct migrate_vma * migrate = walk - > private ;
unsigned long addr ;
2017-09-09 02:12:21 +03:00
for ( addr = start & PAGE_MASK ; addr < end ; addr + = PAGE_SIZE ) {
2017-10-14 01:57:30 +03:00
migrate - > src [ migrate - > npages ] = MIGRATE_PFN_MIGRATE ;
2017-09-09 02:12:21 +03:00
migrate - > dst [ migrate - > npages ] = 0 ;
2017-10-14 01:57:30 +03:00
migrate - > npages + + ;
2017-09-09 02:12:21 +03:00
migrate - > cpages + + ;
}
return 0 ;
}
static int migrate_vma_collect_skip ( unsigned long start ,
unsigned long end ,
struct mm_walk * walk )
{
struct migrate_vma * migrate = walk - > private ;
unsigned long addr ;
2017-09-09 02:12:09 +03:00
for ( addr = start & PAGE_MASK ; addr < end ; addr + = PAGE_SIZE ) {
migrate - > dst [ migrate - > npages ] = 0 ;
migrate - > src [ migrate - > npages + + ] = 0 ;
}
return 0 ;
}
static int migrate_vma_collect_pmd ( pmd_t * pmdp ,
unsigned long start ,
unsigned long end ,
struct mm_walk * walk )
{
struct migrate_vma * migrate = walk - > private ;
struct vm_area_struct * vma = walk - > vma ;
struct mm_struct * mm = vma - > vm_mm ;
2017-09-09 02:12:13 +03:00
unsigned long addr = start , unmapped = 0 ;
2017-09-09 02:12:09 +03:00
spinlock_t * ptl ;
pte_t * ptep ;
again :
if ( pmd_none ( * pmdp ) )
return migrate_vma_collect_hole ( start , end , walk ) ;
if ( pmd_trans_huge ( * pmdp ) ) {
struct page * page ;
ptl = pmd_lock ( mm , pmdp ) ;
if ( unlikely ( ! pmd_trans_huge ( * pmdp ) ) ) {
spin_unlock ( ptl ) ;
goto again ;
}
page = pmd_page ( * pmdp ) ;
if ( is_huge_zero_page ( page ) ) {
spin_unlock ( ptl ) ;
split_huge_pmd ( vma , pmdp , addr ) ;
if ( pmd_trans_unstable ( pmdp ) )
2017-09-09 02:12:21 +03:00
return migrate_vma_collect_skip ( start , end ,
2017-09-09 02:12:09 +03:00
walk ) ;
} else {
int ret ;
get_page ( page ) ;
spin_unlock ( ptl ) ;
if ( unlikely ( ! trylock_page ( page ) ) )
2017-09-09 02:12:21 +03:00
return migrate_vma_collect_skip ( start , end ,
2017-09-09 02:12:09 +03:00
walk ) ;
ret = split_huge_page ( page ) ;
unlock_page ( page ) ;
put_page ( page ) ;
2017-09-09 02:12:21 +03:00
if ( ret )
return migrate_vma_collect_skip ( start , end ,
walk ) ;
if ( pmd_none ( * pmdp ) )
2017-09-09 02:12:09 +03:00
return migrate_vma_collect_hole ( start , end ,
walk ) ;
}
}
if ( unlikely ( pmd_bad ( * pmdp ) ) )
2017-09-09 02:12:21 +03:00
return migrate_vma_collect_skip ( start , end , walk ) ;
2017-09-09 02:12:09 +03:00
ptep = pte_offset_map_lock ( mm , pmdp , addr , & ptl ) ;
2017-09-09 02:12:13 +03:00
arch_enter_lazy_mmu_mode ( ) ;
2017-09-09 02:12:09 +03:00
for ( ; addr < end ; addr + = PAGE_SIZE , ptep + + ) {
unsigned long mpfn , pfn ;
struct page * page ;
2017-09-09 02:12:13 +03:00
swp_entry_t entry ;
2017-09-09 02:12:09 +03:00
pte_t pte ;
pte = * ptep ;
pfn = pte_pfn ( pte ) ;
2017-09-09 02:12:17 +03:00
if ( pte_none ( pte ) ) {
2017-09-09 02:12:21 +03:00
mpfn = MIGRATE_PFN_MIGRATE ;
migrate - > cpages + + ;
pfn = 0 ;
2017-09-09 02:12:09 +03:00
goto next ;
}
2017-09-09 02:12:17 +03:00
if ( ! pte_present ( pte ) ) {
mpfn = pfn = 0 ;
/*
* Only care about unaddressable device page special
* page table entry . Other special swap entries are not
* migratable , and we ignore regular swapped page .
*/
entry = pte_to_swp_entry ( pte ) ;
if ( ! is_device_private_entry ( entry ) )
goto next ;
page = device_private_entry_to_page ( entry ) ;
mpfn = migrate_pfn ( page_to_pfn ( page ) ) |
MIGRATE_PFN_DEVICE | MIGRATE_PFN_MIGRATE ;
if ( is_write_device_private_entry ( entry ) )
mpfn | = MIGRATE_PFN_WRITE ;
} else {
2017-09-09 02:12:21 +03:00
if ( is_zero_pfn ( pfn ) ) {
mpfn = MIGRATE_PFN_MIGRATE ;
migrate - > cpages + + ;
pfn = 0 ;
goto next ;
}
2017-09-09 02:12:24 +03:00
page = _vm_normal_page ( migrate - > vma , addr , pte , true ) ;
2017-09-09 02:12:17 +03:00
mpfn = migrate_pfn ( pfn ) | MIGRATE_PFN_MIGRATE ;
mpfn | = pte_write ( pte ) ? MIGRATE_PFN_WRITE : 0 ;
}
2017-09-09 02:12:09 +03:00
/* FIXME support THP */
if ( ! page | | ! page - > mapping | | PageTransCompound ( page ) ) {
mpfn = pfn = 0 ;
goto next ;
}
2017-09-09 02:12:17 +03:00
pfn = page_to_pfn ( page ) ;
2017-09-09 02:12:09 +03:00
/*
* By getting a reference on the page we pin it and that blocks
* any kind of migration . Side effect is that it " freezes " the
* pte .
*
* We drop this reference after isolating the page from the lru
* for non device page ( device page are not on the lru and thus
* can ' t be dropped from it ) .
*/
get_page ( page ) ;
migrate - > cpages + + ;
2017-09-09 02:12:13 +03:00
/*
* Optimize for the common case where page is only mapped once
* in one process . If we can lock the page , then we can safely
* set up a special migration page table entry now .
*/
if ( trylock_page ( page ) ) {
pte_t swp_pte ;
mpfn | = MIGRATE_PFN_LOCKED ;
ptep_get_and_clear ( mm , addr , ptep ) ;
/* Setup special migration page table entry */
2018-04-11 02:29:27 +03:00
entry = make_migration_entry ( page , mpfn &
MIGRATE_PFN_WRITE ) ;
2017-09-09 02:12:13 +03:00
swp_pte = swp_entry_to_pte ( entry ) ;
if ( pte_soft_dirty ( pte ) )
swp_pte = pte_swp_mksoft_dirty ( swp_pte ) ;
set_pte_at ( mm , addr , ptep , swp_pte ) ;
/*
* This is like regular unmap : we remove the rmap and
* drop page refcount . Page won ' t be freed , as we took
* a reference just above .
*/
page_remove_rmap ( page , false ) ;
put_page ( page ) ;
2017-09-09 02:12:17 +03:00
if ( pte_present ( pte ) )
unmapped + + ;
2017-09-09 02:12:13 +03:00
}
2017-09-09 02:12:09 +03:00
next :
2017-09-09 02:12:17 +03:00
migrate - > dst [ migrate - > npages ] = 0 ;
2017-09-09 02:12:09 +03:00
migrate - > src [ migrate - > npages + + ] = mpfn ;
}
2017-09-09 02:12:13 +03:00
arch_leave_lazy_mmu_mode ( ) ;
2017-09-09 02:12:09 +03:00
pte_unmap_unlock ( ptep - 1 , ptl ) ;
2017-09-09 02:12:13 +03:00
/* Only flush the TLB if we actually modified any entries */
if ( unmapped )
flush_tlb_range ( walk - > vma , start , end ) ;
2017-09-09 02:12:09 +03:00
return 0 ;
}
/*
* migrate_vma_collect ( ) - collect pages over a range of virtual addresses
* @ migrate : migrate struct containing all migration information
*
* This will walk the CPU page table . For each virtual address backed by a
* valid page , it updates the src array and takes a reference on the page , in
* order to pin the page until we lock it and unmap it .
*/
static void migrate_vma_collect ( struct migrate_vma * migrate )
{
struct mm_walk mm_walk ;
mm_walk . pmd_entry = migrate_vma_collect_pmd ;
mm_walk . pte_entry = NULL ;
mm_walk . pte_hole = migrate_vma_collect_hole ;
mm_walk . hugetlb_entry = NULL ;
mm_walk . test_walk = NULL ;
mm_walk . vma = migrate - > vma ;
mm_walk . mm = migrate - > vma - > vm_mm ;
mm_walk . private = migrate ;
2017-09-09 02:12:13 +03:00
mmu_notifier_invalidate_range_start ( mm_walk . mm ,
migrate - > start ,
migrate - > end ) ;
2017-09-09 02:12:09 +03:00
walk_page_range ( migrate - > start , migrate - > end , & mm_walk ) ;
2017-09-09 02:12:13 +03:00
mmu_notifier_invalidate_range_end ( mm_walk . mm ,
migrate - > start ,
migrate - > end ) ;
2017-09-09 02:12:09 +03:00
migrate - > end = migrate - > start + ( migrate - > npages < < PAGE_SHIFT ) ;
}
/*
* migrate_vma_check_page ( ) - check if page is pinned or not
* @ page : struct page to check
*
* Pinned pages cannot be migrated . This is the same test as in
* migrate_page_move_mapping ( ) , except that here we allow migration of a
* ZONE_DEVICE page .
*/
static bool migrate_vma_check_page ( struct page * page )
{
/*
* One extra ref because caller holds an extra reference , either from
* isolate_lru_page ( ) for a regular page , or migrate_vma_collect ( ) for
* a device page .
*/
int extra = 1 ;
/*
* FIXME support THP ( transparent huge page ) , it is bit more complex to
* check them than regular pages , because they can be mapped with a pmd
* or with a pte ( split pte mapping ) .
*/
if ( PageCompound ( page ) )
return false ;
2017-09-09 02:12:17 +03:00
/* Page from ZONE_DEVICE have one extra reference */
if ( is_zone_device_page ( page ) ) {
/*
* Private page can never be pin as they have no valid pte and
* GUP will fail for those . Yet if there is a pending migration
* a thread might try to wait on the pte migration entry and
* will bump the page reference count . Sadly there is no way to
* differentiate a regular pin from migration wait . Hence to
* avoid 2 racing thread trying to migrate back to CPU to enter
* infinite loop ( one stoping migration because the other is
* waiting on pte migration entry ) . We always return true here .
*
* FIXME proper solution is to rework migration_entry_wait ( ) so
* it does not need to take a reference on page .
*/
if ( is_device_private_page ( page ) )
return true ;
2017-09-09 02:12:24 +03:00
/*
* Only allow device public page to be migrated and account for
* the extra reference count imply by ZONE_DEVICE pages .
*/
if ( ! is_device_public_page ( page ) )
return false ;
extra + + ;
2017-09-09 02:12:17 +03:00
}
2017-09-09 02:12:24 +03:00
/* For file back page */
if ( page_mapping ( page ) )
extra + = 1 + page_has_private ( page ) ;
2017-09-09 02:12:09 +03:00
if ( ( page_count ( page ) - extra ) > page_mapcount ( page ) )
return false ;
return true ;
}
/*
* migrate_vma_prepare ( ) - lock pages and isolate them from the lru
* @ migrate : migrate struct containing all migration information
*
* This locks pages that have been collected by migrate_vma_collect ( ) . Once each
* page is locked it is isolated from the lru ( for non - device pages ) . Finally ,
* the ref taken by migrate_vma_collect ( ) is dropped , as locked pages cannot be
* migrated by concurrent kernel threads .
*/
static void migrate_vma_prepare ( struct migrate_vma * migrate )
{
const unsigned long npages = migrate - > npages ;
2017-09-09 02:12:13 +03:00
const unsigned long start = migrate - > start ;
unsigned long addr , i , restore = 0 ;
2017-09-09 02:12:09 +03:00
bool allow_drain = true ;
lru_add_drain ( ) ;
for ( i = 0 ; ( i < npages ) & & migrate - > cpages ; i + + ) {
struct page * page = migrate_pfn_to_page ( migrate - > src [ i ] ) ;
2017-09-09 02:12:13 +03:00
bool remap = true ;
2017-09-09 02:12:09 +03:00
if ( ! page )
continue ;
2017-09-09 02:12:13 +03:00
if ( ! ( migrate - > src [ i ] & MIGRATE_PFN_LOCKED ) ) {
/*
* Because we are migrating several pages there can be
* a deadlock between 2 concurrent migration where each
* are waiting on each other page lock .
*
* Make migrate_vma ( ) a best effort thing and backoff
* for any page we can not lock right away .
*/
if ( ! trylock_page ( page ) ) {
migrate - > src [ i ] = 0 ;
migrate - > cpages - - ;
put_page ( page ) ;
continue ;
}
remap = false ;
migrate - > src [ i ] | = MIGRATE_PFN_LOCKED ;
2017-09-09 02:12:09 +03:00
}
2017-09-09 02:12:17 +03:00
/* ZONE_DEVICE pages are not on LRU */
if ( ! is_zone_device_page ( page ) ) {
if ( ! PageLRU ( page ) & & allow_drain ) {
/* Drain CPU's pagevec */
lru_add_drain_all ( ) ;
allow_drain = false ;
}
2017-09-09 02:12:09 +03:00
2017-09-09 02:12:17 +03:00
if ( isolate_lru_page ( page ) ) {
if ( remap ) {
migrate - > src [ i ] & = ~ MIGRATE_PFN_MIGRATE ;
migrate - > cpages - - ;
restore + + ;
} else {
migrate - > src [ i ] = 0 ;
unlock_page ( page ) ;
migrate - > cpages - - ;
put_page ( page ) ;
}
continue ;
2017-09-09 02:12:13 +03:00
}
2017-09-09 02:12:17 +03:00
/* Drop the reference we took in collect */
put_page ( page ) ;
2017-09-09 02:12:09 +03:00
}
if ( ! migrate_vma_check_page ( page ) ) {
2017-09-09 02:12:13 +03:00
if ( remap ) {
migrate - > src [ i ] & = ~ MIGRATE_PFN_MIGRATE ;
migrate - > cpages - - ;
restore + + ;
2017-09-09 02:12:09 +03:00
2017-09-09 02:12:17 +03:00
if ( ! is_zone_device_page ( page ) ) {
get_page ( page ) ;
putback_lru_page ( page ) ;
}
2017-09-09 02:12:13 +03:00
} else {
migrate - > src [ i ] = 0 ;
unlock_page ( page ) ;
migrate - > cpages - - ;
2017-09-09 02:12:17 +03:00
if ( ! is_zone_device_page ( page ) )
putback_lru_page ( page ) ;
else
put_page ( page ) ;
2017-09-09 02:12:13 +03:00
}
2017-09-09 02:12:09 +03:00
}
}
2017-09-09 02:12:13 +03:00
for ( i = 0 , addr = start ; i < npages & & restore ; i + + , addr + = PAGE_SIZE ) {
struct page * page = migrate_pfn_to_page ( migrate - > src [ i ] ) ;
if ( ! page | | ( migrate - > src [ i ] & MIGRATE_PFN_MIGRATE ) )
continue ;
remove_migration_pte ( page , migrate - > vma , addr , page ) ;
migrate - > src [ i ] = 0 ;
unlock_page ( page ) ;
put_page ( page ) ;
restore - - ;
}
2017-09-09 02:12:09 +03:00
}
/*
* migrate_vma_unmap ( ) - replace page mapping with special migration pte entry
* @ migrate : migrate struct containing all migration information
*
* Replace page mapping ( CPU page table pte ) with a special migration pte entry
* and check again if it has been pinned . Pinned pages are restored because we
* cannot migrate them .
*
* This is the last step before we call the device driver callback to allocate
* destination memory and copy contents of original page over to new page .
*/
static void migrate_vma_unmap ( struct migrate_vma * migrate )
{
int flags = TTU_MIGRATION | TTU_IGNORE_MLOCK | TTU_IGNORE_ACCESS ;
const unsigned long npages = migrate - > npages ;
const unsigned long start = migrate - > start ;
unsigned long addr , i , restore = 0 ;
for ( i = 0 ; i < npages ; i + + ) {
struct page * page = migrate_pfn_to_page ( migrate - > src [ i ] ) ;
if ( ! page | | ! ( migrate - > src [ i ] & MIGRATE_PFN_MIGRATE ) )
continue ;
2017-09-09 02:12:13 +03:00
if ( page_mapped ( page ) ) {
try_to_unmap ( page , flags ) ;
if ( page_mapped ( page ) )
goto restore ;
2017-09-09 02:12:09 +03:00
}
2017-09-09 02:12:13 +03:00
if ( migrate_vma_check_page ( page ) )
continue ;
restore :
migrate - > src [ i ] & = ~ MIGRATE_PFN_MIGRATE ;
migrate - > cpages - - ;
restore + + ;
2017-09-09 02:12:09 +03:00
}
for ( addr = start , i = 0 ; i < npages & & restore ; addr + = PAGE_SIZE , i + + ) {
struct page * page = migrate_pfn_to_page ( migrate - > src [ i ] ) ;
if ( ! page | | ( migrate - > src [ i ] & MIGRATE_PFN_MIGRATE ) )
continue ;
remove_migration_ptes ( page , page , false ) ;
migrate - > src [ i ] = 0 ;
unlock_page ( page ) ;
restore - - ;
2017-09-09 02:12:17 +03:00
if ( is_zone_device_page ( page ) )
put_page ( page ) ;
else
putback_lru_page ( page ) ;
2017-09-09 02:12:09 +03:00
}
}
2017-09-09 02:12:21 +03:00
static void migrate_vma_insert_page ( struct migrate_vma * migrate ,
unsigned long addr ,
struct page * page ,
unsigned long * src ,
unsigned long * dst )
{
struct vm_area_struct * vma = migrate - > vma ;
struct mm_struct * mm = vma - > vm_mm ;
struct mem_cgroup * memcg ;
bool flush = false ;
spinlock_t * ptl ;
pte_t entry ;
pgd_t * pgdp ;
p4d_t * p4dp ;
pud_t * pudp ;
pmd_t * pmdp ;
pte_t * ptep ;
/* Only allow populating anonymous memory */
if ( ! vma_is_anonymous ( vma ) )
goto abort ;
pgdp = pgd_offset ( mm , addr ) ;
p4dp = p4d_alloc ( mm , pgdp , addr ) ;
if ( ! p4dp )
goto abort ;
pudp = pud_alloc ( mm , p4dp , addr ) ;
if ( ! pudp )
goto abort ;
pmdp = pmd_alloc ( mm , pudp , addr ) ;
if ( ! pmdp )
goto abort ;
if ( pmd_trans_huge ( * pmdp ) | | pmd_devmap ( * pmdp ) )
goto abort ;
/*
* Use pte_alloc ( ) instead of pte_alloc_map ( ) . We can ' t run
* pte_offset_map ( ) on pmds where a huge pmd might be created
* from a different thread .
*
* pte_alloc_map ( ) is safe to use under down_write ( mmap_sem ) or when
* parallel threads are excluded by other means .
*
* Here we only have down_read ( mmap_sem ) .
*/
if ( pte_alloc ( mm , pmdp , addr ) )
goto abort ;
/* See the comment in pte_alloc_one_map() */
if ( unlikely ( pmd_trans_unstable ( pmdp ) ) )
goto abort ;
if ( unlikely ( anon_vma_prepare ( vma ) ) )
goto abort ;
if ( mem_cgroup_try_charge ( page , vma - > vm_mm , GFP_KERNEL , & memcg , false ) )
goto abort ;
/*
* The memory barrier inside __SetPageUptodate makes sure that
* preceding stores to the page contents become visible before
* the set_pte_at ( ) write .
*/
__SetPageUptodate ( page ) ;
2017-09-09 02:12:24 +03:00
if ( is_zone_device_page ( page ) ) {
if ( is_device_private_page ( page ) ) {
swp_entry_t swp_entry ;
swp_entry = make_device_private_entry ( page , vma - > vm_flags & VM_WRITE ) ;
entry = swp_entry_to_pte ( swp_entry ) ;
} else if ( is_device_public_page ( page ) ) {
entry = pte_mkold ( mk_pte ( page , READ_ONCE ( vma - > vm_page_prot ) ) ) ;
if ( vma - > vm_flags & VM_WRITE )
entry = pte_mkwrite ( pte_mkdirty ( entry ) ) ;
entry = pte_mkdevmap ( entry ) ;
}
2017-09-09 02:12:21 +03:00
} else {
entry = mk_pte ( page , vma - > vm_page_prot ) ;
if ( vma - > vm_flags & VM_WRITE )
entry = pte_mkwrite ( pte_mkdirty ( entry ) ) ;
}
ptep = pte_offset_map_lock ( mm , pmdp , addr , & ptl ) ;
if ( pte_present ( * ptep ) ) {
unsigned long pfn = pte_pfn ( * ptep ) ;
if ( ! is_zero_pfn ( pfn ) ) {
pte_unmap_unlock ( ptep , ptl ) ;
mem_cgroup_cancel_charge ( page , memcg , false ) ;
goto abort ;
}
flush = true ;
} else if ( ! pte_none ( * ptep ) ) {
pte_unmap_unlock ( ptep , ptl ) ;
mem_cgroup_cancel_charge ( page , memcg , false ) ;
goto abort ;
}
/*
* Check for usefaultfd but do not deliver the fault . Instead ,
* just back off .
*/
if ( userfaultfd_missing ( vma ) ) {
pte_unmap_unlock ( ptep , ptl ) ;
mem_cgroup_cancel_charge ( page , memcg , false ) ;
goto abort ;
}
inc_mm_counter ( mm , MM_ANONPAGES ) ;
page_add_new_anon_rmap ( page , vma , addr , false ) ;
mem_cgroup_commit_charge ( page , memcg , false , false ) ;
if ( ! is_zone_device_page ( page ) )
lru_cache_add_active_or_unevictable ( page , vma ) ;
get_page ( page ) ;
if ( flush ) {
flush_cache_page ( vma , addr , pte_pfn ( * ptep ) ) ;
ptep_clear_flush_notify ( vma , addr , ptep ) ;
set_pte_at_notify ( mm , addr , ptep , entry ) ;
update_mmu_cache ( vma , addr , ptep ) ;
} else {
/* No need to invalidate - it was non-present before */
set_pte_at ( mm , addr , ptep , entry ) ;
update_mmu_cache ( vma , addr , ptep ) ;
}
pte_unmap_unlock ( ptep , ptl ) ;
* src = MIGRATE_PFN_MIGRATE ;
return ;
abort :
* src & = ~ MIGRATE_PFN_MIGRATE ;
}
2017-09-09 02:12:09 +03:00
/*
* migrate_vma_pages ( ) - migrate meta - data from src page to dst page
* @ migrate : migrate struct containing all migration information
*
* This migrates struct page meta - data from source struct page to destination
* struct page . This effectively finishes the migration from source page to the
* destination page .
*/
static void migrate_vma_pages ( struct migrate_vma * migrate )
{
const unsigned long npages = migrate - > npages ;
const unsigned long start = migrate - > start ;
2017-09-09 02:12:21 +03:00
struct vm_area_struct * vma = migrate - > vma ;
struct mm_struct * mm = vma - > vm_mm ;
unsigned long addr , i , mmu_start ;
bool notified = false ;
2017-09-09 02:12:09 +03:00
for ( i = 0 , addr = start ; i < npages ; addr + = PAGE_SIZE , i + + ) {
struct page * newpage = migrate_pfn_to_page ( migrate - > dst [ i ] ) ;
struct page * page = migrate_pfn_to_page ( migrate - > src [ i ] ) ;
struct address_space * mapping ;
int r ;
2017-09-09 02:12:21 +03:00
if ( ! newpage ) {
migrate - > src [ i ] & = ~ MIGRATE_PFN_MIGRATE ;
2017-09-09 02:12:09 +03:00
continue ;
2017-09-09 02:12:21 +03:00
}
if ( ! page ) {
if ( ! ( migrate - > src [ i ] & MIGRATE_PFN_MIGRATE ) ) {
continue ;
}
if ( ! notified ) {
mmu_start = addr ;
notified = true ;
mmu_notifier_invalidate_range_start ( mm ,
mmu_start ,
migrate - > end ) ;
}
migrate_vma_insert_page ( migrate , addr , newpage ,
& migrate - > src [ i ] ,
& migrate - > dst [ i ] ) ;
2017-09-09 02:12:09 +03:00
continue ;
2017-09-09 02:12:21 +03:00
}
2017-09-09 02:12:09 +03:00
mapping = page_mapping ( page ) ;
2017-09-09 02:12:17 +03:00
if ( is_zone_device_page ( newpage ) ) {
if ( is_device_private_page ( newpage ) ) {
/*
* For now only support private anonymous when
* migrating to un - addressable device memory .
*/
if ( mapping ) {
migrate - > src [ i ] & = ~ MIGRATE_PFN_MIGRATE ;
continue ;
}
2017-09-09 02:12:24 +03:00
} else if ( ! is_device_public_page ( newpage ) ) {
2017-09-09 02:12:17 +03:00
/*
* Other types of ZONE_DEVICE page are not
* supported .
*/
migrate - > src [ i ] & = ~ MIGRATE_PFN_MIGRATE ;
continue ;
}
}
2017-09-09 02:12:09 +03:00
r = migrate_page ( mapping , newpage , page , MIGRATE_SYNC_NO_COPY ) ;
if ( r ! = MIGRATEPAGE_SUCCESS )
migrate - > src [ i ] & = ~ MIGRATE_PFN_MIGRATE ;
}
2017-09-09 02:12:21 +03:00
2017-11-16 04:34:11 +03:00
/*
* No need to double call mmu_notifier - > invalidate_range ( ) callback as
* the above ptep_clear_flush_notify ( ) inside migrate_vma_insert_page ( )
* did already call it .
*/
2017-09-09 02:12:21 +03:00
if ( notified )
2017-11-16 04:34:11 +03:00
mmu_notifier_invalidate_range_only_end ( mm , mmu_start ,
migrate - > end ) ;
2017-09-09 02:12:09 +03:00
}
/*
* migrate_vma_finalize ( ) - restore CPU page table entry
* @ migrate : migrate struct containing all migration information
*
* This replaces the special migration pte entry with either a mapping to the
* new page if migration was successful for that page , or to the original page
* otherwise .
*
* This also unlocks the pages and puts them back on the lru , or drops the extra
* refcount , for device pages .
*/
static void migrate_vma_finalize ( struct migrate_vma * migrate )
{
const unsigned long npages = migrate - > npages ;
unsigned long i ;
for ( i = 0 ; i < npages ; i + + ) {
struct page * newpage = migrate_pfn_to_page ( migrate - > dst [ i ] ) ;
struct page * page = migrate_pfn_to_page ( migrate - > src [ i ] ) ;
2017-09-09 02:12:21 +03:00
if ( ! page ) {
if ( newpage ) {
unlock_page ( newpage ) ;
put_page ( newpage ) ;
}
2017-09-09 02:12:09 +03:00
continue ;
2017-09-09 02:12:21 +03:00
}
2017-09-09 02:12:09 +03:00
if ( ! ( migrate - > src [ i ] & MIGRATE_PFN_MIGRATE ) | | ! newpage ) {
if ( newpage ) {
unlock_page ( newpage ) ;
put_page ( newpage ) ;
}
newpage = page ;
}
remove_migration_ptes ( page , newpage , false ) ;
unlock_page ( page ) ;
migrate - > cpages - - ;
2017-09-09 02:12:17 +03:00
if ( is_zone_device_page ( page ) )
put_page ( page ) ;
else
putback_lru_page ( page ) ;
2017-09-09 02:12:09 +03:00
if ( newpage ! = page ) {
unlock_page ( newpage ) ;
2017-09-09 02:12:17 +03:00
if ( is_zone_device_page ( newpage ) )
put_page ( newpage ) ;
else
putback_lru_page ( newpage ) ;
2017-09-09 02:12:09 +03:00
}
}
}
/*
* migrate_vma ( ) - migrate a range of memory inside vma
*
* @ ops : migration callback for allocating destination memory and copying
* @ vma : virtual memory area containing the range to be migrated
* @ start : start address of the range to migrate ( inclusive )
* @ end : end address of the range to migrate ( exclusive )
* @ src : array of hmm_pfn_t containing source pfns
* @ dst : array of hmm_pfn_t containing destination pfns
* @ private : pointer passed back to each of the callback
* Returns : 0 on success , error code otherwise
*
* This function tries to migrate a range of memory virtual address range , using
* callbacks to allocate and copy memory from source to destination . First it
* collects all the pages backing each virtual address in the range , saving this
* inside the src array . Then it locks those pages and unmaps them . Once the pages
* are locked and unmapped , it checks whether each page is pinned or not . Pages
* that aren ' t pinned have the MIGRATE_PFN_MIGRATE flag set ( by this function )
* in the corresponding src array entry . It then restores any pages that are
* pinned , by remapping and unlocking those pages .
*
* At this point it calls the alloc_and_copy ( ) callback . For documentation on
* what is expected from that callback , see struct migrate_vma_ops comments in
* include / linux / migrate . h
*
* After the alloc_and_copy ( ) callback , this function goes over each entry in
* the src array that has the MIGRATE_PFN_VALID and MIGRATE_PFN_MIGRATE flag
* set . If the corresponding entry in dst array has MIGRATE_PFN_VALID flag set ,
* then the function tries to migrate struct page information from the source
* struct page to the destination struct page . If it fails to migrate the struct
* page information , then it clears the MIGRATE_PFN_MIGRATE flag in the src
* array .
*
* At this point all successfully migrated pages have an entry in the src
* array with MIGRATE_PFN_VALID and MIGRATE_PFN_MIGRATE flag set and the dst
* array entry with MIGRATE_PFN_VALID flag set .
*
* It then calls the finalize_and_map ( ) callback . See comments for " struct
* migrate_vma_ops " , in include/linux/migrate.h for details about
* finalize_and_map ( ) behavior .
*
* After the finalize_and_map ( ) callback , for successfully migrated pages , this
* function updates the CPU page table to point to new pages , otherwise it
* restores the CPU page table to point to the original source pages .
*
* Function returns 0 after the above steps , even if no pages were migrated
* ( The function only returns an error if any of the arguments are invalid . )
*
* Both src and dst array must be big enough for ( end - start ) > > PAGE_SHIFT
* unsigned long entries .
*/
int migrate_vma ( const struct migrate_vma_ops * ops ,
struct vm_area_struct * vma ,
unsigned long start ,
unsigned long end ,
unsigned long * src ,
unsigned long * dst ,
void * private )
{
struct migrate_vma migrate ;
/* Sanity check the arguments */
start & = PAGE_MASK ;
end & = PAGE_MASK ;
if ( ! vma | | is_vm_hugetlb_page ( vma ) | | ( vma - > vm_flags & VM_SPECIAL ) )
return - EINVAL ;
if ( start < vma - > vm_start | | start > = vma - > vm_end )
return - EINVAL ;
if ( end < = vma - > vm_start | | end > vma - > vm_end )
return - EINVAL ;
if ( ! ops | | ! src | | ! dst | | start > = end )
return - EINVAL ;
memset ( src , 0 , sizeof ( * src ) * ( ( end - start ) > > PAGE_SHIFT ) ) ;
migrate . src = src ;
migrate . dst = dst ;
migrate . start = start ;
migrate . npages = 0 ;
migrate . cpages = 0 ;
migrate . end = end ;
migrate . vma = vma ;
/* Collect, and try to unmap source pages */
migrate_vma_collect ( & migrate ) ;
if ( ! migrate . cpages )
return 0 ;
/* Lock and isolate page */
migrate_vma_prepare ( & migrate ) ;
if ( ! migrate . cpages )
return 0 ;
/* Unmap pages */
migrate_vma_unmap ( & migrate ) ;
if ( ! migrate . cpages )
return 0 ;
/*
* At this point pages are locked and unmapped , and thus they have
* stable content and can safely be copied to destination memory that
* is allocated by the callback .
*
* Note that migration can fail in migrate_vma_struct_page ( ) for each
* individual page .
*/
ops - > alloc_and_copy ( vma , src , dst , start , end , private ) ;
/* This does the real migration of struct page */
migrate_vma_pages ( & migrate ) ;
ops - > finalize_and_map ( vma , src , dst , start , end , private ) ;
/* Unlock and remap pages */
migrate_vma_finalize ( & migrate ) ;
return 0 ;
}
EXPORT_SYMBOL ( migrate_vma ) ;
2017-09-09 02:12:32 +03:00
# endif /* defined(MIGRATE_VMA_HELPER) */