2005-04-17 02:20:36 +04:00
|
|
|
#ifndef _LINUX_SWAP_H
|
|
|
|
|
#define _LINUX_SWAP_H
|
|
|
|
|
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
#include <linux/linkage.h>
|
|
|
|
|
#include <linux/mmzone.h>
|
|
|
|
|
#include <linux/list.h>
|
2008-02-07 11:13:56 +03:00
|
|
|
#include <linux/memcontrol.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/sched.h>
|
2008-10-19 07:26:53 +04:00
|
|
|
#include <linux/node.h>
|
2005-07-13 00:58:31 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <asm/atomic.h>
|
|
|
|
|
#include <asm/page.h>
|
|
|
|
|
|
2006-09-26 10:31:20 +04:00
|
|
|
struct notifier_block;
|
|
|
|
|
|
2006-09-26 10:32:42 +04:00
|
|
|
struct bio;
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#define SWAP_FLAG_PREFER 0x8000 /* set if swap priority specified */
|
|
|
|
|
#define SWAP_FLAG_PRIO_MASK 0x7fff
|
|
|
|
|
#define SWAP_FLAG_PRIO_SHIFT 0
|
|
|
|
|
|
|
|
|
|
static inline int current_is_kswapd(void)
|
|
|
|
|
{
|
|
|
|
|
return current->flags & PF_KSWAPD;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* MAX_SWAPFILES defines the maximum number of swaptypes: things which can
|
|
|
|
|
* be swapped to. The swap type and the offset into that swap type are
|
|
|
|
|
* encoded into pte's and into pgoff_t's in the swapcache. Using five bits
|
|
|
|
|
* for the type means that the maximum number of swapcache pages is 27 bits
|
|
|
|
|
* on 32-bit-pgoff_t architectures. And that assumes that the architecture packs
|
|
|
|
|
* the type/offset into the pte as 5/27 as well.
|
|
|
|
|
*/
|
|
|
|
|
#define MAX_SWAPFILES_SHIFT 5
|
[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
|
|
|
#ifndef CONFIG_MIGRATION
|
2005-04-17 02:20:36 +04:00
|
|
|
#define MAX_SWAPFILES (1 << MAX_SWAPFILES_SHIFT)
|
[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
|
|
|
#else
|
|
|
|
|
/* Use last two entries for page migration swap entries */
|
|
|
|
|
#define MAX_SWAPFILES ((1 << MAX_SWAPFILES_SHIFT)-2)
|
|
|
|
|
#define SWP_MIGRATION_READ MAX_SWAPFILES
|
|
|
|
|
#define SWP_MIGRATION_WRITE (MAX_SWAPFILES + 1)
|
|
|
|
|
#endif
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Magic header for a swap area. The first part of the union is
|
|
|
|
|
* what the swap magic looks like for the old (limited to 128MB)
|
|
|
|
|
* swap area format, the second part of the union adds - in the
|
|
|
|
|
* old reserved area - some extra information. Note that the first
|
|
|
|
|
* kilobyte is reserved for boot loader or disk label stuff...
|
|
|
|
|
*
|
|
|
|
|
* Having the magic at the end of the PAGE_SIZE makes detecting swap
|
|
|
|
|
* areas somewhat tricky on machines that support multiple page sizes.
|
|
|
|
|
* For 2.5 we'll probably want to move the magic to just beyond the
|
|
|
|
|
* bootbits...
|
|
|
|
|
*/
|
|
|
|
|
union swap_header {
|
|
|
|
|
struct {
|
|
|
|
|
char reserved[PAGE_SIZE - 10];
|
|
|
|
|
char magic[10]; /* SWAP-SPACE or SWAPSPACE2 */
|
|
|
|
|
} magic;
|
|
|
|
|
struct {
|
2006-06-23 13:03:14 +04:00
|
|
|
char bootbits[1024]; /* Space for disklabel etc. */
|
|
|
|
|
__u32 version;
|
|
|
|
|
__u32 last_page;
|
|
|
|
|
__u32 nr_badpages;
|
|
|
|
|
unsigned char sws_uuid[16];
|
|
|
|
|
unsigned char sws_volume[16];
|
|
|
|
|
__u32 padding[117];
|
|
|
|
|
__u32 badpages[1];
|
2005-04-17 02:20:36 +04:00
|
|
|
} info;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* A swap entry has to fit into a "unsigned long", as
|
|
|
|
|
* the entry is hidden in the "index" field of the
|
|
|
|
|
* swapper address space.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct {
|
|
|
|
|
unsigned long val;
|
|
|
|
|
} swp_entry_t;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* current->reclaim_state points to one of these when a task is running
|
|
|
|
|
* memory reclaim
|
|
|
|
|
*/
|
|
|
|
|
struct reclaim_state {
|
|
|
|
|
unsigned long reclaimed_slab;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
|
|
|
|
|
struct address_space;
|
|
|
|
|
struct sysinfo;
|
|
|
|
|
struct writeback_control;
|
|
|
|
|
struct zone;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
|
|
|
|
|
* disk blocks. A list of swap extents maps the entire swapfile. (Where the
|
|
|
|
|
* term `swapfile' refers to either a blockdevice or an IS_REG file. Apart
|
|
|
|
|
* from setup, they're handled identically.
|
|
|
|
|
*
|
|
|
|
|
* We always assume that blocks are of size PAGE_SIZE.
|
|
|
|
|
*/
|
|
|
|
|
struct swap_extent {
|
|
|
|
|
struct list_head list;
|
|
|
|
|
pgoff_t start_page;
|
|
|
|
|
pgoff_t nr_pages;
|
|
|
|
|
sector_t start_block;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Max bad pages in the new format..
|
|
|
|
|
*/
|
|
|
|
|
#define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
|
|
|
|
|
#define MAX_SWAP_BADPAGES \
|
|
|
|
|
((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
SWP_USED = (1 << 0), /* is slot in swap_info[] used? */
|
|
|
|
|
SWP_WRITEOK = (1 << 1), /* ok to write to this swap? */
|
2009-01-07 01:39:51 +03:00
|
|
|
SWP_DISCARDABLE = (1 << 2), /* blkdev supports discard */
|
2009-01-07 01:39:53 +03:00
|
|
|
SWP_DISCARDING = (1 << 3), /* now discarding a free cluster */
|
2009-01-07 01:39:54 +03:00
|
|
|
SWP_SOLIDSTATE = (1 << 4), /* blkdev seeks are cheap */
|
[PATCH] swap: scan_swap_map drop swap_device_lock
get_swap_page has often shown up on latency traces, doing lengthy scans while
holding two spinlocks. swap_list_lock is already dropped, now scan_swap_map
drop swap_device_lock before scanning the swap_map.
While scanning for an empty cluster, don't worry that racing tasks may
allocate what was free and free what was allocated; but when allocating an
entry, check it's still free after retaking the lock. Avoid dropping the lock
in the expected common path. No barriers beyond the locks, just let the
cookie crumble; highest_bit limit is volatile, but benign.
Guard against swapoff: must check SWP_WRITEOK before allocating, must raise
SWP_SCANNING reference count while in scan_swap_map, swapoff wait for that to
fall - just use schedule_timeout, we don't want to burden scan_swap_map
itself, and it's very unlikely that anyone can really still be in
scan_swap_map once swapoff gets this far.
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-09-04 02:54:39 +04:00
|
|
|
/* add others here before... */
|
|
|
|
|
SWP_SCANNING = (1 << 8), /* refcount in scan_swap_map */
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define SWAP_CLUSTER_MAX 32
|
|
|
|
|
|
2009-06-17 02:32:53 +04:00
|
|
|
#define SWAP_MAP_MAX 0x7ffe
|
|
|
|
|
#define SWAP_MAP_BAD 0x7fff
|
|
|
|
|
#define SWAP_HAS_CACHE 0x8000 /* There is a swap cache of entry. */
|
|
|
|
|
#define SWAP_COUNT_MASK (~SWAP_HAS_CACHE)
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
|
* The in-memory structure used to track swap areas.
|
|
|
|
|
*/
|
|
|
|
|
struct swap_info_struct {
|
2009-01-07 01:39:50 +03:00
|
|
|
unsigned long flags;
|
[PATCH] swap: swap_lock replace list+device
The idea of a swap_device_lock per device, and a swap_list_lock over them all,
is appealing; but in practice almost every holder of swap_device_lock must
already hold swap_list_lock, which defeats the purpose of the split.
The only exceptions have been swap_duplicate, valid_swaphandles and an
untrodden path in try_to_unuse (plus a few places added in this series).
valid_swaphandles doesn't show up high in profiles, but swap_duplicate does
demand attention. However, with the hold time in get_swap_pages so much
reduced, I've not yet found a load and set of swap device priorities to show
even swap_duplicate benefitting from the split. Certainly the split is mere
overhead in the common case of a single swap device.
So, replace swap_list_lock and swap_device_lock by spinlock_t swap_lock
(generally we seem to prefer an _ in the name, and not hide in a macro).
If someone can show a regression in swap_duplicate, then probably we should
add a hashlock for the swap_map entries alone (shorts being anatomic), so as
to help the case of the single swap device too.
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-09-04 02:54:41 +04:00
|
|
|
int prio; /* swap priority */
|
2009-01-07 01:39:50 +03:00
|
|
|
int next; /* next entry on swap list */
|
2005-04-17 02:20:36 +04:00
|
|
|
struct file *swap_file;
|
|
|
|
|
struct block_device *bdev;
|
|
|
|
|
struct list_head extent_list;
|
|
|
|
|
struct swap_extent *curr_swap_extent;
|
2009-01-07 01:39:50 +03:00
|
|
|
unsigned short *swap_map;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int lowest_bit;
|
|
|
|
|
unsigned int highest_bit;
|
2009-01-07 01:39:53 +03:00
|
|
|
unsigned int lowest_alloc; /* while preparing discard cluster */
|
|
|
|
|
unsigned int highest_alloc; /* while preparing discard cluster */
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int cluster_next;
|
|
|
|
|
unsigned int cluster_nr;
|
2005-09-04 02:54:35 +04:00
|
|
|
unsigned int pages;
|
|
|
|
|
unsigned int max;
|
|
|
|
|
unsigned int inuse_pages;
|
2009-01-07 01:39:50 +03:00
|
|
|
unsigned int old_block_size;
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct swap_list_t {
|
|
|
|
|
int head; /* head of priority-ordered swapfile list */
|
|
|
|
|
int next; /* swapfile to be used next */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Swap 50% full? Release swapcache more aggressively.. */
|
|
|
|
|
#define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
|
|
|
|
|
|
|
|
|
|
/* linux/mm/page_alloc.c */
|
|
|
|
|
extern unsigned long totalram_pages;
|
2006-04-11 09:52:59 +04:00
|
|
|
extern unsigned long totalreserve_pages;
|
2005-04-17 02:20:36 +04:00
|
|
|
extern unsigned int nr_free_buffer_pages(void);
|
|
|
|
|
extern unsigned int nr_free_pagecache_pages(void);
|
|
|
|
|
|
2007-02-10 12:43:03 +03:00
|
|
|
/* Definition of global_page_state not available yet */
|
|
|
|
|
#define nr_free_pages() global_page_state(NR_FREE_PAGES)
|
|
|
|
|
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* linux/mm/swap.c */
|
2008-10-19 07:26:19 +04:00
|
|
|
extern void __lru_cache_add(struct page *, enum lru_list lru);
|
|
|
|
|
extern void lru_cache_add_lru(struct page *, enum lru_list lru);
|
2008-02-14 02:03:15 +03:00
|
|
|
extern void activate_page(struct page *);
|
|
|
|
|
extern void mark_page_accessed(struct page *);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void lru_add_drain(void);
|
2006-01-19 04:42:27 +03:00
|
|
|
extern int lru_add_drain_all(void);
|
2008-04-28 13:12:38 +04:00
|
|
|
extern void rotate_reclaimable_page(struct page *page);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void swap_setup(void);
|
|
|
|
|
|
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
|
|
|
extern void add_page_to_unevictable_list(struct page *page);
|
|
|
|
|
|
2008-10-19 07:26:19 +04:00
|
|
|
/**
|
|
|
|
|
* lru_cache_add: add a page to the page lists
|
|
|
|
|
* @page: the page to add
|
|
|
|
|
*/
|
2008-10-19 07:26:32 +04:00
|
|
|
static inline void lru_cache_add_anon(struct page *page)
|
2008-10-19 07:26:19 +04:00
|
|
|
{
|
2008-10-19 07:26:32 +04:00
|
|
|
__lru_cache_add(page, LRU_INACTIVE_ANON);
|
2008-10-19 07:26:19 +04:00
|
|
|
}
|
|
|
|
|
|
2008-10-19 07:26:32 +04:00
|
|
|
static inline void lru_cache_add_active_anon(struct page *page)
|
2008-10-19 07:26:19 +04:00
|
|
|
{
|
2008-10-19 07:26:32 +04:00
|
|
|
__lru_cache_add(page, LRU_ACTIVE_ANON);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void lru_cache_add_file(struct page *page)
|
|
|
|
|
{
|
|
|
|
|
__lru_cache_add(page, LRU_INACTIVE_FILE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void lru_cache_add_active_file(struct page *page)
|
|
|
|
|
{
|
|
|
|
|
__lru_cache_add(page, LRU_ACTIVE_FILE);
|
2008-10-19 07:26:19 +04:00
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* linux/mm/vmscan.c */
|
2008-04-28 13:12:12 +04:00
|
|
|
extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
|
2009-04-01 02:23:31 +04:00
|
|
|
gfp_t gfp_mask, nodemask_t *mask);
|
2008-02-07 11:14:02 +03:00
|
|
|
extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
|
2009-01-08 05:08:24 +03:00
|
|
|
gfp_t gfp_mask, bool noswap,
|
|
|
|
|
unsigned int swappiness);
|
2008-10-19 07:26:32 +04:00
|
|
|
extern int __isolate_lru_page(struct page *page, int mode, int file);
|
2006-03-22 11:08:19 +03:00
|
|
|
extern unsigned long shrink_all_memory(unsigned long nr_pages);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern int vm_swappiness;
|
2006-03-22 11:09:12 +03:00
|
|
|
extern int remove_mapping(struct address_space *mapping, struct page *page);
|
2006-06-23 13:03:47 +04:00
|
|
|
extern long vm_total_pages;
|
2006-03-22 11:09:12 +03:00
|
|
|
|
2006-01-19 04:42:31 +03:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
|
extern int zone_reclaim_mode;
|
2006-07-03 11:24:13 +04:00
|
|
|
extern int sysctl_min_unmapped_ratio;
|
2006-09-26 10:31:52 +04:00
|
|
|
extern int sysctl_min_slab_ratio;
|
2006-01-19 04:42:31 +03:00
|
|
|
extern int zone_reclaim(struct zone *, gfp_t, unsigned int);
|
|
|
|
|
#else
|
|
|
|
|
#define zone_reclaim_mode 0
|
|
|
|
|
static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
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
|
|
|
extern int page_evictable(struct page *page, struct vm_area_struct *vma);
|
2008-10-19 07:26:43 +04:00
|
|
|
extern void scan_mapping_unevictable_pages(struct address_space *);
|
2008-10-19 07:26:53 +04:00
|
|
|
|
|
|
|
|
extern unsigned long scan_unevictable_pages;
|
|
|
|
|
extern int scan_unevictable_handler(struct ctl_table *, int, struct file *,
|
|
|
|
|
void __user *, size_t *, loff_t *);
|
|
|
|
|
extern int scan_unevictable_register_node(struct node *node);
|
|
|
|
|
extern void scan_unevictable_unregister_node(struct node *node);
|
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
|
|
|
|
2006-06-27 13:53:33 +04:00
|
|
|
extern int kswapd_run(int nid);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#ifdef CONFIG_MMU
|
|
|
|
|
/* linux/mm/shmem.c */
|
|
|
|
|
extern int shmem_unuse(swp_entry_t entry, struct page *page);
|
|
|
|
|
#endif /* CONFIG_MMU */
|
|
|
|
|
|
|
|
|
|
extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SWAP
|
|
|
|
|
/* linux/mm/page_io.c */
|
|
|
|
|
extern int swap_readpage(struct file *, struct page *);
|
|
|
|
|
extern int swap_writepage(struct page *page, struct writeback_control *wbc);
|
2007-09-27 14:47:43 +04:00
|
|
|
extern void end_swap_bio_read(struct bio *bio, int err);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
|
/* linux/mm/swap_state.c */
|
|
|
|
|
extern struct address_space swapper_space;
|
|
|
|
|
#define total_swapcache_pages swapper_space.nrpages
|
|
|
|
|
extern void show_swap_cache_info(void);
|
2009-01-07 01:39:39 +03:00
|
|
|
extern int add_to_swap(struct page *);
|
2008-02-05 09:28:50 +03:00
|
|
|
extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void __delete_from_swap_cache(struct page *);
|
|
|
|
|
extern void delete_from_swap_cache(struct page *);
|
|
|
|
|
extern void free_page_and_swap_cache(struct page *);
|
|
|
|
|
extern void free_pages_and_swap_cache(struct page **, int);
|
2008-02-05 09:28:41 +03:00
|
|
|
extern struct page *lookup_swap_cache(swp_entry_t);
|
swapin needs gfp_mask for loop on tmpfs
Building in a filesystem on a loop device on a tmpfs file can hang when
swapping, the loop thread caught in that infamous throttle_vm_writeout.
In theory this is a long standing problem, which I've either never seen in
practice, or long ago suppressed the recollection, after discounting my load
and my tmpfs size as unrealistically high. But now, with the new aops, it has
become easy to hang on one machine.
Loop used to grab_cache_page before the old prepare_write to tmpfs, which
seems to have been enough to free up some memory for any swapin needed; but
the new write_begin lets tmpfs find or allocate the page (much nicer, since
grab_cache_page missed tmpfs pages in swapcache).
When allocating a fresh page, tmpfs respects loop's mapping_gfp_mask, which
has __GFP_IO|__GFP_FS stripped off, and throttle_vm_writeout is designed to
break out when __GFP_IO or GFP_FS is unset; but when tmfps swaps in,
read_swap_cache_async allocates with GFP_HIGHUSER_MOVABLE regardless of the
mapping_gfp_mask - hence the hang.
So, pass gfp_mask down the line from shmem_getpage to shmem_swapin to
swapin_readahead to read_swap_cache_async to add_to_swap_cache.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Rik van Riel <riel@redhat.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-05 09:28:42 +03:00
|
|
|
extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
|
2008-02-05 09:28:41 +03:00
|
|
|
struct vm_area_struct *vma, unsigned long addr);
|
swapin needs gfp_mask for loop on tmpfs
Building in a filesystem on a loop device on a tmpfs file can hang when
swapping, the loop thread caught in that infamous throttle_vm_writeout.
In theory this is a long standing problem, which I've either never seen in
practice, or long ago suppressed the recollection, after discounting my load
and my tmpfs size as unrealistically high. But now, with the new aops, it has
become easy to hang on one machine.
Loop used to grab_cache_page before the old prepare_write to tmpfs, which
seems to have been enough to free up some memory for any swapin needed; but
the new write_begin lets tmpfs find or allocate the page (much nicer, since
grab_cache_page missed tmpfs pages in swapcache).
When allocating a fresh page, tmpfs respects loop's mapping_gfp_mask, which
has __GFP_IO|__GFP_FS stripped off, and throttle_vm_writeout is designed to
break out when __GFP_IO or GFP_FS is unset; but when tmfps swaps in,
read_swap_cache_async allocates with GFP_HIGHUSER_MOVABLE regardless of the
mapping_gfp_mask - hence the hang.
So, pass gfp_mask down the line from shmem_getpage to shmem_swapin to
swapin_readahead to read_swap_cache_async to add_to_swap_cache.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Rik van Riel <riel@redhat.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-05 09:28:42 +03:00
|
|
|
extern struct page *swapin_readahead(swp_entry_t, gfp_t,
|
2008-02-05 09:28:41 +03:00
|
|
|
struct vm_area_struct *vma, unsigned long addr);
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* linux/mm/swapfile.c */
|
2009-01-07 01:39:41 +03:00
|
|
|
extern long nr_swap_pages;
|
2005-04-17 02:20:36 +04:00
|
|
|
extern long total_swap_pages;
|
|
|
|
|
extern void si_swapinfo(struct sysinfo *);
|
|
|
|
|
extern swp_entry_t get_swap_page(void);
|
2006-03-23 13:59:59 +03:00
|
|
|
extern swp_entry_t get_swap_page_of_type(int);
|
2009-06-17 02:32:53 +04:00
|
|
|
extern void swap_duplicate(swp_entry_t);
|
2009-06-17 02:32:52 +04:00
|
|
|
extern int swapcache_prepare(swp_entry_t);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern int valid_swaphandles(swp_entry_t, unsigned long *);
|
|
|
|
|
extern void swap_free(swp_entry_t);
|
2009-06-17 02:32:52 +04:00
|
|
|
extern void swapcache_free(swp_entry_t, struct page *page);
|
2009-01-07 01:40:10 +03:00
|
|
|
extern int free_swap_and_cache(swp_entry_t);
|
2007-01-06 03:36:28 +03:00
|
|
|
extern int swap_type_of(dev_t, sector_t, struct block_device **);
|
2006-03-23 13:59:59 +03:00
|
|
|
extern unsigned int count_swap_pages(int, int);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
|
2006-12-07 07:34:10 +03:00
|
|
|
extern sector_t swapdev_block(int, pgoff_t);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern struct swap_info_struct *get_swap_info_struct(unsigned);
|
2009-01-07 01:39:34 +03:00
|
|
|
extern int reuse_swap_page(struct page *);
|
2009-01-07 01:39:36 +03:00
|
|
|
extern int try_to_free_swap(struct page *);
|
2005-04-17 02:20:36 +04:00
|
|
|
struct backing_dev_info;
|
|
|
|
|
|
|
|
|
|
/* linux/mm/thrash.c */
|
|
|
|
|
extern struct mm_struct * swap_token_mm;
|
|
|
|
|
extern void grab_swap_token(void);
|
|
|
|
|
extern void __put_swap_token(struct mm_struct *);
|
|
|
|
|
|
|
|
|
|
static inline int has_swap_token(struct mm_struct *mm)
|
|
|
|
|
{
|
|
|
|
|
return (mm == swap_token_mm);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void put_swap_token(struct mm_struct *mm)
|
|
|
|
|
{
|
|
|
|
|
if (has_swap_token(mm))
|
|
|
|
|
__put_swap_token(mm);
|
|
|
|
|
}
|
|
|
|
|
|
2005-11-29 00:44:07 +03:00
|
|
|
static inline void disable_swap_token(void)
|
|
|
|
|
{
|
|
|
|
|
put_swap_token(swap_token_mm);
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-08 05:07:56 +03:00
|
|
|
#ifdef CONFIG_CGROUP_MEM_RES_CTLR
|
2009-01-08 05:08:00 +03:00
|
|
|
extern void mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent);
|
2009-01-08 05:07:56 +03:00
|
|
|
#else
|
2009-01-08 05:08:00 +03:00
|
|
|
static inline void
|
|
|
|
|
mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
|
|
|
|
|
extern void mem_cgroup_uncharge_swap(swp_entry_t ent);
|
|
|
|
|
#else
|
|
|
|
|
static inline void mem_cgroup_uncharge_swap(swp_entry_t ent)
|
2009-01-08 05:07:56 +03:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#else /* CONFIG_SWAP */
|
|
|
|
|
|
2009-01-07 01:39:41 +03:00
|
|
|
#define nr_swap_pages 0L
|
|
|
|
|
#define total_swap_pages 0L
|
2005-04-17 02:20:36 +04:00
|
|
|
#define total_swapcache_pages 0UL
|
|
|
|
|
|
|
|
|
|
#define si_swapinfo(val) \
|
|
|
|
|
do { (val)->freeswap = (val)->totalswap = 0; } while (0)
|
2005-08-07 20:42:24 +04:00
|
|
|
/* only sparc can not include linux/pagemap.h in this file
|
|
|
|
|
* so leave page_cache_release and release_pages undeclared... */
|
2005-04-17 02:20:36 +04:00
|
|
|
#define free_page_and_swap_cache(page) \
|
|
|
|
|
page_cache_release(page)
|
|
|
|
|
#define free_pages_and_swap_cache(pages, nr) \
|
|
|
|
|
release_pages((pages), (nr), 0);
|
|
|
|
|
|
2006-06-23 13:03:42 +04:00
|
|
|
static inline void show_swap_cache_info(void)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-07 01:40:10 +03:00
|
|
|
#define free_swap_and_cache(swp) is_migration_entry(swp)
|
2009-06-17 02:32:52 +04:00
|
|
|
#define swapcache_prepare(swp) is_migration_entry(swp)
|
2006-06-23 13:03:42 +04:00
|
|
|
|
2009-06-17 02:32:53 +04:00
|
|
|
static inline void swap_duplicate(swp_entry_t swp)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-23 13:03:42 +04:00
|
|
|
static inline void swap_free(swp_entry_t swp)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-17 02:32:52 +04:00
|
|
|
static inline void swapcache_free(swp_entry_t swp, struct page *page)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
swapin needs gfp_mask for loop on tmpfs
Building in a filesystem on a loop device on a tmpfs file can hang when
swapping, the loop thread caught in that infamous throttle_vm_writeout.
In theory this is a long standing problem, which I've either never seen in
practice, or long ago suppressed the recollection, after discounting my load
and my tmpfs size as unrealistically high. But now, with the new aops, it has
become easy to hang on one machine.
Loop used to grab_cache_page before the old prepare_write to tmpfs, which
seems to have been enough to free up some memory for any swapin needed; but
the new write_begin lets tmpfs find or allocate the page (much nicer, since
grab_cache_page missed tmpfs pages in swapcache).
When allocating a fresh page, tmpfs respects loop's mapping_gfp_mask, which
has __GFP_IO|__GFP_FS stripped off, and throttle_vm_writeout is designed to
break out when __GFP_IO or GFP_FS is unset; but when tmfps swaps in,
read_swap_cache_async allocates with GFP_HIGHUSER_MOVABLE regardless of the
mapping_gfp_mask - hence the hang.
So, pass gfp_mask down the line from shmem_getpage to shmem_swapin to
swapin_readahead to read_swap_cache_async to add_to_swap_cache.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Rik van Riel <riel@redhat.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-05 09:28:42 +03:00
|
|
|
static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
|
2006-06-23 13:03:42 +04:00
|
|
|
struct vm_area_struct *vma, unsigned long addr)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
shmem: writepage directly to swap
Synopsis: if shmem_writepage calls swap_writepage directly, most shmem
swap loads benefit, and a catastrophic interaction between SLUB and some
flash storage is avoided.
shmem_writepage() has always been peculiar in making no attempt to write:
it has just transferred a shmem page from file cache to swap cache, then
let that page make its way around the LRU again before being written and
freed.
The idea was that people use tmpfs because they want those pages to stay
in RAM; so although we give it an overflow to swap, we should resist
writing too soon, giving those pages a second chance before they can be
reclaimed.
That was always questionable, and I've toyed with this patch for years;
but never had a clear justification to depart from the original design.
It became more questionable in 2.6.28, when the split LRU patches classed
shmem and tmpfs pages as SwapBacked rather than as file_cache: that in
itself gives them more resistance to reclaim than normal file pages. I
prepared this patch for 2.6.29, but the merge window arrived before I'd
completed gathering statistics to justify sending it in.
Then while comparing SLQB against SLUB, running SLUB on a laptop I'd
habitually used with SLAB, I found SLUB to run my tmpfs kbuild swapping
tests five times slower than SLAB or SLQB - other machines slower too, but
nowhere near so bad. Simpler "cp -a" swapping tests showed the same.
slub_max_order=0 brings sanity to all, but heavy swapping is too far from
normal to justify such a tuning. The crucial factor on that laptop turns
out to be that I'm using an SD card for swap. What happens is this:
By default, SLUB uses order-2 pages for shmem_inode_cache (and many other
fs inodes), so creating tmpfs files under memory pressure brings lumpy
reclaim into play. One subpage of the order is chosen from the bottom of
the LRU as usual, then the other three picked out from their random
positions on the LRUs.
In a tmpfs load, many of these pages will be ones which already passed
through shmem_writepage, so already have swap allocated. And though their
offsets on swap were probably allocated sequentially, now that the pages
are picked off at random, their swap offsets are scattered.
But the flash storage on the SD card is very sensitive to having its
writes merged: once swap is written at scattered offsets, performance
falls apart. Rotating disk seeks increase too, but less disastrously.
So: stop giving shmem/tmpfs pages a second pass around the LRU, write them
out to swap as soon as their swap has been allocated.
It's surely possible to devise an artificial load which runs faster the
old way, one whose sizing is such that the tmpfs pages on their second
pass are the ones that are wanted again, and other pages not.
But I've not yet found such a load: on all machines, under the loads I've
tried, immediate swap_writepage speeds up shmem swapping: especially when
using the SLUB allocator (and more effectively than slub_max_order=0), but
also with the others; and it also reduces the variance between runs. How
much faster varies widely: a factor of five is rare, 5% is common.
One load which might have suffered: imagine a swapping shmem load in a
limited mem_cgroup on a machine with plenty of memory. Before 2.6.29 the
swapcache was not charged, and such a load would have run quickest with
the shmem swapcache never written to swap. But now swapcache is charged,
so even this load benefits from shmem_writepage directly to swap.
Apologies for the #ifndef CONFIG_SWAP swap_writepage() stub in swap.h:
it's silly because that will never get called; but refactoring shmem.c
sensibly according to CONFIG_SWAP will be a separate task.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Pekka Enberg <penberg@cs.helsinki.fi>
Acked-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-01 02:23:33 +04:00
|
|
|
static inline int swap_writepage(struct page *p, struct writeback_control *wbc)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-23 13:03:42 +04:00
|
|
|
static inline struct page *lookup_swap_cache(swp_entry_t swp)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-07 01:39:40 +03:00
|
|
|
static inline int add_to_swap(struct page *page)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-05 09:28:50 +03:00
|
|
|
static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
|
|
|
|
|
gfp_t gfp_mask)
|
2006-06-23 13:03:42 +04:00
|
|
|
{
|
2008-02-05 09:28:50 +03:00
|
|
|
return -1;
|
2006-06-23 13:03:42 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void __delete_from_swap_cache(struct page *page)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void delete_from_swap_cache(struct page *page)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-07 01:39:34 +03:00
|
|
|
#define reuse_swap_page(page) (page_mapcount(page) == 1)
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-01-07 01:39:36 +03:00
|
|
|
static inline int try_to_free_swap(struct page *page)
|
2008-10-19 07:26:23 +04:00
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static inline swp_entry_t get_swap_page(void)
|
|
|
|
|
{
|
|
|
|
|
swp_entry_t entry;
|
|
|
|
|
entry.val = 0;
|
|
|
|
|
return entry;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* linux/mm/thrash.c */
|
|
|
|
|
#define put_swap_token(x) do { } while(0)
|
|
|
|
|
#define grab_swap_token() do { } while(0)
|
|
|
|
|
#define has_swap_token(x) 0
|
2005-11-29 00:44:07 +03:00
|
|
|
#define disable_swap_token() do { } while(0)
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-01-08 05:07:56 +03:00
|
|
|
static inline int mem_cgroup_cache_charge_swapin(struct page *page,
|
|
|
|
|
struct mm_struct *mm, gfp_t mask, bool locked)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-29 01:34:28 +04:00
|
|
|
static inline void
|
|
|
|
|
mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif /* CONFIG_SWAP */
|
|
|
|
|
#endif /* __KERNEL__*/
|
|
|
|
|
#endif /* _LINUX_SWAP_H */
|
