Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi...

Pull fuse updates from Miklos Szeredi:
 "This fixes error propagation from writeback to fsync/close for
  writeback cache mode as well as adding a missing capability flag to
  the INIT message.  The rest are cleanups.

  (The commits are recent but all the code actually sat in -next for a
  while now.  The recommits are due to conflict avoidance and the
  addition of Cc: stable@...)"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/fuse:
  fuse: use filemap_check_errors()
  mm: export filemap_check_errors() to modules
  fuse: fix wrong assignment of ->flags in fuse_send_init()
  fuse: fuse_flush must check mapping->flags for errors
  fuse: fsync() did not return IO errors
  fuse: don't mess with blocking signals
  new helper: wait_event_killable_exclusive()
  fuse: improve aio directIO write performance for size extending writes

diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 203adf3b75dba448c074e596b81c9966a75f51d4..a94d2ed81ab4af4bf7cc8316d5f7517a9902c3a2 100644 (file)
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -99,19 +99,6 @@ void fuse_request_free(struct fuse_req *req)
        kmem_cache_free(fuse_req_cachep, req);
 }
 
-static void block_sigs(sigset_t *oldset)
-{
-       sigset_t mask;
-
-       siginitsetinv(&mask, sigmask(SIGKILL));
-       sigprocmask(SIG_BLOCK, &mask, oldset);
-}
-
-static void restore_sigs(sigset_t *oldset)
-{
-       sigprocmask(SIG_SETMASK, oldset, NULL);
-}
-
 void __fuse_get_request(struct fuse_req *req)
 {
        atomic_inc(&req->count);
@@ -151,15 +138,9 @@ static struct fuse_req *__fuse_get_req(struct fuse_conn *fc, unsigned npages,
        atomic_inc(&fc->num_waiting);
 
        if (fuse_block_alloc(fc, for_background)) {
-               sigset_t oldset;
-               int intr;
-
-               block_sigs(&oldset);
-               intr = wait_event_interruptible_exclusive(fc->blocked_waitq,
-                               !fuse_block_alloc(fc, for_background));
-               restore_sigs(&oldset);
                err = -EINTR;
-               if (intr)
+               if (wait_event_killable_exclusive(fc->blocked_waitq,
+                               !fuse_block_alloc(fc, for_background)))
                        goto out;
        }
        /* Matches smp_wmb() in fuse_set_initialized() */
@@ -446,14 +427,9 @@ static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
        }
 
        if (!test_bit(FR_FORCE, &req->flags)) {
-               sigset_t oldset;
-
                /* Only fatal signals may interrupt this */
-               block_sigs(&oldset);
-               err = wait_event_interruptible(req->waitq,
+               err = wait_event_killable(req->waitq,
                                        test_bit(FR_FINISHED, &req->flags));
-               restore_sigs(&oldset);
-
                if (!err)
                        return;
 

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 2382f22a2a8bfc3af619d62ec8bf00a23b73ed80..f394aff59c363a34c43eea0eec32293e21570986 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -417,6 +417,10 @@ static int fuse_flush(struct file *file, fl_owner_t id)
        fuse_sync_writes(inode);
        inode_unlock(inode);
 
+       err = filemap_check_errors(file->f_mapping);
+       if (err)
+               return err;
+
        req = fuse_get_req_nofail_nopages(fc, file);
        memset(&inarg, 0, sizeof(inarg));
        inarg.fh = ff->fh;
@@ -462,6 +466,16 @@ int fuse_fsync_common(struct file *file, loff_t start, loff_t end,
                goto out;
 
        fuse_sync_writes(inode);
+
+       /*
+        * Due to implementation of fuse writeback
+        * filemap_write_and_wait_range() does not catch errors.
+        * We have to do this directly after fuse_sync_writes()
+        */
+       err = filemap_check_errors(file->f_mapping);
+       if (err)
+               goto out;
+
        err = sync_inode_metadata(inode, 1);
        if (err)
                goto out;
@@ -562,7 +576,6 @@ static ssize_t fuse_get_res_by_io(struct fuse_io_priv *io)
  */
 static void fuse_aio_complete(struct fuse_io_priv *io, int err, ssize_t pos)
 {
-       bool is_sync = is_sync_kiocb(io->iocb);
        int left;
 
        spin_lock(&io->lock);
@@ -572,11 +585,11 @@ static void fuse_aio_complete(struct fuse_io_priv *io, int err, ssize_t pos)
                io->bytes = pos;
 
        left = --io->reqs;
-       if (!left && is_sync)
+       if (!left && io->blocking)
                complete(io->done);
        spin_unlock(&io->lock);
 
-       if (!left && !is_sync) {
+       if (!left && !io->blocking) {
                ssize_t res = fuse_get_res_by_io(io);
 
                if (res >= 0) {
@@ -2850,7 +2863,6 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
        size_t count = iov_iter_count(iter);
        loff_t offset = iocb->ki_pos;
        struct fuse_io_priv *io;
-       bool is_sync = is_sync_kiocb(iocb);
 
        pos = offset;
        inode = file->f_mapping->host;
@@ -2885,17 +2897,16 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
         */
        io->async = async_dio;
        io->iocb = iocb;
+       io->blocking = is_sync_kiocb(iocb);
 
        /*
-        * We cannot asynchronously extend the size of a file. We have no method
-        * to wait on real async I/O requests, so we must submit this request
-        * synchronously.
+        * We cannot asynchronously extend the size of a file.
+        * In such case the aio will behave exactly like sync io.
         */
-       if (!is_sync && (offset + count > i_size) &&
-           iov_iter_rw(iter) == WRITE)
-               io->async = false;
+       if ((offset + count > i_size) && iov_iter_rw(iter) == WRITE)
+               io->blocking = true;
 
-       if (io->async && is_sync) {
+       if (io->async && io->blocking) {
                /*
                 * Additional reference to keep io around after
                 * calling fuse_aio_complete()
@@ -2915,7 +2926,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
                fuse_aio_complete(io, ret < 0 ? ret : 0, -1);
 
                /* we have a non-extending, async request, so return */
-               if (!is_sync)
+               if (!io->blocking)
                        return -EIOCBQUEUED;
 
                wait_for_completion(&wait);

diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 929c383432b034f3f695e0cc83e55e9b48c35898..5db5d24f91a5929dd7c291c833b7049778336da3 100644 (file)
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -259,6 +259,7 @@ struct fuse_io_priv {
        struct kiocb *iocb;
        struct file *file;
        struct completion *done;
+       bool blocking;
 };
 
 #define FUSE_IO_PRIV_SYNC(f) \

diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 9961d8432ce335ba445df4a36824cd12912f1419..9b7cb37b4ba8362f495bbae3af46ea05e2b86073 100644 (file)
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -942,7 +942,7 @@ static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
        arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
                FUSE_EXPORT_SUPPORT | FUSE_BIG_WRITES | FUSE_DONT_MASK |
                FUSE_SPLICE_WRITE | FUSE_SPLICE_MOVE | FUSE_SPLICE_READ |
-               FUSE_FLOCK_LOCKS | FUSE_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
+               FUSE_FLOCK_LOCKS | FUSE_HAS_IOCTL_DIR | FUSE_AUTO_INVAL_DATA |
                FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO | FUSE_ASYNC_DIO |
                FUSE_WRITEBACK_CACHE | FUSE_NO_OPEN_SUPPORT |
                FUSE_PARALLEL_DIROPS;

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 50ccf845b56cedc291b2a75cbb4b254c2da6b7fa..f65a6801f60967346f7a47b4c49087966dcb2593 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2506,6 +2506,7 @@ extern int __filemap_fdatawrite_range(struct address_space *mapping,
                                loff_t start, loff_t end, int sync_mode);
 extern int filemap_fdatawrite_range(struct address_space *mapping,
                                loff_t start, loff_t end);
+extern int filemap_check_errors(struct address_space *mapping);
 
 extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
                           int datasync);

diff --git a/include/linux/wait.h b/include/linux/wait.h
index 27d7a0ab5da3edf217e60d767c10c65d3e3c52a0..c3ff74d764faad094e7f00dcd025ddb568a6382d 100644 (file)
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -600,6 +600,19 @@ do {                                                                       \
        __ret;                                                          \
 })
 
+#define __wait_event_killable_exclusive(wq, condition)                 \
+       ___wait_event(wq, condition, TASK_KILLABLE, 1, 0,               \
+                     schedule())
+
+#define wait_event_killable_exclusive(wq, condition)                   \
+({                                                                     \
+       int __ret = 0;                                                  \
+       might_sleep();                                                  \
+       if (!(condition))                                               \
+               __ret = __wait_event_killable_exclusive(wq, condition); \
+       __ret;                                                          \
+})
+
 
 #define __wait_event_freezable_exclusive(wq, condition)                        \
        ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0,          \

diff --git a/mm/filemap.c b/mm/filemap.c
index c5f5e46c6f7ff855f36efd934cce2d78ce73c549..3083ded98b15f32b68c58d744a5c3abb07d94c96 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -273,7 +273,7 @@ void delete_from_page_cache(struct page *page)
 }
 EXPORT_SYMBOL(delete_from_page_cache);
 
-static int filemap_check_errors(struct address_space *mapping)
+int filemap_check_errors(struct address_space *mapping)
 {
        int ret = 0;
        /* Check for outstanding write errors */
@@ -285,6 +285,7 @@ static int filemap_check_errors(struct address_space *mapping)
                ret = -EIO;
        return ret;
 }
+EXPORT_SYMBOL(filemap_check_errors);
 
 /**
  * __filemap_fdatawrite_range - start writeback on mapping dirty pages in range