mm/swap: skip readahead only when swap slot cache is enabled

Because during swap off, a swap entry may have swap_map[] ==
SWAP_HAS_CACHE (for example, just allocated).  If we return NULL in
__read_swap_cache_async(), the swap off will abort.  So when swap slot
cache is disabled, (for swap off), we will wait for page to be put into
swap cache in such race condition.  This should not be a problem for swap
slot cache, because swap slot cache should be drained after clearing
swap_slot_cache_enabled.

[[email protected]: fix memory leak in __read_swap_cache_async()]
Link: http://lkml.kernel.org/r/[email protected]
Link: http://lkml.kernel.org/r/5e2c5f6abe8e6eb0797408897b1bba80938e9b9d.1484082593.git.tim.c.chen@linux.intel.com
Signed-off-by: "Huang, Ying" <[email protected]>
Signed-off-by: Tim Chen <[email protected]>
Cc: Aaron Lu <[email protected]>
Cc: Andi Kleen <[email protected]>
Cc: Andrea Arcangeli <[email protected]>
Cc: Christian Borntraeger <[email protected]>
Cc: Dave Hansen <[email protected]>
Cc: Hillf Danton <[email protected]>
Cc: Huang Ying <[email protected]>
Cc: Hugh Dickins <[email protected]>
Cc: Johannes Weiner <[email protected]>
Cc: Jonathan Corbet <[email protected]> escreveu:
Cc: Kirill A. Shutemov <[email protected]>
Cc: Michal Hocko <[email protected]>
Cc: Minchan Kim <[email protected]>
Cc: Rik van Riel <[email protected]>
Cc: Shaohua Li <[email protected]>
Cc: Vladimir Davydov <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Signed-off-by: Linus Torvalds <[email protected]>

diff --git a/include/linux/swap_slots.h b/include/linux/swap_slots.h
index ba5623b27c60407924c64886cb2ba8e795a9c5fd..6ef92d17633da7eb1c138a9e79195cf644f9038d 100644 (file)
--- a/include/linux/swap_slots.h
+++ b/include/linux/swap_slots.h
@@ -25,4 +25,6 @@ void reenable_swap_slots_cache_unlock(void);
 int enable_swap_slots_cache(void);
 int free_swap_slot(swp_entry_t entry);
 
+extern bool swap_slot_cache_enabled;
+
 #endif /* _LINUX_SWAP_SLOTS_H */

diff --git a/mm/swap_slots.c b/mm/swap_slots.c
index ebf4f1cbac0452ef431ccf398293a4a37008e197..9b5bc86f96ad731269e2051719583f168a74bc51 100644 (file)
--- a/mm/swap_slots.c
+++ b/mm/swap_slots.c
@@ -36,7 +36,7 @@
 
 static DEFINE_PER_CPU(struct swap_slots_cache, swp_slots);
 static bool    swap_slot_cache_active;
-static bool    swap_slot_cache_enabled;
+bool   swap_slot_cache_enabled;
 static bool    swap_slot_cache_initialized;
 DEFINE_MUTEX(swap_slots_cache_mutex);
 /* Serialize swap slots cache enable/disable operations */

diff --git a/mm/swap_state.c b/mm/swap_state.c
index e1f07cafecaacdcf63f6758ad15a27b766aebe4d..473b71e052a8ed29df7c496af747e2b43491c782 100644 (file)
--- a/mm/swap_state.c
+++ b/mm/swap_state.c
@@ -324,9 +324,16 @@ struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
                if (found_page)
                        break;
 
-               /* Just skip read ahead for unused swap slot */
-               if (!__swp_swapcount(entry))
-                       return NULL;
+               /*
+                * Just skip read ahead for unused swap slot.
+                * During swap_off when swap_slot_cache is disabled,
+                * we have to handle the race between putting
+                * swap entry in swap cache and marking swap slot
+                * as SWAP_HAS_CACHE.  That's done in later part of code or
+                * else swap_off will be aborted if we return NULL.
+                */
+               if (!__swp_swapcount(entry) && swap_slot_cache_enabled)
+                       break;
 
                /*
                 * Get a new page to read into from swap.