mm/swapfile: move get_swap_page_of_type() under CONFIG_HIBERNATION

Patch series "Cleanups for swap", v2.

This series contains just cleanups to remove some unused variables, delete
meaningless forward declarations and so on.  More details can be found in
the respective changelogs.

This patch (of 4):

We should move get_swap_page_of_type() under CONFIG_HIBERNATION since the
only caller of this function is now suspend routine.

[linmiaohe@huawei.com: move scan_swap_map() under CONFIG_HIBERNATION]
Link: https://lkml.kernel.org/r/20210521070855.2015094-1-linmiaohe@huawei.com
[linmiaohe@huawei.com: fold scan_swap_map() into the only caller get_swap_page_of_type()]
Link: https://lkml.kernel.org/r/20210527120328.3935132-1-linmiaohe@huawei.com
Link: https://lkml.kernel.org/r/20210520134022.1370406-1-linmiaohe@huawei.com
Link: https://lkml.kernel.org/r/20210520134022.1370406-2-linmiaohe@huawei.com
Signed-off-by: Miaohe Lin <linmiaohe@huawei.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/mm/swapfile.c b/mm/swapfile.c
index a9a04a5..115f0b0 100644 (file)
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -453,10 +453,10 @@ static void swap_cluster_schedule_discard(struct swap_info_struct *si,
                unsigned int idx)
 {
        /*
-        * If scan_swap_map() can't find a free cluster, it will check
+        * If scan_swap_map_slots() can't find a free cluster, it will check
         * si->swap_map directly. To make sure the discarding cluster isn't
-        * taken by scan_swap_map(), mark the swap entries bad (occupied). It
-        * will be cleared after discard
+        * taken by scan_swap_map_slots(), mark the swap entries bad (occupied).
+        * It will be cleared after discard
         */
        memset(si->swap_map + idx * SWAPFILE_CLUSTER,
                        SWAP_MAP_BAD, SWAPFILE_CLUSTER);
@@ -589,7 +589,7 @@ static void dec_cluster_info_page(struct swap_info_struct *p,
 }
 
 /*
- * It's possible scan_swap_map() uses a free cluster in the middle of free
+ * It's possible scan_swap_map_slots() uses a free cluster in the middle of free
  * cluster list. Avoiding such abuse to avoid list corruption.
  */
 static bool
@@ -1037,21 +1037,6 @@ static void swap_free_cluster(struct swap_info_struct *si, unsigned long idx)
        swap_range_free(si, offset, SWAPFILE_CLUSTER);
 }
 
-static unsigned long scan_swap_map(struct swap_info_struct *si,
-                                  unsigned char usage)
-{
-       swp_entry_t entry;
-       int n_ret;
-
-       n_ret = scan_swap_map_slots(si, usage, 1, &entry);
-
-       if (n_ret)
-               return swp_offset(entry);
-       else
-               return 0;
-
-}
-
 int get_swap_pages(int n_goal, swp_entry_t swp_entries[], int entry_size)
 {
        unsigned long size = swap_entry_size(entry_size);
@@ -1114,14 +1099,14 @@ start_over:
 nextsi:
                /*
                 * if we got here, it's likely that si was almost full before,
-                * and since scan_swap_map() can drop the si->lock, multiple
-                * callers probably all tried to get a page from the same si
-                * and it filled up before we could get one; or, the si filled
-                * up between us dropping swap_avail_lock and taking si->lock.
-                * Since we dropped the swap_avail_lock, the swap_avail_head
-                * list may have been modified; so if next is still in the
-                * swap_avail_head list then try it, otherwise start over
-                * if we have not gotten any slots.
+                * and since scan_swap_map_slots() can drop the si->lock,
+                * multiple callers probably all tried to get a page from the
+                * same si and it filled up before we could get one; or, the si
+                * filled up between us dropping swap_avail_lock and taking
+                * si->lock. Since we dropped the swap_avail_lock, the
+                * swap_avail_head list may have been modified; so if next is
+                * still in the swap_avail_head list then try it, otherwise
+                * start over if we have not gotten any slots.
                 */
                if (plist_node_empty(&next->avail_lists[node]))
                        goto start_over;
@@ -1137,30 +1122,6 @@ noswap:
        return n_ret;
 }
 
-/* The only caller of this function is now suspend routine */
-swp_entry_t get_swap_page_of_type(int type)
-{
-       struct swap_info_struct *si = swap_type_to_swap_info(type);
-       pgoff_t offset;
-
-       if (!si)
-               goto fail;
-
-       spin_lock(&si->lock);
-       if (si->flags & SWP_WRITEOK) {
-               /* This is called for allocating swap entry, not cache */
-               offset = scan_swap_map(si, 1);
-               if (offset) {
-                       atomic_long_dec(&nr_swap_pages);
-                       spin_unlock(&si->lock);
-                       return swp_entry(type, offset);
-               }
-       }
-       spin_unlock(&si->lock);
-fail:
-       return (swp_entry_t) {0};
-}
-
 static struct swap_info_struct *__swap_info_get(swp_entry_t entry)
 {
        struct swap_info_struct *p;
@@ -1812,6 +1773,24 @@ int free_swap_and_cache(swp_entry_t entry)
 }
 
 #ifdef CONFIG_HIBERNATION
+
+swp_entry_t get_swap_page_of_type(int type)
+{
+       struct swap_info_struct *si = swap_type_to_swap_info(type);
+       swp_entry_t entry = {0};
+
+       if (!si)
+               goto fail;
+
+       /* This is called for allocating swap entry, not cache */
+       spin_lock(&si->lock);
+       if ((si->flags & SWP_WRITEOK) && scan_swap_map_slots(si, 1, 1, &entry))
+               atomic_long_dec(&nr_swap_pages);
+       spin_unlock(&si->lock);
+fail:
+       return entry;
+}
+
 /*
  * Find the swap type that corresponds to given device (if any).
  *
@@ -2649,7 +2628,7 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
        spin_lock(&p->lock);
        drain_mmlist();
 
-       /* wait for anyone still in scan_swap_map */
+       /* wait for anyone still in scan_swap_map_slots */
        p->highest_bit = 0;             /* cuts scans short */
        while (p->flags >= SWP_SCANNING) {
                spin_unlock(&p->lock);