Skip to content

Commit

Permalink
swap_info: SWAP_HAS_CACHE cleanups
Browse files Browse the repository at this point in the history 
Though swap_count() is useful, I'm finding that swap_has_cache() and
encode_swapmap() obscure what happens in the swap_map entry, just at
those points where I need to understand it.  Remove them, and pass
more usable "usage" values to scan_swap_map(), swap_entry_free() and
__swap_duplicate(), instead of the SWAP_MAP and SWAP_CACHE enum.

Signed-off-by: Hugh Dickins <hugh.dickins@tiscali.co.uk>
Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
  • Loading branch information
Hugh Dickins authored and Linus Torvalds committed Dec 15, 2009
1 parent 73c34b6 commit 253d553
Show file tree
Hide file tree
Showing 2 changed files with 65 additions and 92 deletions.
2 changes: 1 addition & 1 deletion include/linux/swap.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -154,7 +154,7 @@ enum {
#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)

/*
* The in-memory structure used to track swap areas.
*/
Expand Down
155 changes: 64 additions & 91 deletions mm/swapfile.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -53,30 +53,9 @@ static struct swap_info_struct *swap_info[MAX_SWAPFILES];

static DEFINE_MUTEX(swapon_mutex);

/* For reference count accounting in swap_map */
/* enum for swap_map[] handling. internal use only */
enum {
SWAP_MAP = 0, /* ops for reference from swap users */
SWAP_CACHE, /* ops for reference from swap cache */
};

static inline int swap_count(unsigned short ent)
{
return ent & SWAP_COUNT_MASK;
}

static inline bool swap_has_cache(unsigned short ent)
{
return !!(ent & SWAP_HAS_CACHE);
}

static inline unsigned short encode_swapmap(int count, bool has_cache)
{
unsigned short ret = count;

if (has_cache)
return SWAP_HAS_CACHE | ret;
return ret;
return ent & ~SWAP_HAS_CACHE;
}

/* returns 1 if swap entry is freed */
Expand Down Expand Up @@ -224,7 +203,7 @@ static int wait_for_discard(void *word)
#define LATENCY_LIMIT 256

static inline unsigned long scan_swap_map(struct swap_info_struct *si,
int cache)
unsigned short usage)
{
unsigned long offset;
unsigned long scan_base;
Expand Down Expand Up @@ -355,10 +334,7 @@ static inline unsigned long scan_swap_map(struct swap_info_struct *si,
si->lowest_bit = si->max;
si->highest_bit = 0;
}
if (cache == SWAP_CACHE) /* at usual swap-out via vmscan.c */
si->swap_map[offset] = encode_swapmap(0, true);
else /* at suspend */
si->swap_map[offset] = encode_swapmap(1, false);
si->swap_map[offset] = usage;
si->cluster_next = offset + 1;
si->flags -= SWP_SCANNING;

Expand Down Expand Up @@ -483,7 +459,7 @@ swp_entry_t get_swap_page(void)

swap_list.next = next;
/* This is called for allocating swap entry for cache */
offset = scan_swap_map(si, SWAP_CACHE);
offset = scan_swap_map(si, SWAP_HAS_CACHE);
if (offset) {
spin_unlock(&swap_lock);
return swp_entry(type, offset);
Expand All @@ -508,7 +484,7 @@ swp_entry_t get_swap_page_of_type(int type)
if (si && (si->flags & SWP_WRITEOK)) {
nr_swap_pages--;
/* This is called for allocating swap entry, not cache */
offset = scan_swap_map(si, SWAP_MAP);
offset = scan_swap_map(si, 1);
if (offset) {
spin_unlock(&swap_lock);
return swp_entry(type, offset);
Expand Down Expand Up @@ -555,29 +531,31 @@ static struct swap_info_struct *swap_info_get(swp_entry_t entry)
return NULL;
}

static int swap_entry_free(struct swap_info_struct *p,
swp_entry_t ent, int cache)
static unsigned short swap_entry_free(struct swap_info_struct *p,
swp_entry_t entry, unsigned short usage)
{
unsigned long offset = swp_offset(ent);
int count = swap_count(p->swap_map[offset]);
bool has_cache;
unsigned long offset = swp_offset(entry);
unsigned short count;
unsigned short has_cache;

has_cache = swap_has_cache(p->swap_map[offset]);
count = p->swap_map[offset];
has_cache = count & SWAP_HAS_CACHE;
count &= ~SWAP_HAS_CACHE;

if (cache == SWAP_MAP) { /* dropping usage count of swap */
if (count < SWAP_MAP_MAX) {
count--;
p->swap_map[offset] = encode_swapmap(count, has_cache);
}
} else { /* dropping swap cache flag */
if (usage == SWAP_HAS_CACHE) {
VM_BUG_ON(!has_cache);
p->swap_map[offset] = encode_swapmap(count, false);
has_cache = 0;
} else if (count < SWAP_MAP_MAX)
count--;

if (!count)
mem_cgroup_uncharge_swap(entry);

usage = count | has_cache;
p->swap_map[offset] = usage;

}
/* return code. */
count = p->swap_map[offset];
/* free if no reference */
if (!count) {
if (!usage) {
if (offset < p->lowest_bit)
p->lowest_bit = offset;
if (offset > p->highest_bit)
Expand All @@ -588,9 +566,8 @@ static int swap_entry_free(struct swap_info_struct *p,
nr_swap_pages++;
p->inuse_pages--;
}
if (!swap_count(count))
mem_cgroup_uncharge_swap(ent);
return count;

return usage;
}

/*
Expand All @@ -603,7 +580,7 @@ void swap_free(swp_entry_t entry)

p = swap_info_get(entry);
if (p) {
swap_entry_free(p, entry, SWAP_MAP);
swap_entry_free(p, entry, 1);
spin_unlock(&swap_lock);
}
}
Expand All @@ -614,19 +591,13 @@ void swap_free(swp_entry_t entry)
void swapcache_free(swp_entry_t entry, struct page *page)
{
struct swap_info_struct *p;
int ret;
unsigned short count;

p = swap_info_get(entry);
if (p) {
ret = swap_entry_free(p, entry, SWAP_CACHE);
if (page) {
bool swapout;
if (ret)
swapout = true; /* the end of swap out */
else
swapout = false; /* no more swap users! */
mem_cgroup_uncharge_swapcache(page, entry, swapout);
}
count = swap_entry_free(p, entry, SWAP_HAS_CACHE);
if (page)
mem_cgroup_uncharge_swapcache(page, entry, count != 0);
spin_unlock(&swap_lock);
}
}
Expand Down Expand Up @@ -705,7 +676,7 @@ int free_swap_and_cache(swp_entry_t entry)

p = swap_info_get(entry);
if (p) {
if (swap_entry_free(p, entry, SWAP_MAP) == SWAP_HAS_CACHE) {
if (swap_entry_free(p, entry, 1) == SWAP_HAS_CACHE) {
page = find_get_page(&swapper_space, entry.val);
if (page && !trylock_page(page)) {
page_cache_release(page);
Expand Down Expand Up @@ -1212,7 +1183,7 @@ static int try_to_unuse(unsigned int type)

if (swap_count(*swap_map) == SWAP_MAP_MAX) {
spin_lock(&swap_lock);
*swap_map = encode_swapmap(0, true);
*swap_map = SWAP_HAS_CACHE;
spin_unlock(&swap_lock);
reset_overflow = 1;
}
Expand Down Expand Up @@ -2111,16 +2082,16 @@ void si_swapinfo(struct sysinfo *val)
* - swap-cache reference is requested but there is already one. -> EEXIST
* - swap-cache reference is requested but the entry is not used. -> ENOENT
*/
static int __swap_duplicate(swp_entry_t entry, bool cache)
static int __swap_duplicate(swp_entry_t entry, unsigned short usage)
{
struct swap_info_struct *p;
unsigned long offset, type;
int result = -EINVAL;
int count;
bool has_cache;
unsigned short count;
unsigned short has_cache;
int err = -EINVAL;

if (non_swap_entry(entry))
return -EINVAL;
goto out;

type = swp_type(entry);
if (type >= nr_swapfiles)
Expand All @@ -2129,54 +2100,56 @@ static int __swap_duplicate(swp_entry_t entry, bool cache)
offset = swp_offset(entry);

spin_lock(&swap_lock);

if (unlikely(offset >= p->max))
goto unlock_out;

count = swap_count(p->swap_map[offset]);
has_cache = swap_has_cache(p->swap_map[offset]);
count = p->swap_map[offset];
has_cache = count & SWAP_HAS_CACHE;
count &= ~SWAP_HAS_CACHE;
err = 0;

if (cache == SWAP_CACHE) { /* called for swapcache/swapin-readahead */
if (usage == SWAP_HAS_CACHE) {

/* set SWAP_HAS_CACHE if there is no cache and entry is used */
if (!has_cache && count) {
p->swap_map[offset] = encode_swapmap(count, true);
result = 0;
} else if (has_cache) /* someone added cache */
result = -EEXIST;
else if (!count) /* no users */
result = -ENOENT;
if (!has_cache && count)
has_cache = SWAP_HAS_CACHE;
else if (has_cache) /* someone else added cache */
err = -EEXIST;
else /* no users remaining */
err = -ENOENT;

} else if (count || has_cache) {
if (count < SWAP_MAP_MAX - 1) {
p->swap_map[offset] = encode_swapmap(count + 1,
has_cache);
result = 0;
} else if (count <= SWAP_MAP_MAX) {

if (count < SWAP_MAP_MAX - 1)
count++;
else if (count <= SWAP_MAP_MAX) {
if (swap_overflow++ < 5)
printk(KERN_WARNING
"swap_dup: swap entry overflow\n");
p->swap_map[offset] = encode_swapmap(SWAP_MAP_MAX,
has_cache);
result = 0;
}
count = SWAP_MAP_MAX;
} else
err = -EINVAL;
} else
result = -ENOENT; /* unused swap entry */
err = -ENOENT; /* unused swap entry */

p->swap_map[offset] = count | has_cache;

unlock_out:
spin_unlock(&swap_lock);
out:
return result;
return err;

bad_file:
printk(KERN_ERR "swap_dup: %s%08lx\n", Bad_file, entry.val);
goto out;
}

/*
* increase reference count of swap entry by 1.
*/
void swap_duplicate(swp_entry_t entry)
{
__swap_duplicate(entry, SWAP_MAP);
__swap_duplicate(entry, 1);
}

/*
Expand All @@ -2189,7 +2162,7 @@ void swap_duplicate(swp_entry_t entry)
*/
int swapcache_prepare(swp_entry_t entry)
{
return __swap_duplicate(entry, SWAP_CACHE);
return __swap_duplicate(entry, SWAP_HAS_CACHE);
}

/*
Expand Down

0 comments on commit 253d553

Please sign in to comment.