swapin needs gfp_mask for loop on tmpfs

Building in a filesystem on a loop device on a tmpfs file can hang when
swapping, the loop thread caught in that infamous throttle_vm_writeout.

In theory this is a long standing problem, which I've either never seen in
practice, or long ago suppressed the recollection, after discounting my load
and my tmpfs size as unrealistically high.  But now, with the new aops, it has
become easy to hang on one machine.

Loop used to grab_cache_page before the old prepare_write to tmpfs, which
seems to have been enough to free up some memory for any swapin needed; but
the new write_begin lets tmpfs find or allocate the page (much nicer, since
grab_cache_page missed tmpfs pages in swapcache).

When allocating a fresh page, tmpfs respects loop's mapping_gfp_mask, which
has __GFP_IO|__GFP_FS stripped off, and throttle_vm_writeout is designed to
break out when __GFP_IO or GFP_FS is unset; but when tmfps swaps in,
read_swap_cache_async allocates with GFP_HIGHUSER_MOVABLE regardless of the
mapping_gfp_mask - hence the hang.

So, pass gfp_mask down the line from shmem_getpage to shmem_swapin to
swapin_readahead to read_swap_cache_async to add_to_swap_cache.

Signed-off-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Rik van Riel <riel@redhat.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 9 insertions, 9 deletions

diff --git a/mm/swap_state.c b/mm/swap_state.c
index 668a80422630..e7875642e2cf 100644
--- a/mm/swap_state.c
+++ b/mm/swap_state.c
@@ -96,7 +96,8 @@ static int __add_to_swap_cache(struct page *page, swp_entry_t entry,
         return error;
 }
 
-static int add_to_swap_cache(struct page *page, swp_entry_t entry)
+static int add_to_swap_cache(struct page *page, swp_entry_t entry,
+                                gfp_t gfp_mask)
 {
         int error;
 
@@ -106,7 +107,7 @@ static int add_to_swap_cache(struct page *page, swp_entry_t entry)
                 return -ENOENT;
         }
         SetPageLocked(page);
-        error = __add_to_swap_cache(page, entry, GFP_KERNEL);
+        error = __add_to_swap_cache(page, entry, gfp_mask & GFP_KERNEL);
         /*
          * Anon pages are already on the LRU, we don't run lru_cache_add here.
          */
@@ -318,7 +319,7 @@ struct page * lookup_swap_cache(swp_entry_t entry)
  * A failure return means that either the page allocation failed or that
  * the swap entry is no longer in use.
  */
-struct page *read_swap_cache_async(swp_entry_t entry,
+struct page *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
                         struct vm_area_struct *vma, unsigned long addr)
 {
         struct page *found_page, *new_page = NULL;
@@ -338,8 +339,7 @@ struct page *read_swap_cache_async(swp_entry_t entry,
                  * Get a new page to read into from swap.
                  */
                 if (!new_page) {
-                        new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE,
-                                                                vma, addr);
+                        new_page = alloc_page_vma(gfp_mask, vma, addr);
                         if (!new_page)
                                 break;          /* Out of memory */
                 }
@@ -354,7 +354,7 @@ struct page *read_swap_cache_async(swp_entry_t entry,
                  * the just freed swap entry for an existing page.
                  * May fail (-ENOMEM) if radix-tree node allocation failed.
                  */
-                err = add_to_swap_cache(new_page, entry);
+                err = add_to_swap_cache(new_page, entry, gfp_mask);
                 if (!err) {
                         /*
                          * Initiate read into locked page and return.
@@ -388,7 +388,7 @@ struct page *read_swap_cache_async(swp_entry_t entry,
  *
  * Caller must hold down_read on the vma->vm_mm if vma is not NULL.
  */
-struct page *swapin_readahead(swp_entry_t entry,
+struct page *swapin_readahead(swp_entry_t entry, gfp_t gfp_mask,
                         struct vm_area_struct *vma, unsigned long addr)
 {
         int nr_pages;
@@ -407,11 +407,11 @@ struct page *swapin_readahead(swp_entry_t entry,
         for (end_offset = offset + nr_pages; offset < end_offset; offset++) {
                 /* Ok, do the async read-ahead now */
                 page = read_swap_cache_async(swp_entry(swp_type(entry), offset),
-                                                vma, addr);
+                                                gfp_mask, vma, addr);
                 if (!page)
                         break;
                 page_cache_release(page);
         }
         lru_add_drain();        /* Push any new pages onto the LRU now */
-        return read_swap_cache_async(entry, vma, addr);
+        return read_swap_cache_async(entry, gfp_mask, vma, addr);
 }