2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* mm/rmap.c - physical to virtual reverse mappings
|
|
|
|
*
|
|
|
|
* Copyright 2001, Rik van Riel <riel@conectiva.com.br>
|
|
|
|
* Released under the General Public License (GPL).
|
|
|
|
*
|
|
|
|
* Simple, low overhead reverse mapping scheme.
|
|
|
|
* Please try to keep this thing as modular as possible.
|
|
|
|
*
|
|
|
|
* Provides methods for unmapping each kind of mapped page:
|
|
|
|
* the anon methods track anonymous pages, and
|
|
|
|
* the file methods track pages belonging to an inode.
|
|
|
|
*
|
|
|
|
* Original design by Rik van Riel <riel@conectiva.com.br> 2001
|
|
|
|
* File methods by Dave McCracken <dmccr@us.ibm.com> 2003, 2004
|
|
|
|
* Anonymous methods by Andrea Arcangeli <andrea@suse.de> 2004
|
|
|
|
* Contributions by Hugh Dickins <hugh@veritas.com> 2003, 2004
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock ordering in mm:
|
|
|
|
*
|
2006-01-09 23:59:24 +00:00
|
|
|
* inode->i_mutex (while writing or truncating, not reading or faulting)
|
2006-10-20 06:29:10 +00:00
|
|
|
* inode->i_alloc_sem (vmtruncate_range)
|
|
|
|
* mm->mmap_sem
|
|
|
|
* page->flags PG_locked (lock_page)
|
|
|
|
* mapping->i_mmap_lock
|
|
|
|
* anon_vma->lock
|
|
|
|
* mm->page_table_lock or pte_lock
|
|
|
|
* zone->lru_lock (in mark_page_accessed, isolate_lru_page)
|
|
|
|
* swap_lock (in swap_duplicate, swap_info_get)
|
|
|
|
* mmlist_lock (in mmput, drain_mmlist and others)
|
|
|
|
* mapping->private_lock (in __set_page_dirty_buffers)
|
|
|
|
* inode_lock (in set_page_dirty's __mark_inode_dirty)
|
|
|
|
* sb_lock (within inode_lock in fs/fs-writeback.c)
|
|
|
|
* mapping->tree_lock (widely used, in set_page_dirty,
|
|
|
|
* in arch-dependent flush_dcache_mmap_lock,
|
|
|
|
* within inode_lock in __sync_single_inode)
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/swapops.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/rmap.h>
|
|
|
|
#include <linux/rcupdate.h>
|
2006-02-01 11:05:38 +00:00
|
|
|
#include <linux/module.h>
|
2006-12-22 09:09:33 +00:00
|
|
|
#include <linux/kallsyms.h>
|
2008-02-07 08:13:53 +00:00
|
|
|
#include <linux/memcontrol.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
|
2006-03-22 08:08:13 +00:00
|
|
|
struct kmem_cache *anon_vma_cachep;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* This must be called under the mmap_sem. */
|
|
|
|
int anon_vma_prepare(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct anon_vma *anon_vma = vma->anon_vma;
|
|
|
|
|
|
|
|
might_sleep();
|
|
|
|
if (unlikely(!anon_vma)) {
|
|
|
|
struct mm_struct *mm = vma->vm_mm;
|
|
|
|
struct anon_vma *allocated, *locked;
|
|
|
|
|
|
|
|
anon_vma = find_mergeable_anon_vma(vma);
|
|
|
|
if (anon_vma) {
|
|
|
|
allocated = NULL;
|
|
|
|
locked = anon_vma;
|
|
|
|
spin_lock(&locked->lock);
|
|
|
|
} else {
|
|
|
|
anon_vma = anon_vma_alloc();
|
|
|
|
if (unlikely(!anon_vma))
|
|
|
|
return -ENOMEM;
|
|
|
|
allocated = anon_vma;
|
|
|
|
locked = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* page_table_lock to protect against threads */
|
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
if (likely(!vma->anon_vma)) {
|
|
|
|
vma->anon_vma = anon_vma;
|
[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 09:03:35 +00:00
|
|
|
list_add_tail(&vma->anon_vma_node, &anon_vma->head);
|
2005-04-16 22:20:36 +00:00
|
|
|
allocated = NULL;
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
|
|
|
|
if (locked)
|
|
|
|
spin_unlock(&locked->lock);
|
|
|
|
if (unlikely(allocated))
|
|
|
|
anon_vma_free(allocated);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __anon_vma_merge(struct vm_area_struct *vma, struct vm_area_struct *next)
|
|
|
|
{
|
|
|
|
BUG_ON(vma->anon_vma != next->anon_vma);
|
|
|
|
list_del(&next->anon_vma_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __anon_vma_link(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct anon_vma *anon_vma = vma->anon_vma;
|
|
|
|
|
2007-06-27 21:09:53 +00:00
|
|
|
if (anon_vma)
|
[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 09:03:35 +00:00
|
|
|
list_add_tail(&vma->anon_vma_node, &anon_vma->head);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void anon_vma_link(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct anon_vma *anon_vma = vma->anon_vma;
|
|
|
|
|
|
|
|
if (anon_vma) {
|
|
|
|
spin_lock(&anon_vma->lock);
|
[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 09:03:35 +00:00
|
|
|
list_add_tail(&vma->anon_vma_node, &anon_vma->head);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock(&anon_vma->lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void anon_vma_unlink(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct anon_vma *anon_vma = vma->anon_vma;
|
|
|
|
int empty;
|
|
|
|
|
|
|
|
if (!anon_vma)
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock(&anon_vma->lock);
|
|
|
|
list_del(&vma->anon_vma_node);
|
|
|
|
|
|
|
|
/* We must garbage collect the anon_vma if it's empty */
|
|
|
|
empty = list_empty(&anon_vma->head);
|
|
|
|
spin_unlock(&anon_vma->lock);
|
|
|
|
|
|
|
|
if (empty)
|
|
|
|
anon_vma_free(anon_vma);
|
|
|
|
}
|
|
|
|
|
2007-10-17 06:25:51 +00:00
|
|
|
static void anon_vma_ctor(struct kmem_cache *cachep, void *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-17 05:10:57 +00:00
|
|
|
struct anon_vma *anon_vma = data;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-17 05:10:57 +00:00
|
|
|
spin_lock_init(&anon_vma->lock);
|
|
|
|
INIT_LIST_HEAD(&anon_vma->head);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void __init anon_vma_init(void)
|
|
|
|
{
|
|
|
|
anon_vma_cachep = kmem_cache_create("anon_vma", sizeof(struct anon_vma),
|
2007-07-20 01:11:58 +00:00
|
|
|
0, SLAB_DESTROY_BY_RCU|SLAB_PANIC, anon_vma_ctor);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Getting a lock on a stable anon_vma from a page off the LRU is
|
|
|
|
* tricky: page_lock_anon_vma rely on RCU to guard against the races.
|
|
|
|
*/
|
|
|
|
static struct anon_vma *page_lock_anon_vma(struct page *page)
|
|
|
|
{
|
2007-03-01 04:13:49 +00:00
|
|
|
struct anon_vma *anon_vma;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long anon_mapping;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
anon_mapping = (unsigned long) page->mapping;
|
|
|
|
if (!(anon_mapping & PAGE_MAPPING_ANON))
|
|
|
|
goto out;
|
|
|
|
if (!page_mapped(page))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
|
|
|
|
spin_lock(&anon_vma->lock);
|
2007-03-01 04:13:49 +00:00
|
|
|
return anon_vma;
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
2007-03-01 04:13:49 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void page_unlock_anon_vma(struct anon_vma *anon_vma)
|
|
|
|
{
|
|
|
|
spin_unlock(&anon_vma->lock);
|
|
|
|
rcu_read_unlock();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
Migration: find correct vma in new_vma_page()
We hit the BUG_ON() in mm/rmap.c:vma_address() when trying to migrate via
mbind(MPOL_MF_MOVE) a non-anon region that spans multiple vmas. For
anon-regions, we just fail to migrate any pages beyond the 1st vma in the
range.
This occurs because do_mbind() collects a list of pages to migrate by
calling check_range(). check_range() walks the task's mm, spanning vmas as
necessary, to collect the migratable pages into a list. Then, do_mbind()
calls migrate_pages() passing the list of pages, a function to allocate new
pages based on vma policy [new_vma_page()], and a pointer to the first vma
of the range.
For each page in the list, new_vma_page() calls page_address_in_vma()
passing the page and the vma [first in range] to obtain the address to get
for alloc_page_vma(). The page address is needed to get interleaving
policy correct. If the pages in the list come from multiple vmas,
eventually, new_page_address() will pass that page to page_address_in_vma()
with the incorrect vma. For !PageAnon pages, this will result in a bug
check in rmap.c:vma_address(). For anon pages, vma_address() will just
return EFAULT and fail the migration.
This patch modifies new_vma_page() to check the return value from
page_address_in_vma(). If the return value is EFAULT, new_vma_page()
searchs forward via vm_next for the vma that maps the page--i.e., that does
not return EFAULT. This assumes that the pages in the list handed to
migrate_pages() is in address order. This is currently case. The patch
documents this assumption in a new comment block for new_vma_page().
If new_vma_page() cannot locate the vma mapping the page in a forward
search in the mm, it will pass a NULL vma to alloc_page_vma(). This will
result in the allocation using the task policy, if any, else system default
policy. This situation is unlikely, but the patch documents this behavior
with a comment.
Note, this patch results in restarting from the first vma in a multi-vma
range each time new_vma_page() is called. If this is not acceptable, we
can make the vma argument a pointer, both in new_vma_page() and it's caller
unmap_and_move() so that the value held by the loop in migrate_pages()
always passes down the last vma in which a page was found. This will
require changes to all new_page_t functions passed to migrate_pages(). Is
this necessary?
For this patch to work, we can't bug check in vma_address() for pages
outside the argument vma. This patch removes the BUG_ON(). All other
callers [besides new_vma_page()] already check the return status.
Tested on x86_64, 4 node NUMA platform.
Signed-off-by: Lee Schermerhorn <lee.schermerhorn@hp.com>
Acked-by: Christoph Lameter <clameter@sgi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-11-15 00:59:10 +00:00
|
|
|
* At what user virtual address is page expected in @vma?
|
|
|
|
* Returns virtual address or -EFAULT if page's index/offset is not
|
|
|
|
* within the range mapped the @vma.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static inline unsigned long
|
|
|
|
vma_address(struct page *page, struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
pgoff_t pgoff = page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
|
|
|
|
unsigned long address;
|
|
|
|
|
|
|
|
address = vma->vm_start + ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
|
|
|
|
if (unlikely(address < vma->vm_start || address >= vma->vm_end)) {
|
Migration: find correct vma in new_vma_page()
We hit the BUG_ON() in mm/rmap.c:vma_address() when trying to migrate via
mbind(MPOL_MF_MOVE) a non-anon region that spans multiple vmas. For
anon-regions, we just fail to migrate any pages beyond the 1st vma in the
range.
This occurs because do_mbind() collects a list of pages to migrate by
calling check_range(). check_range() walks the task's mm, spanning vmas as
necessary, to collect the migratable pages into a list. Then, do_mbind()
calls migrate_pages() passing the list of pages, a function to allocate new
pages based on vma policy [new_vma_page()], and a pointer to the first vma
of the range.
For each page in the list, new_vma_page() calls page_address_in_vma()
passing the page and the vma [first in range] to obtain the address to get
for alloc_page_vma(). The page address is needed to get interleaving
policy correct. If the pages in the list come from multiple vmas,
eventually, new_page_address() will pass that page to page_address_in_vma()
with the incorrect vma. For !PageAnon pages, this will result in a bug
check in rmap.c:vma_address(). For anon pages, vma_address() will just
return EFAULT and fail the migration.
This patch modifies new_vma_page() to check the return value from
page_address_in_vma(). If the return value is EFAULT, new_vma_page()
searchs forward via vm_next for the vma that maps the page--i.e., that does
not return EFAULT. This assumes that the pages in the list handed to
migrate_pages() is in address order. This is currently case. The patch
documents this assumption in a new comment block for new_vma_page().
If new_vma_page() cannot locate the vma mapping the page in a forward
search in the mm, it will pass a NULL vma to alloc_page_vma(). This will
result in the allocation using the task policy, if any, else system default
policy. This situation is unlikely, but the patch documents this behavior
with a comment.
Note, this patch results in restarting from the first vma in a multi-vma
range each time new_vma_page() is called. If this is not acceptable, we
can make the vma argument a pointer, both in new_vma_page() and it's caller
unmap_and_move() so that the value held by the loop in migrate_pages()
always passes down the last vma in which a page was found. This will
require changes to all new_page_t functions passed to migrate_pages(). Is
this necessary?
For this patch to work, we can't bug check in vma_address() for pages
outside the argument vma. This patch removes the BUG_ON(). All other
callers [besides new_vma_page()] already check the return status.
Tested on x86_64, 4 node NUMA platform.
Signed-off-by: Lee Schermerhorn <lee.schermerhorn@hp.com>
Acked-by: Christoph Lameter <clameter@sgi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-11-15 00:59:10 +00:00
|
|
|
/* page should be within @vma mapping range */
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return address;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At what user virtual address is page expected in vma? checking that the
|
[PATCH] unpaged: anon in VM_UNPAGED
copy_one_pte needs to copy the anonymous COWed pages in a VM_UNPAGED area,
zap_pte_range needs to free them, do_wp_page needs to COW them: just like
ordinary pages, not like the unpaged.
But recognizing them is a little subtle: because PageReserved is no longer a
condition for remap_pfn_range, we can now mmap all of /dev/mem (whether the
distro permits, and whether it's advisable on this or that architecture, is
another matter). So if we can see a PageAnon, it may not be ours to mess with
(or may be ours from elsewhere in the address space). I suspect there's an
entertaining insoluble self-referential problem here, but the page_is_anon
function does a good practical job, and MAP_PRIVATE PROT_WRITE VM_UNPAGED will
always be an odd choice.
In updating the comment on page_address_in_vma, noticed a potential NULL
dereference, in a path we don't actually take, but fixed it.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-11-22 05:32:18 +00:00
|
|
|
* page matches the vma: currently only used on anon pages, by unuse_vma;
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
unsigned long page_address_in_vma(struct page *page, struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
if (PageAnon(page)) {
|
|
|
|
if ((void *)vma->anon_vma !=
|
|
|
|
(void *)page->mapping - PAGE_MAPPING_ANON)
|
|
|
|
return -EFAULT;
|
|
|
|
} else if (page->mapping && !(vma->vm_flags & VM_NONLINEAR)) {
|
[PATCH] unpaged: anon in VM_UNPAGED
copy_one_pte needs to copy the anonymous COWed pages in a VM_UNPAGED area,
zap_pte_range needs to free them, do_wp_page needs to COW them: just like
ordinary pages, not like the unpaged.
But recognizing them is a little subtle: because PageReserved is no longer a
condition for remap_pfn_range, we can now mmap all of /dev/mem (whether the
distro permits, and whether it's advisable on this or that architecture, is
another matter). So if we can see a PageAnon, it may not be ours to mess with
(or may be ours from elsewhere in the address space). I suspect there's an
entertaining insoluble self-referential problem here, but the page_is_anon
function does a good practical job, and MAP_PRIVATE PROT_WRITE VM_UNPAGED will
always be an odd choice.
In updating the comment on page_address_in_vma, noticed a potential NULL
dereference, in a path we don't actually take, but fixed it.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-11-22 05:32:18 +00:00
|
|
|
if (!vma->vm_file ||
|
|
|
|
vma->vm_file->f_mapping != page->mapping)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
} else
|
|
|
|
return -EFAULT;
|
|
|
|
return vma_address(page, vma);
|
|
|
|
}
|
|
|
|
|
2005-05-01 15:58:36 +00:00
|
|
|
/*
|
|
|
|
* Check that @page is mapped at @address into @mm.
|
|
|
|
*
|
2005-10-30 01:16:41 +00:00
|
|
|
* On success returns with pte mapped and locked.
|
2005-05-01 15:58:36 +00:00
|
|
|
*/
|
2005-06-24 05:05:25 +00:00
|
|
|
pte_t *page_check_address(struct page *page, struct mm_struct *mm,
|
2005-10-30 01:16:31 +00:00
|
|
|
unsigned long address, spinlock_t **ptlp)
|
2005-05-01 15:58:36 +00:00
|
|
|
{
|
|
|
|
pgd_t *pgd;
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
|
|
|
pte_t *pte;
|
2005-10-30 01:16:31 +00:00
|
|
|
spinlock_t *ptl;
|
2005-05-01 15:58:36 +00:00
|
|
|
|
|
|
|
pgd = pgd_offset(mm, address);
|
2005-10-30 01:16:31 +00:00
|
|
|
if (!pgd_present(*pgd))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pud = pud_offset(pgd, address);
|
|
|
|
if (!pud_present(*pud))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pmd = pmd_offset(pud, address);
|
|
|
|
if (!pmd_present(*pmd))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pte = pte_offset_map(pmd, address);
|
|
|
|
/* Make a quick check before getting the lock */
|
|
|
|
if (!pte_present(*pte)) {
|
|
|
|
pte_unmap(pte);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
[PATCH] mm: split page table lock
Christoph Lameter demonstrated very poor scalability on the SGI 512-way, with
a many-threaded application which concurrently initializes different parts of
a large anonymous area.
This patch corrects that, by using a separate spinlock per page table page, to
guard the page table entries in that page, instead of using the mm's single
page_table_lock. (But even then, page_table_lock is still used to guard page
table allocation, and anon_vma allocation.)
In this implementation, the spinlock is tucked inside the struct page of the
page table page: with a BUILD_BUG_ON in case it overflows - which it would in
the case of 32-bit PA-RISC with spinlock debugging enabled.
Splitting the lock is not quite for free: another cacheline access. Ideally,
I suppose we would use split ptlock only for multi-threaded processes on
multi-cpu machines; but deciding that dynamically would have its own costs.
So for now enable it by config, at some number of cpus - since the Kconfig
language doesn't support inequalities, let preprocessor compare that with
NR_CPUS. But I don't think it's worth being user-configurable: for good
testing of both split and unsplit configs, split now at 4 cpus, and perhaps
change that to 8 later.
There is a benefit even for singly threaded processes: kswapd can be attacking
one part of the mm while another part is busy faulting.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 01:16:40 +00:00
|
|
|
ptl = pte_lockptr(mm, pmd);
|
2005-10-30 01:16:31 +00:00
|
|
|
spin_lock(ptl);
|
|
|
|
if (pte_present(*pte) && page_to_pfn(page) == pte_pfn(*pte)) {
|
|
|
|
*ptlp = ptl;
|
|
|
|
return pte;
|
2005-05-01 15:58:36 +00:00
|
|
|
}
|
2005-10-30 01:16:31 +00:00
|
|
|
pte_unmap_unlock(pte, ptl);
|
|
|
|
return NULL;
|
2005-05-01 15:58:36 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Subfunctions of page_referenced: page_referenced_one called
|
|
|
|
* repeatedly from either page_referenced_anon or page_referenced_file.
|
|
|
|
*/
|
|
|
|
static int page_referenced_one(struct page *page,
|
2005-11-28 21:44:07 +00:00
|
|
|
struct vm_area_struct *vma, unsigned int *mapcount)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mm_struct *mm = vma->vm_mm;
|
|
|
|
unsigned long address;
|
|
|
|
pte_t *pte;
|
2005-10-30 01:16:31 +00:00
|
|
|
spinlock_t *ptl;
|
2005-04-16 22:20:36 +00:00
|
|
|
int referenced = 0;
|
|
|
|
|
|
|
|
address = vma_address(page, vma);
|
|
|
|
if (address == -EFAULT)
|
|
|
|
goto out;
|
|
|
|
|
2005-10-30 01:16:31 +00:00
|
|
|
pte = page_check_address(page, mm, address, &ptl);
|
|
|
|
if (!pte)
|
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-05 06:29:23 +00:00
|
|
|
if (vma->vm_flags & VM_LOCKED) {
|
|
|
|
referenced++;
|
|
|
|
*mapcount = 1; /* break early from loop */
|
|
|
|
} else if (ptep_clear_flush_young(vma, address, pte))
|
2005-10-30 01:16:31 +00:00
|
|
|
referenced++;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-30 01:16:31 +00:00
|
|
|
/* Pretend the page is referenced if the task has the
|
|
|
|
swap token and is in the middle of a page fault. */
|
2005-11-28 21:44:07 +00:00
|
|
|
if (mm != current->mm && has_swap_token(mm) &&
|
2005-10-30 01:16:31 +00:00
|
|
|
rwsem_is_locked(&mm->mmap_sem))
|
|
|
|
referenced++;
|
|
|
|
|
|
|
|
(*mapcount)--;
|
|
|
|
pte_unmap_unlock(pte, ptl);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
|
|
|
return referenced;
|
|
|
|
}
|
|
|
|
|
2008-02-07 08:14:01 +00:00
|
|
|
static int page_referenced_anon(struct page *page,
|
|
|
|
struct mem_cgroup *mem_cont)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned int mapcount;
|
|
|
|
struct anon_vma *anon_vma;
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
int referenced = 0;
|
|
|
|
|
|
|
|
anon_vma = page_lock_anon_vma(page);
|
|
|
|
if (!anon_vma)
|
|
|
|
return referenced;
|
|
|
|
|
|
|
|
mapcount = page_mapcount(page);
|
|
|
|
list_for_each_entry(vma, &anon_vma->head, anon_vma_node) {
|
2008-02-07 08:14:01 +00:00
|
|
|
/*
|
|
|
|
* If we are reclaiming on behalf of a cgroup, skip
|
|
|
|
* counting on behalf of references from different
|
|
|
|
* cgroups
|
|
|
|
*/
|
2008-03-04 22:29:01 +00:00
|
|
|
if (mem_cont && !mm_match_cgroup(vma->vm_mm, mem_cont))
|
2008-02-07 08:14:01 +00:00
|
|
|
continue;
|
2005-11-28 21:44:07 +00:00
|
|
|
referenced += page_referenced_one(page, vma, &mapcount);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!mapcount)
|
|
|
|
break;
|
|
|
|
}
|
2007-03-01 04:13:49 +00:00
|
|
|
|
|
|
|
page_unlock_anon_vma(anon_vma);
|
2005-04-16 22:20:36 +00:00
|
|
|
return referenced;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* page_referenced_file - referenced check for object-based rmap
|
|
|
|
* @page: the page we're checking references on.
|
2008-03-20 00:00:43 +00:00
|
|
|
* @mem_cont: target memory controller
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* For an object-based mapped page, find all the places it is mapped and
|
|
|
|
* check/clear the referenced flag. This is done by following the page->mapping
|
|
|
|
* pointer, then walking the chain of vmas it holds. It returns the number
|
|
|
|
* of references it found.
|
|
|
|
*
|
|
|
|
* This function is only called from page_referenced for object-based pages.
|
|
|
|
*/
|
2008-02-07 08:14:01 +00:00
|
|
|
static int page_referenced_file(struct page *page,
|
|
|
|
struct mem_cgroup *mem_cont)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned int mapcount;
|
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
pgoff_t pgoff = page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
struct prio_tree_iter iter;
|
|
|
|
int referenced = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The caller's checks on page->mapping and !PageAnon have made
|
|
|
|
* sure that this is a file page: the check for page->mapping
|
|
|
|
* excludes the case just before it gets set on an anon page.
|
|
|
|
*/
|
|
|
|
BUG_ON(PageAnon(page));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The page lock not only makes sure that page->mapping cannot
|
|
|
|
* suddenly be NULLified by truncation, it makes sure that the
|
|
|
|
* structure at mapping cannot be freed and reused yet,
|
|
|
|
* so we can safely take mapping->i_mmap_lock.
|
|
|
|
*/
|
|
|
|
BUG_ON(!PageLocked(page));
|
|
|
|
|
|
|
|
spin_lock(&mapping->i_mmap_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* i_mmap_lock does not stabilize mapcount at all, but mapcount
|
|
|
|
* is more likely to be accurate if we note it after spinning.
|
|
|
|
*/
|
|
|
|
mapcount = page_mapcount(page);
|
|
|
|
|
|
|
|
vma_prio_tree_foreach(vma, &iter, &mapping->i_mmap, pgoff, pgoff) {
|
2008-02-07 08:14:01 +00:00
|
|
|
/*
|
|
|
|
* If we are reclaiming on behalf of a cgroup, skip
|
|
|
|
* counting on behalf of references from different
|
|
|
|
* cgroups
|
|
|
|
*/
|
2008-03-04 22:29:01 +00:00
|
|
|
if (mem_cont && !mm_match_cgroup(vma->vm_mm, mem_cont))
|
2008-02-07 08:14:01 +00:00
|
|
|
continue;
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((vma->vm_flags & (VM_LOCKED|VM_MAYSHARE))
|
|
|
|
== (VM_LOCKED|VM_MAYSHARE)) {
|
|
|
|
referenced++;
|
|
|
|
break;
|
|
|
|
}
|
2005-11-28 21:44:07 +00:00
|
|
|
referenced += page_referenced_one(page, vma, &mapcount);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!mapcount)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&mapping->i_mmap_lock);
|
|
|
|
return referenced;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* page_referenced - test if the page was referenced
|
|
|
|
* @page: the page to test
|
|
|
|
* @is_locked: caller holds lock on the page
|
2008-03-20 00:00:43 +00:00
|
|
|
* @mem_cont: target memory controller
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Quick test_and_clear_referenced for all mappings to a page,
|
|
|
|
* returns the number of ptes which referenced the page.
|
|
|
|
*/
|
2008-02-07 08:14:01 +00:00
|
|
|
int page_referenced(struct page *page, int is_locked,
|
|
|
|
struct mem_cgroup *mem_cont)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int referenced = 0;
|
|
|
|
|
|
|
|
if (TestClearPageReferenced(page))
|
|
|
|
referenced++;
|
|
|
|
|
|
|
|
if (page_mapped(page) && page->mapping) {
|
|
|
|
if (PageAnon(page))
|
2008-02-07 08:14:01 +00:00
|
|
|
referenced += page_referenced_anon(page, mem_cont);
|
2005-04-16 22:20:36 +00:00
|
|
|
else if (is_locked)
|
2008-02-07 08:14:01 +00:00
|
|
|
referenced += page_referenced_file(page, mem_cont);
|
2005-04-16 22:20:36 +00:00
|
|
|
else if (TestSetPageLocked(page))
|
|
|
|
referenced++;
|
|
|
|
else {
|
|
|
|
if (page->mapping)
|
2008-02-07 08:14:01 +00:00
|
|
|
referenced +=
|
|
|
|
page_referenced_file(page, mem_cont);
|
2005-04-16 22:20:36 +00:00
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
}
|
2008-03-25 17:47:12 +00:00
|
|
|
|
|
|
|
if (page_test_and_clear_young(page))
|
|
|
|
referenced++;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return referenced;
|
|
|
|
}
|
|
|
|
|
2006-09-26 06:30:57 +00:00
|
|
|
static int page_mkclean_one(struct page *page, struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = vma->vm_mm;
|
|
|
|
unsigned long address;
|
2006-12-22 13:25:52 +00:00
|
|
|
pte_t *pte;
|
2006-09-26 06:30:57 +00:00
|
|
|
spinlock_t *ptl;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
address = vma_address(page, vma);
|
|
|
|
if (address == -EFAULT)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
pte = page_check_address(page, mm, address, &ptl);
|
|
|
|
if (!pte)
|
|
|
|
goto out;
|
|
|
|
|
2006-12-22 13:25:52 +00:00
|
|
|
if (pte_dirty(*pte) || pte_write(*pte)) {
|
|
|
|
pte_t entry;
|
2006-09-26 06:30:57 +00:00
|
|
|
|
2006-12-22 13:25:52 +00:00
|
|
|
flush_cache_page(vma, address, pte_pfn(*pte));
|
|
|
|
entry = ptep_clear_flush(vma, address, pte);
|
|
|
|
entry = pte_wrprotect(entry);
|
|
|
|
entry = pte_mkclean(entry);
|
2006-12-30 00:48:35 +00:00
|
|
|
set_pte_at(mm, address, pte, entry);
|
2006-12-22 13:25:52 +00:00
|
|
|
ret = 1;
|
|
|
|
}
|
2006-09-26 06:30:57 +00:00
|
|
|
|
|
|
|
pte_unmap_unlock(pte, ptl);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int page_mkclean_file(struct address_space *mapping, struct page *page)
|
|
|
|
{
|
|
|
|
pgoff_t pgoff = page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
struct prio_tree_iter iter;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
BUG_ON(PageAnon(page));
|
|
|
|
|
|
|
|
spin_lock(&mapping->i_mmap_lock);
|
|
|
|
vma_prio_tree_foreach(vma, &iter, &mapping->i_mmap, pgoff, pgoff) {
|
|
|
|
if (vma->vm_flags & VM_SHARED)
|
|
|
|
ret += page_mkclean_one(page, vma);
|
|
|
|
}
|
|
|
|
spin_unlock(&mapping->i_mmap_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int page_mkclean(struct page *page)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
BUG_ON(!PageLocked(page));
|
|
|
|
|
|
|
|
if (page_mapped(page)) {
|
|
|
|
struct address_space *mapping = page_mapping(page);
|
2007-11-20 10:13:36 +00:00
|
|
|
if (mapping) {
|
2006-09-26 06:30:57 +00:00
|
|
|
ret = page_mkclean_file(mapping, page);
|
2007-11-20 10:13:36 +00:00
|
|
|
if (page_test_dirty(page)) {
|
|
|
|
page_clear_dirty(page);
|
|
|
|
ret = 1;
|
|
|
|
}
|
2007-04-27 14:01:57 +00:00
|
|
|
}
|
2006-09-26 06:30:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2007-05-08 07:37:37 +00:00
|
|
|
EXPORT_SYMBOL_GPL(page_mkclean);
|
2006-09-26 06:30:57 +00:00
|
|
|
|
2006-01-06 08:11:12 +00:00
|
|
|
/**
|
2008-03-20 00:00:43 +00:00
|
|
|
* __page_set_anon_rmap - setup new anonymous rmap
|
2006-01-06 08:11:12 +00:00
|
|
|
* @page: the page to add the mapping to
|
|
|
|
* @vma: the vm area in which the mapping is added
|
|
|
|
* @address: the user virtual address mapped
|
|
|
|
*/
|
|
|
|
static void __page_set_anon_rmap(struct page *page,
|
|
|
|
struct vm_area_struct *vma, unsigned long address)
|
|
|
|
{
|
|
|
|
struct anon_vma *anon_vma = vma->anon_vma;
|
|
|
|
|
|
|
|
BUG_ON(!anon_vma);
|
|
|
|
anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
|
|
|
|
page->mapping = (struct address_space *) anon_vma;
|
|
|
|
|
|
|
|
page->index = linear_page_index(vma, address);
|
|
|
|
|
2006-01-06 08:11:20 +00:00
|
|
|
/*
|
|
|
|
* nr_mapped state can be updated without turning off
|
|
|
|
* interrupts because it is not modified via interrupt.
|
|
|
|
*/
|
2006-06-30 08:55:36 +00:00
|
|
|
__inc_zone_page_state(page, NR_ANON_PAGES);
|
2006-01-06 08:11:12 +00:00
|
|
|
}
|
|
|
|
|
2007-05-17 05:11:21 +00:00
|
|
|
/**
|
2008-03-20 00:00:43 +00:00
|
|
|
* __page_check_anon_rmap - sanity check anonymous rmap addition
|
2007-05-17 05:11:21 +00:00
|
|
|
* @page: the page to add the mapping to
|
|
|
|
* @vma: the vm area in which the mapping is added
|
|
|
|
* @address: the user virtual address mapped
|
|
|
|
*/
|
|
|
|
static void __page_check_anon_rmap(struct page *page,
|
|
|
|
struct vm_area_struct *vma, unsigned long address)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_DEBUG_VM
|
|
|
|
/*
|
|
|
|
* The page's anon-rmap details (mapping and index) are guaranteed to
|
|
|
|
* be set up correctly at this point.
|
|
|
|
*
|
|
|
|
* We have exclusion against page_add_anon_rmap because the caller
|
|
|
|
* always holds the page locked, except if called from page_dup_rmap,
|
|
|
|
* in which case the page is already known to be setup.
|
|
|
|
*
|
|
|
|
* We have exclusion against page_add_new_anon_rmap because those pages
|
|
|
|
* are initially only visible via the pagetables, and the pte is locked
|
|
|
|
* over the call to page_add_new_anon_rmap.
|
|
|
|
*/
|
|
|
|
struct anon_vma *anon_vma = vma->anon_vma;
|
|
|
|
anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
|
|
|
|
BUG_ON(page->mapping != (struct address_space *)anon_vma);
|
|
|
|
BUG_ON(page->index != linear_page_index(vma, address));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* page_add_anon_rmap - add pte mapping to an anonymous page
|
|
|
|
* @page: the page to add the mapping to
|
|
|
|
* @vma: the vm area in which the mapping is added
|
|
|
|
* @address: the user virtual address mapped
|
|
|
|
*
|
2007-05-17 05:11:21 +00:00
|
|
|
* The caller needs to hold the pte lock and the page must be locked.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
void page_add_anon_rmap(struct page *page,
|
|
|
|
struct vm_area_struct *vma, unsigned long address)
|
|
|
|
{
|
2007-05-17 05:11:21 +00:00
|
|
|
VM_BUG_ON(!PageLocked(page));
|
|
|
|
VM_BUG_ON(address < vma->vm_start || address >= vma->vm_end);
|
2006-01-06 08:11:12 +00:00
|
|
|
if (atomic_inc_and_test(&page->_mapcount))
|
|
|
|
__page_set_anon_rmap(page, vma, address);
|
memcg: remove refcnt from page_cgroup
memcg: performance improvements
Patch Description
1/5 ... remove refcnt fron page_cgroup patch (shmem handling is fixed)
2/5 ... swapcache handling patch
3/5 ... add helper function for shmem's memory reclaim patch
4/5 ... optimize by likely/unlikely ppatch
5/5 ... remove redundunt check patch (shmem handling is fixed.)
Unix bench result.
== 2.6.26-rc2-mm1 + memory resource controller
Execl Throughput 2915.4 lps (29.6 secs, 3 samples)
C Compiler Throughput 1019.3 lpm (60.0 secs, 3 samples)
Shell Scripts (1 concurrent) 5796.0 lpm (60.0 secs, 3 samples)
Shell Scripts (8 concurrent) 1097.7 lpm (60.0 secs, 3 samples)
Shell Scripts (16 concurrent) 565.3 lpm (60.0 secs, 3 samples)
File Read 1024 bufsize 2000 maxblocks 1022128.0 KBps (30.0 secs, 3 samples)
File Write 1024 bufsize 2000 maxblocks 544057.0 KBps (30.0 secs, 3 samples)
File Copy 1024 bufsize 2000 maxblocks 346481.0 KBps (30.0 secs, 3 samples)
File Read 256 bufsize 500 maxblocks 319325.0 KBps (30.0 secs, 3 samples)
File Write 256 bufsize 500 maxblocks 148788.0 KBps (30.0 secs, 3 samples)
File Copy 256 bufsize 500 maxblocks 99051.0 KBps (30.0 secs, 3 samples)
File Read 4096 bufsize 8000 maxblocks 2058917.0 KBps (30.0 secs, 3 samples)
File Write 4096 bufsize 8000 maxblocks 1606109.0 KBps (30.0 secs, 3 samples)
File Copy 4096 bufsize 8000 maxblocks 854789.0 KBps (30.0 secs, 3 samples)
Dc: sqrt(2) to 99 decimal places 126145.2 lpm (30.0 secs, 3 samples)
INDEX VALUES
TEST BASELINE RESULT INDEX
Execl Throughput 43.0 2915.4 678.0
File Copy 1024 bufsize 2000 maxblocks 3960.0 346481.0 875.0
File Copy 256 bufsize 500 maxblocks 1655.0 99051.0 598.5
File Copy 4096 bufsize 8000 maxblocks 5800.0 854789.0 1473.8
Shell Scripts (8 concurrent) 6.0 1097.7 1829.5
=========
FINAL SCORE 991.3
== 2.6.26-rc2-mm1 + this set ==
Execl Throughput 3012.9 lps (29.9 secs, 3 samples)
C Compiler Throughput 981.0 lpm (60.0 secs, 3 samples)
Shell Scripts (1 concurrent) 5872.0 lpm (60.0 secs, 3 samples)
Shell Scripts (8 concurrent) 1120.3 lpm (60.0 secs, 3 samples)
Shell Scripts (16 concurrent) 578.0 lpm (60.0 secs, 3 samples)
File Read 1024 bufsize 2000 maxblocks 1003993.0 KBps (30.0 secs, 3 samples)
File Write 1024 bufsize 2000 maxblocks 550452.0 KBps (30.0 secs, 3 samples)
File Copy 1024 bufsize 2000 maxblocks 347159.0 KBps (30.0 secs, 3 samples)
File Read 256 bufsize 500 maxblocks 314644.0 KBps (30.0 secs, 3 samples)
File Write 256 bufsize 500 maxblocks 151852.0 KBps (30.0 secs, 3 samples)
File Copy 256 bufsize 500 maxblocks 101000.0 KBps (30.0 secs, 3 samples)
File Read 4096 bufsize 8000 maxblocks 2033256.0 KBps (30.0 secs, 3 samples)
File Write 4096 bufsize 8000 maxblocks 1611814.0 KBps (30.0 secs, 3 samples)
File Copy 4096 bufsize 8000 maxblocks 847979.0 KBps (30.0 secs, 3 samples)
Dc: sqrt(2) to 99 decimal places 128148.7 lpm (30.0 secs, 3 samples)
INDEX VALUES
TEST BASELINE RESULT INDEX
Execl Throughput 43.0 3012.9 700.7
File Copy 1024 bufsize 2000 maxblocks 3960.0 347159.0 876.7
File Copy 256 bufsize 500 maxblocks 1655.0 101000.0 610.3
File Copy 4096 bufsize 8000 maxblocks 5800.0 847979.0 1462.0
Shell Scripts (8 concurrent) 6.0 1120.3 1867.2
=========
FINAL SCORE 1004.6
This patch:
Remove refcnt from page_cgroup().
After this,
* A page is charged only when !page_mapped() && no page_cgroup is assigned.
* Anon page is newly mapped.
* File page is added to mapping->tree.
* A page is uncharged only when
* Anon page is fully unmapped.
* File page is removed from LRU.
There is no change in behavior from user's view.
This patch also removes unnecessary calls in rmap.c which was used only for
refcnt mangement.
[akpm@linux-foundation.org: fix warning]
[hugh@veritas.com: fix shmem_unuse_inode charging]
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: Pavel Emelyanov <xemul@openvz.org>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Hugh Dickins <hugh@veritas.com>
Cc: YAMAMOTO Takashi <yamamoto@valinux.co.jp>
Cc: Paul Menage <menage@google.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 08:47:14 +00:00
|
|
|
else
|
2007-05-17 05:11:21 +00:00
|
|
|
__page_check_anon_rmap(page, vma, address);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-20 00:00:43 +00:00
|
|
|
/**
|
2006-01-06 08:11:12 +00:00
|
|
|
* page_add_new_anon_rmap - add pte mapping to a new anonymous page
|
|
|
|
* @page: the page to add the mapping to
|
|
|
|
* @vma: the vm area in which the mapping is added
|
|
|
|
* @address: the user virtual address mapped
|
|
|
|
*
|
|
|
|
* Same as page_add_anon_rmap but must only be called on *new* pages.
|
|
|
|
* This means the inc-and-test can be bypassed.
|
2007-05-17 05:11:21 +00:00
|
|
|
* Page does not have to be locked.
|
2006-01-06 08:11:12 +00:00
|
|
|
*/
|
|
|
|
void page_add_new_anon_rmap(struct page *page,
|
|
|
|
struct vm_area_struct *vma, unsigned long address)
|
|
|
|
{
|
2007-05-17 05:11:21 +00:00
|
|
|
BUG_ON(address < vma->vm_start || address >= vma->vm_end);
|
2006-01-06 08:11:12 +00:00
|
|
|
atomic_set(&page->_mapcount, 0); /* elevate count by 1 (starts at -1) */
|
|
|
|
__page_set_anon_rmap(page, vma, address);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* page_add_file_rmap - add pte mapping to a file page
|
|
|
|
* @page: the page to add the mapping to
|
|
|
|
*
|
2005-10-30 01:16:41 +00:00
|
|
|
* The caller needs to hold the pte lock.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
void page_add_file_rmap(struct page *page)
|
|
|
|
{
|
|
|
|
if (atomic_inc_and_test(&page->_mapcount))
|
2006-06-30 08:55:34 +00:00
|
|
|
__inc_zone_page_state(page, NR_FILE_MAPPED);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-17 05:11:21 +00:00
|
|
|
#ifdef CONFIG_DEBUG_VM
|
|
|
|
/**
|
|
|
|
* page_dup_rmap - duplicate pte mapping to a page
|
|
|
|
* @page: the page to add the mapping to
|
2008-03-20 00:00:43 +00:00
|
|
|
* @vma: the vm area being duplicated
|
|
|
|
* @address: the user virtual address mapped
|
2007-05-17 05:11:21 +00:00
|
|
|
*
|
|
|
|
* For copy_page_range only: minimal extract from page_add_file_rmap /
|
|
|
|
* page_add_anon_rmap, avoiding unnecessary tests (already checked) so it's
|
|
|
|
* quicker.
|
|
|
|
*
|
|
|
|
* The caller needs to hold the pte lock.
|
|
|
|
*/
|
|
|
|
void page_dup_rmap(struct page *page, struct vm_area_struct *vma, unsigned long address)
|
|
|
|
{
|
|
|
|
BUG_ON(page_mapcount(page) == 0);
|
|
|
|
if (PageAnon(page))
|
|
|
|
__page_check_anon_rmap(page, vma, address);
|
|
|
|
atomic_inc(&page->_mapcount);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* page_remove_rmap - take down pte mapping from a page
|
|
|
|
* @page: page to remove mapping from
|
2008-03-20 00:00:43 +00:00
|
|
|
* @vma: the vm area in which the mapping is removed
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2005-10-30 01:16:41 +00:00
|
|
|
* The caller needs to hold the pte lock.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-12-22 09:09:33 +00:00
|
|
|
void page_remove_rmap(struct page *page, struct vm_area_struct *vma)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (atomic_add_negative(-1, &page->_mapcount)) {
|
2006-03-22 08:08:42 +00:00
|
|
|
if (unlikely(page_mapcount(page) < 0)) {
|
2006-01-08 09:01:00 +00:00
|
|
|
printk (KERN_EMERG "Eeek! page_mapcount(page) went negative! (%d)\n", page_mapcount(page));
|
2006-12-22 09:09:33 +00:00
|
|
|
printk (KERN_EMERG " page pfn = %lx\n", page_to_pfn(page));
|
2006-01-08 09:01:00 +00:00
|
|
|
printk (KERN_EMERG " page->flags = %lx\n", page->flags);
|
|
|
|
printk (KERN_EMERG " page->count = %x\n", page_count(page));
|
|
|
|
printk (KERN_EMERG " page->mapping = %p\n", page->mapping);
|
2006-12-22 09:09:33 +00:00
|
|
|
print_symbol (KERN_EMERG " vma->vm_ops = %s\n", (unsigned long)vma->vm_ops);
|
2007-07-19 08:46:59 +00:00
|
|
|
if (vma->vm_ops) {
|
|
|
|
print_symbol (KERN_EMERG " vma->vm_ops->fault = %s\n", (unsigned long)vma->vm_ops->fault);
|
|
|
|
}
|
2006-12-22 09:09:33 +00:00
|
|
|
if (vma->vm_file && vma->vm_file->f_op)
|
|
|
|
print_symbol (KERN_EMERG " vma->vm_file->f_op->mmap = %s\n", (unsigned long)vma->vm_file->f_op->mmap);
|
2006-10-11 08:21:27 +00:00
|
|
|
BUG();
|
2006-01-08 09:01:00 +00:00
|
|
|
}
|
2006-10-11 08:21:27 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* It would be tidy to reset the PageAnon mapping here,
|
|
|
|
* but that might overwrite a racing page_add_anon_rmap
|
|
|
|
* which increments mapcount after us but sets mapping
|
|
|
|
* before us: so leave the reset to free_hot_cold_page,
|
|
|
|
* and remember that it's only reliable while mapped.
|
|
|
|
* Leaving it set also helps swapoff to reinstate ptes
|
|
|
|
* faster for those pages still in swapcache.
|
|
|
|
*/
|
2007-04-27 14:01:57 +00:00
|
|
|
if (page_test_dirty(page)) {
|
|
|
|
page_clear_dirty(page);
|
2005-04-16 22:20:36 +00:00
|
|
|
set_page_dirty(page);
|
2007-04-27 14:01:57 +00:00
|
|
|
}
|
2008-02-07 08:13:53 +00:00
|
|
|
mem_cgroup_uncharge_page(page);
|
|
|
|
|
2006-06-30 08:55:36 +00:00
|
|
|
__dec_zone_page_state(page,
|
|
|
|
PageAnon(page) ? NR_ANON_PAGES : NR_FILE_MAPPED);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Subfunctions of try_to_unmap: try_to_unmap_one called
|
|
|
|
* repeatedly from either try_to_unmap_anon or try_to_unmap_file.
|
|
|
|
*/
|
2006-02-01 11:05:38 +00:00
|
|
|
static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
|
2006-06-23 09:03:27 +00:00
|
|
|
int migration)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mm_struct *mm = vma->vm_mm;
|
|
|
|
unsigned long address;
|
|
|
|
pte_t *pte;
|
|
|
|
pte_t pteval;
|
2005-10-30 01:16:31 +00:00
|
|
|
spinlock_t *ptl;
|
2005-04-16 22:20:36 +00:00
|
|
|
int ret = SWAP_AGAIN;
|
|
|
|
|
|
|
|
address = vma_address(page, vma);
|
|
|
|
if (address == -EFAULT)
|
|
|
|
goto out;
|
|
|
|
|
2005-10-30 01:16:31 +00:00
|
|
|
pte = page_check_address(page, mm, address, &ptl);
|
|
|
|
if (!pte)
|
2005-05-01 15:58:36 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the page is mlock()d, we cannot swap it out.
|
|
|
|
* If it's recently referenced (perhaps page_referenced
|
|
|
|
* skipped over this mm) then we should reactivate it.
|
|
|
|
*/
|
2006-06-25 12:46:49 +00:00
|
|
|
if (!migration && ((vma->vm_flags & VM_LOCKED) ||
|
|
|
|
(ptep_clear_flush_young(vma, address, pte)))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
ret = SWAP_FAIL;
|
|
|
|
goto out_unmap;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Nuke the page table entry. */
|
|
|
|
flush_cache_page(vma, address, page_to_pfn(page));
|
|
|
|
pteval = ptep_clear_flush(vma, address, pte);
|
|
|
|
|
|
|
|
/* Move the dirty bit to the physical page now the pte is gone. */
|
|
|
|
if (pte_dirty(pteval))
|
|
|
|
set_page_dirty(page);
|
|
|
|
|
[PATCH] mm: update_hiwaters just in time
update_mem_hiwater has attracted various criticisms, in particular from those
concerned with mm scalability. Originally it was called whenever rss or
total_vm got raised. Then many of those callsites were replaced by a timer
tick call from account_system_time. Now Frank van Maarseveen reports that to
be found inadequate. How about this? Works for Frank.
Replace update_mem_hiwater, a poor combination of two unrelated ops, by macros
update_hiwater_rss and update_hiwater_vm. Don't attempt to keep
mm->hiwater_rss up to date at timer tick, nor every time we raise rss (usually
by 1): those are hot paths. Do the opposite, update only when about to lower
rss (usually by many), or just before final accounting in do_exit. Handle
mm->hiwater_vm in the same way, though it's much less of an issue. Demand
that whoever collects these hiwater statistics do the work of taking the
maximum with rss or total_vm.
And there has been no collector of these hiwater statistics in the tree. The
new convention needs an example, so match Frank's usage by adding a VmPeak
line above VmSize to /proc/<pid>/status, and also a VmHWM line above VmRSS
(High-Water-Mark or High-Water-Memory).
There was a particular anomaly during mremap move, that hiwater_vm might be
captured too high. A fleeting such anomaly remains, but it's quickly
corrected now, whereas before it would stick.
What locking? None: if the app is racy then these statistics will be racy,
it's not worth any overhead to make them exact. But whenever it suits,
hiwater_vm is updated under exclusive mmap_sem, and hiwater_rss under
page_table_lock (for now) or with preemption disabled (later on): without
going to any trouble, minimize the time between reading current values and
updating, to minimize those occasions when a racing thread bumps a count up
and back down in between.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 01:16:18 +00:00
|
|
|
/* Update high watermark before we lower rss */
|
|
|
|
update_hiwater_rss(mm);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (PageAnon(page)) {
|
[PATCH] mm: split page table lock
Christoph Lameter demonstrated very poor scalability on the SGI 512-way, with
a many-threaded application which concurrently initializes different parts of
a large anonymous area.
This patch corrects that, by using a separate spinlock per page table page, to
guard the page table entries in that page, instead of using the mm's single
page_table_lock. (But even then, page_table_lock is still used to guard page
table allocation, and anon_vma allocation.)
In this implementation, the spinlock is tucked inside the struct page of the
page table page: with a BUILD_BUG_ON in case it overflows - which it would in
the case of 32-bit PA-RISC with spinlock debugging enabled.
Splitting the lock is not quite for free: another cacheline access. Ideally,
I suppose we would use split ptlock only for multi-threaded processes on
multi-cpu machines; but deciding that dynamically would have its own costs.
So for now enable it by config, at some number of cpus - since the Kconfig
language doesn't support inequalities, let preprocessor compare that with
NR_CPUS. But I don't think it's worth being user-configurable: for good
testing of both split and unsplit configs, split now at 4 cpus, and perhaps
change that to 8 later.
There is a benefit even for singly threaded processes: kswapd can be attacking
one part of the mm while another part is busy faulting.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 01:16:40 +00:00
|
|
|
swp_entry_t entry = { .val = page_private(page) };
|
[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 09:03:35 +00:00
|
|
|
|
|
|
|
if (PageSwapCache(page)) {
|
|
|
|
/*
|
|
|
|
* Store the swap location in the pte.
|
|
|
|
* See handle_pte_fault() ...
|
|
|
|
*/
|
|
|
|
swap_duplicate(entry);
|
|
|
|
if (list_empty(&mm->mmlist)) {
|
|
|
|
spin_lock(&mmlist_lock);
|
|
|
|
if (list_empty(&mm->mmlist))
|
|
|
|
list_add(&mm->mmlist, &init_mm.mmlist);
|
|
|
|
spin_unlock(&mmlist_lock);
|
|
|
|
}
|
2006-06-23 09:03:38 +00:00
|
|
|
dec_mm_counter(mm, anon_rss);
|
2006-06-23 09:03:38 +00:00
|
|
|
#ifdef CONFIG_MIGRATION
|
[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 09:03:35 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Store the pfn of the page in a special migration
|
|
|
|
* pte. do_swap_page() will wait until the migration
|
|
|
|
* pte is removed and then restart fault handling.
|
|
|
|
*/
|
|
|
|
BUG_ON(!migration);
|
|
|
|
entry = make_migration_entry(page, pte_write(pteval));
|
2006-06-23 09:03:38 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
set_pte_at(mm, address, pte, swp_entry_to_pte(entry));
|
|
|
|
BUG_ON(pte_file(*pte));
|
2005-10-30 01:16:05 +00:00
|
|
|
} else
|
2006-06-23 09:03:38 +00:00
|
|
|
#ifdef CONFIG_MIGRATION
|
|
|
|
if (migration) {
|
|
|
|
/* Establish migration entry for a file page */
|
|
|
|
swp_entry_t entry;
|
|
|
|
entry = make_migration_entry(page, pte_write(pteval));
|
|
|
|
set_pte_at(mm, address, pte, swp_entry_to_pte(entry));
|
|
|
|
} else
|
|
|
|
#endif
|
2005-10-30 01:16:05 +00:00
|
|
|
dec_mm_counter(mm, file_rss);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-23 09:03:38 +00:00
|
|
|
|
2006-12-22 09:09:33 +00:00
|
|
|
page_remove_rmap(page, vma);
|
2005-04-16 22:20:36 +00:00
|
|
|
page_cache_release(page);
|
|
|
|
|
|
|
|
out_unmap:
|
2005-10-30 01:16:31 +00:00
|
|
|
pte_unmap_unlock(pte, ptl);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* objrmap doesn't work for nonlinear VMAs because the assumption that
|
|
|
|
* offset-into-file correlates with offset-into-virtual-addresses does not hold.
|
|
|
|
* Consequently, given a particular page and its ->index, we cannot locate the
|
|
|
|
* ptes which are mapping that page without an exhaustive linear search.
|
|
|
|
*
|
|
|
|
* So what this code does is a mini "virtual scan" of each nonlinear VMA which
|
|
|
|
* maps the file to which the target page belongs. The ->vm_private_data field
|
|
|
|
* holds the current cursor into that scan. Successive searches will circulate
|
|
|
|
* around the vma's virtual address space.
|
|
|
|
*
|
|
|
|
* So as more replacement pressure is applied to the pages in a nonlinear VMA,
|
|
|
|
* more scanning pressure is placed against them as well. Eventually pages
|
|
|
|
* will become fully unmapped and are eligible for eviction.
|
|
|
|
*
|
|
|
|
* For very sparsely populated VMAs this is a little inefficient - chances are
|
|
|
|
* there there won't be many ptes located within the scan cluster. In this case
|
|
|
|
* maybe we could scan further - to the end of the pte page, perhaps.
|
|
|
|
*/
|
|
|
|
#define CLUSTER_SIZE min(32*PAGE_SIZE, PMD_SIZE)
|
|
|
|
#define CLUSTER_MASK (~(CLUSTER_SIZE - 1))
|
|
|
|
|
|
|
|
static void try_to_unmap_cluster(unsigned long cursor,
|
|
|
|
unsigned int *mapcount, struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = vma->vm_mm;
|
|
|
|
pgd_t *pgd;
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
2005-10-30 01:16:31 +00:00
|
|
|
pte_t *pte;
|
2005-04-16 22:20:36 +00:00
|
|
|
pte_t pteval;
|
2005-10-30 01:16:31 +00:00
|
|
|
spinlock_t *ptl;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct page *page;
|
|
|
|
unsigned long address;
|
|
|
|
unsigned long end;
|
|
|
|
|
|
|
|
address = (vma->vm_start + cursor) & CLUSTER_MASK;
|
|
|
|
end = address + CLUSTER_SIZE;
|
|
|
|
if (address < vma->vm_start)
|
|
|
|
address = vma->vm_start;
|
|
|
|
if (end > vma->vm_end)
|
|
|
|
end = vma->vm_end;
|
|
|
|
|
|
|
|
pgd = pgd_offset(mm, address);
|
|
|
|
if (!pgd_present(*pgd))
|
2005-10-30 01:16:31 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pud = pud_offset(pgd, address);
|
|
|
|
if (!pud_present(*pud))
|
2005-10-30 01:16:31 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pmd = pmd_offset(pud, address);
|
|
|
|
if (!pmd_present(*pmd))
|
2005-10-30 01:16:31 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
pte = pte_offset_map_lock(mm, pmd, address, &ptl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[PATCH] mm: update_hiwaters just in time
update_mem_hiwater has attracted various criticisms, in particular from those
concerned with mm scalability. Originally it was called whenever rss or
total_vm got raised. Then many of those callsites were replaced by a timer
tick call from account_system_time. Now Frank van Maarseveen reports that to
be found inadequate. How about this? Works for Frank.
Replace update_mem_hiwater, a poor combination of two unrelated ops, by macros
update_hiwater_rss and update_hiwater_vm. Don't attempt to keep
mm->hiwater_rss up to date at timer tick, nor every time we raise rss (usually
by 1): those are hot paths. Do the opposite, update only when about to lower
rss (usually by many), or just before final accounting in do_exit. Handle
mm->hiwater_vm in the same way, though it's much less of an issue. Demand
that whoever collects these hiwater statistics do the work of taking the
maximum with rss or total_vm.
And there has been no collector of these hiwater statistics in the tree. The
new convention needs an example, so match Frank's usage by adding a VmPeak
line above VmSize to /proc/<pid>/status, and also a VmHWM line above VmRSS
(High-Water-Mark or High-Water-Memory).
There was a particular anomaly during mremap move, that hiwater_vm might be
captured too high. A fleeting such anomaly remains, but it's quickly
corrected now, whereas before it would stick.
What locking? None: if the app is racy then these statistics will be racy,
it's not worth any overhead to make them exact. But whenever it suits,
hiwater_vm is updated under exclusive mmap_sem, and hiwater_rss under
page_table_lock (for now) or with preemption disabled (later on): without
going to any trouble, minimize the time between reading current values and
updating, to minimize those occasions when a racing thread bumps a count up
and back down in between.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 01:16:18 +00:00
|
|
|
/* Update high watermark before we lower rss */
|
|
|
|
update_hiwater_rss(mm);
|
|
|
|
|
2005-10-30 01:16:31 +00:00
|
|
|
for (; address < end; pte++, address += PAGE_SIZE) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!pte_present(*pte))
|
|
|
|
continue;
|
2005-11-28 22:34:23 +00:00
|
|
|
page = vm_normal_page(vma, address, *pte);
|
|
|
|
BUG_ON(!page || PageAnon(page));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (ptep_clear_flush_young(vma, address, pte))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Nuke the page table entry. */
|
2005-11-29 19:45:26 +00:00
|
|
|
flush_cache_page(vma, address, pte_pfn(*pte));
|
2005-04-16 22:20:36 +00:00
|
|
|
pteval = ptep_clear_flush(vma, address, pte);
|
|
|
|
|
|
|
|
/* If nonlinear, store the file page offset in the pte. */
|
|
|
|
if (page->index != linear_page_index(vma, address))
|
|
|
|
set_pte_at(mm, address, pte, pgoff_to_pte(page->index));
|
|
|
|
|
|
|
|
/* Move the dirty bit to the physical page now the pte is gone. */
|
|
|
|
if (pte_dirty(pteval))
|
|
|
|
set_page_dirty(page);
|
|
|
|
|
2006-12-22 09:09:33 +00:00
|
|
|
page_remove_rmap(page, vma);
|
2005-04-16 22:20:36 +00:00
|
|
|
page_cache_release(page);
|
2005-10-30 01:16:05 +00:00
|
|
|
dec_mm_counter(mm, file_rss);
|
2005-04-16 22:20:36 +00:00
|
|
|
(*mapcount)--;
|
|
|
|
}
|
2005-10-30 01:16:31 +00:00
|
|
|
pte_unmap_unlock(pte - 1, ptl);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-06-23 09:03:27 +00:00
|
|
|
static int try_to_unmap_anon(struct page *page, int migration)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct anon_vma *anon_vma;
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
int ret = SWAP_AGAIN;
|
|
|
|
|
|
|
|
anon_vma = page_lock_anon_vma(page);
|
|
|
|
if (!anon_vma)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
list_for_each_entry(vma, &anon_vma->head, anon_vma_node) {
|
2006-06-23 09:03:27 +00:00
|
|
|
ret = try_to_unmap_one(page, vma, migration);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret == SWAP_FAIL || !page_mapped(page))
|
|
|
|
break;
|
|
|
|
}
|
2007-03-01 04:13:49 +00:00
|
|
|
|
|
|
|
page_unlock_anon_vma(anon_vma);
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* try_to_unmap_file - unmap file page using the object-based rmap method
|
|
|
|
* @page: the page to unmap
|
2008-03-20 00:00:43 +00:00
|
|
|
* @migration: migration flag
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Find all the mappings of a page using the mapping pointer and the vma chains
|
|
|
|
* contained in the address_space struct it points to.
|
|
|
|
*
|
|
|
|
* This function is only called from try_to_unmap for object-based pages.
|
|
|
|
*/
|
2006-06-23 09:03:27 +00:00
|
|
|
static int try_to_unmap_file(struct page *page, int migration)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
pgoff_t pgoff = page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
struct prio_tree_iter iter;
|
|
|
|
int ret = SWAP_AGAIN;
|
|
|
|
unsigned long cursor;
|
|
|
|
unsigned long max_nl_cursor = 0;
|
|
|
|
unsigned long max_nl_size = 0;
|
|
|
|
unsigned int mapcount;
|
|
|
|
|
|
|
|
spin_lock(&mapping->i_mmap_lock);
|
|
|
|
vma_prio_tree_foreach(vma, &iter, &mapping->i_mmap, pgoff, pgoff) {
|
2006-06-23 09:03:27 +00:00
|
|
|
ret = try_to_unmap_one(page, vma, migration);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret == SWAP_FAIL || !page_mapped(page))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (list_empty(&mapping->i_mmap_nonlinear))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
list_for_each_entry(vma, &mapping->i_mmap_nonlinear,
|
|
|
|
shared.vm_set.list) {
|
2006-06-25 12:46:49 +00:00
|
|
|
if ((vma->vm_flags & VM_LOCKED) && !migration)
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
|
|
|
cursor = (unsigned long) vma->vm_private_data;
|
|
|
|
if (cursor > max_nl_cursor)
|
|
|
|
max_nl_cursor = cursor;
|
|
|
|
cursor = vma->vm_end - vma->vm_start;
|
|
|
|
if (cursor > max_nl_size)
|
|
|
|
max_nl_size = cursor;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (max_nl_size == 0) { /* any nonlinears locked or reserved */
|
|
|
|
ret = SWAP_FAIL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't try to search for this page in the nonlinear vmas,
|
|
|
|
* and page_referenced wouldn't have found it anyway. Instead
|
|
|
|
* just walk the nonlinear vmas trying to age and unmap some.
|
|
|
|
* The mapcount of the page we came in with is irrelevant,
|
|
|
|
* but even so use it as a guide to how hard we should try?
|
|
|
|
*/
|
|
|
|
mapcount = page_mapcount(page);
|
|
|
|
if (!mapcount)
|
|
|
|
goto out;
|
|
|
|
cond_resched_lock(&mapping->i_mmap_lock);
|
|
|
|
|
|
|
|
max_nl_size = (max_nl_size + CLUSTER_SIZE - 1) & CLUSTER_MASK;
|
|
|
|
if (max_nl_cursor == 0)
|
|
|
|
max_nl_cursor = CLUSTER_SIZE;
|
|
|
|
|
|
|
|
do {
|
|
|
|
list_for_each_entry(vma, &mapping->i_mmap_nonlinear,
|
|
|
|
shared.vm_set.list) {
|
2006-06-25 12:46:49 +00:00
|
|
|
if ((vma->vm_flags & VM_LOCKED) && !migration)
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
|
|
|
cursor = (unsigned long) vma->vm_private_data;
|
2005-09-03 22:54:43 +00:00
|
|
|
while ( cursor < max_nl_cursor &&
|
2005-04-16 22:20:36 +00:00
|
|
|
cursor < vma->vm_end - vma->vm_start) {
|
|
|
|
try_to_unmap_cluster(cursor, &mapcount, vma);
|
|
|
|
cursor += CLUSTER_SIZE;
|
|
|
|
vma->vm_private_data = (void *) cursor;
|
|
|
|
if ((int)mapcount <= 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
vma->vm_private_data = (void *) max_nl_cursor;
|
|
|
|
}
|
|
|
|
cond_resched_lock(&mapping->i_mmap_lock);
|
|
|
|
max_nl_cursor += CLUSTER_SIZE;
|
|
|
|
} while (max_nl_cursor <= max_nl_size);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't loop forever (perhaps all the remaining pages are
|
|
|
|
* in locked vmas). Reset cursor on all unreserved nonlinear
|
|
|
|
* vmas, now forgetting on which ones it had fallen behind.
|
|
|
|
*/
|
2005-11-22 05:32:16 +00:00
|
|
|
list_for_each_entry(vma, &mapping->i_mmap_nonlinear, shared.vm_set.list)
|
|
|
|
vma->vm_private_data = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
|
|
|
spin_unlock(&mapping->i_mmap_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* try_to_unmap - try to remove all page table mappings to a page
|
|
|
|
* @page: the page to get unmapped
|
2008-03-20 00:00:43 +00:00
|
|
|
* @migration: migration flag
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Tries to remove all the page table entries which are mapping this
|
|
|
|
* page, used in the pageout path. Caller must hold the page lock.
|
|
|
|
* Return values are:
|
|
|
|
*
|
|
|
|
* SWAP_SUCCESS - we succeeded in removing all mappings
|
|
|
|
* SWAP_AGAIN - we missed a mapping, try again later
|
|
|
|
* SWAP_FAIL - the page is unswappable
|
|
|
|
*/
|
2006-06-23 09:03:27 +00:00
|
|
|
int try_to_unmap(struct page *page, int migration)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
BUG_ON(!PageLocked(page));
|
|
|
|
|
|
|
|
if (PageAnon(page))
|
2006-06-23 09:03:27 +00:00
|
|
|
ret = try_to_unmap_anon(page, migration);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2006-06-23 09:03:27 +00:00
|
|
|
ret = try_to_unmap_file(page, migration);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!page_mapped(page))
|
|
|
|
ret = SWAP_SUCCESS;
|
|
|
|
return ret;
|
|
|
|
}
|
2005-05-01 15:58:36 +00:00
|
|
|
|