tmpfs: open a window in shmem_unuse_inode

There are a couple of reasons (patches follow) why it would be good to open a
window for sleep in shmem_unuse_inode, between its search for a matching swap
entry, and its handling of the entry found.

shmem_unuse_inode must then use igrab to hold the inode against deletion in
that window, and its corresponding iput might result in deletion: so it had
better unlock_page before the iput, and might as well release the page too.

Nor is there any need to hold on to shmem_swaplist_mutex once we know we'll
leave the loop.  So this unwinding moves from try_to_unuse and shmem_unuse
into shmem_unuse_inode, in the case when it finds a match.

Let try_to_unuse break on error in the shmem_unuse case, as it does in the
unuse_mm case: though at this point in the series, no error to break on.

Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 10 insertions, 13 deletions

diff --git a/mm/swapfile.c b/mm/swapfile.c
index 14bc4f28a8cc..eade24da9310 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -814,7 +814,7 @@ static int try_to_unuse(unsigned int type)
                         atomic_inc(&new_start_mm->mm_users);
                         atomic_inc(&prev_mm->mm_users);
                         spin_lock(&mmlist_lock);
-                        while (*swap_map > 1 && !retval &&
+                        while (*swap_map > 1 && !retval && !shmem &&
                                         (p = p->next) != &start_mm->mmlist) {
                                 mm = list_entry(p, struct mm_struct, mmlist);
                                 if (!atomic_inc_not_zero(&mm->mm_users))
@@ -846,6 +846,13 @@ static int try_to_unuse(unsigned int type)
                         mmput(start_mm);
                         start_mm = new_start_mm;
                 }
+                if (shmem) {
+                        /* page has already been unlocked and released */
+                        if (shmem > 0)
+                                continue;
+                        retval = shmem;
+                        break;
+                }
                 if (retval) {
                         unlock_page(page);
                         page_cache_release(page);
@@ -884,12 +891,6 @@ static int try_to_unuse(unsigned int type)
                  * read from disk into another page.  Splitting into two
                  * pages would be incorrect if swap supported "shared
                  * private" pages, but they are handled by tmpfs files.
-                 *
-                 * Note shmem_unuse already deleted a swappage from
-                 * the swap cache, unless the move to filepage failed:
-                 * in which case it left swappage in cache, lowered its
-                 * swap count to pass quickly through the loops above,
-                 * and now we must reincrement count to try again later.
                  */
                 if ((*swap_map > 1) && PageDirty(page) && PageSwapCache(page)) {
                         struct writeback_control wbc = {
@@ -900,12 +901,8 @@ static int try_to_unuse(unsigned int type)
                         lock_page(page);
                         wait_on_page_writeback(page);
                 }
-                if (PageSwapCache(page)) {
-                        if (shmem)
-                                swap_duplicate(entry);
-                        else
-                                delete_from_swap_cache(page);
-                }
+                if (PageSwapCache(page))
+                        delete_from_swap_cache(page);
 
                 /*
                  * So we could skip searching mms once swap count went