fuse: fix readahead reclaim deadlock

Commit e26ee4efbc79 ("fuse: allocate ff->release_args only if release is
needed") skips allocating ff->release_args if the server does not
implement open. However in doing so, fuse_prepare_release() now skips
grabbing the reference on the inode, which makes it possible for an
inode to be evicted from the dcache while there are inflight readahead
requests. This causes a deadlock if the server triggers reclaim while
servicing the readahead request and reclaim attempts to evict the inode
of the file being read ahead. Since the folio is locked during
readahead, when reclaim evicts the fuse inode and fuse_evict_inode()
attempts to remove all folios associated with the inode from the page
cache (truncate_inode_pages_range()), reclaim will block forever waiting
for the lock since readahead cannot relinquish the lock because it is
itself blocked in reclaim:

>>> stack_trace(1504735)
 folio_wait_bit_common (mm/filemap.c:1308:4)
 folio_lock (./include/linux/pagemap.h:1052:3)
 truncate_inode_pages_range (mm/truncate.c:336:10)
 fuse_evict_inode (fs/fuse/inode.c:161:2)
 evict (fs/inode.c:704:3)
 dentry_unlink_inode (fs/dcache.c:412:3)
 __dentry_kill (fs/dcache.c:615:3)
 shrink_kill (fs/dcache.c:1060:12)
 shrink_dentry_list (fs/dcache.c:1087:3)
 prune_dcache_sb (fs/dcache.c:1168:2)
 super_cache_scan (fs/super.c:221:10)
 do_shrink_slab (mm/shrinker.c:435:9)
 shrink_slab (mm/shrinker.c:626:10)
 shrink_node (mm/vmscan.c:5951:2)
 shrink_zones (mm/vmscan.c:6195:3)
 do_try_to_free_pages (mm/vmscan.c:6257:3)
 do_swap_page (mm/memory.c:4136:11)
 handle_pte_fault (mm/memory.c:5562:10)
 handle_mm_fault (mm/memory.c:5870:9)
 do_user_addr_fault (arch/x86/mm/fault.c:1338:10)
 handle_page_fault (arch/x86/mm/fault.c:1481:3)
 exc_page_fault (arch/x86/mm/fault.c:1539:2)
 asm_exc_page_fault+0x22/0x27

Fix this deadlock by allocating ff->release_args and grabbing the
reference on the inode when preparing the file for release even if the
server does not implement open. The inode reference will be dropped when
the last reference on the fuse file is dropped (see fuse_file_put() ->
fuse_release_end()).

Fixes: e26ee4efbc79 ("fuse: allocate ff->release_args only if release is needed")
Cc: stable@vger.kernel.org
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Reported-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index f1ef77a0be05bbee8991a0b1bdf61644e58b6c50..4d96e684d73635415a1b8e485d4b8309e76c71e6 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -110,7 +110,9 @@ static void fuse_file_put(struct fuse_file *ff, bool sync)
                        fuse_file_io_release(ff, ra->inode);
 
                if (!args) {
-                       /* Do nothing when server does not implement 'open' */
+                       /* Do nothing when server does not implement 'opendir' */
+               } else if (args->opcode == FUSE_RELEASE && ff->fm->fc->no_open) {
+                       fuse_release_end(ff->fm, args, 0);
                } else if (sync) {
                        fuse_simple_request(ff->fm, args);
                        fuse_release_end(ff->fm, args, 0);
@@ -131,8 +133,17 @@ struct fuse_file *fuse_file_open(struct fuse_mount *fm, u64 nodeid,
        struct fuse_file *ff;
        int opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
        bool open = isdir ? !fc->no_opendir : !fc->no_open;
+       bool release = !isdir || open;
 
-       ff = fuse_file_alloc(fm, open);
+       /*
+        * ff->args->release_args still needs to be allocated (so we can hold an
+        * inode reference while there are pending inflight file operations when
+        * ->release() is called, see fuse_prepare_release()) even if
+        * fc->no_open is set else it becomes possible for reclaim to deadlock
+        * if while servicing the readahead request the server triggers reclaim
+        * and reclaim evicts the inode of the file being read ahead.
+        */
+       ff = fuse_file_alloc(fm, release);
        if (!ff)
                return ERR_PTR(-ENOMEM);
 
@@ -152,13 +163,14 @@ struct fuse_file *fuse_file_open(struct fuse_mount *fm, u64 nodeid,
                        fuse_file_free(ff);
                        return ERR_PTR(err);
                } else {
-                       /* No release needed */
-                       kfree(ff->args);
-                       ff->args = NULL;
-                       if (isdir)
+                       if (isdir) {
+                               /* No release needed */
+                               kfree(ff->args);
+                               ff->args = NULL;
                                fc->no_opendir = 1;
-                       else
+                       } else {
                                fc->no_open = 1;
+                       }
                }
        }