swap_info: SWAP_HAS_CACHE cleanups

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>

2 files changed, 65 insertions, 92 deletions

diff --git a/include/linux/swap.h b/include/linux/swap.h
index 109dfe794237..c9d8870892b8 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -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.
  */
diff --git a/mm/swapfile.c b/mm/swapfile.c
index fa5f10b9c28b..52497490a7ca 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -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 */
@@ -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;
@@ -355,10 +334,7 @@ checks:
                 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;
 
@@ -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);
@@ -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);
@@ -555,29 +531,31 @@ out:
         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)
@@ -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;
 }
 
 /*
@@ -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);
         }
 }
@@ -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);
         }
 }
@@ -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);
@@ -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;
                 }
@@ -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)
@@ -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);
 }
 
 /*
@@ -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);
 }
 
 /*