5 files changed, 276 insertions, 149 deletions

diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 8f873e621f41..e08ab4702d97 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -148,6 +148,26 @@ void fuse_release_background(struct fuse_req *req)
         spin_unlock(&fuse_lock);
 }
 
+static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
+{
+        int i;
+        struct fuse_init_out *arg = &req->misc.init_out;
+
+        if (arg->major != FUSE_KERNEL_VERSION)
+                fc->conn_error = 1;
+        else {
+                fc->minor = arg->minor;
+                fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
+        }
+
+        /* After INIT reply is received other requests can go
+           out.  So do (FUSE_MAX_OUTSTANDING - 1) number of
+           up()s on outstanding_sem.  The last up() is done in
+           fuse_putback_request() */
+        for (i = 1; i < FUSE_MAX_OUTSTANDING; i++)
+                up(&fc->outstanding_sem);
+}
+
 /*
  * This function is called when a request is finished.  Either a reply
  * has arrived or it was interrupted (and not yet sent) or some error
@@ -172,19 +192,9 @@ static void request_end(struct fuse_conn *fc, struct fuse_req *req)
                 up_read(&fc->sbput_sem);
         }
         wake_up(&req->waitq);
-        if (req->in.h.opcode == FUSE_INIT) {
-                int i;
-
-                if (req->misc.init_in_out.major != FUSE_KERNEL_VERSION)
-                        fc->conn_error = 1;
-
-                /* After INIT reply is received other requests can go
-                   out.  So do (FUSE_MAX_OUTSTANDING - 1) number of
-                   up()s on outstanding_sem.  The last up() is done in
-                   fuse_putback_request() */
-                for (i = 1; i < FUSE_MAX_OUTSTANDING; i++)
-                        up(&fc->outstanding_sem);
-        } else if (req->in.h.opcode == FUSE_RELEASE && req->inode == NULL) {
+        if (req->in.h.opcode == FUSE_INIT)
+                process_init_reply(fc, req);
+        else if (req->in.h.opcode == FUSE_RELEASE && req->inode == NULL) {
                 /* Special case for failed iget in CREATE */
                 u64 nodeid = req->in.h.nodeid;
                 __fuse_get_request(req);
@@ -357,7 +367,7 @@ void fuse_send_init(struct fuse_conn *fc)
         /* This is called from fuse_read_super() so there's guaranteed
            to be a request available */
         struct fuse_req *req = do_get_request(fc);
-        struct fuse_init_in_out *arg = &req->misc.init_in_out;
+        struct fuse_init_in *arg = &req->misc.init_in;
         arg->major = FUSE_KERNEL_VERSION;
         arg->minor = FUSE_KERNEL_MINOR_VERSION;
         req->in.h.opcode = FUSE_INIT;
@@ -365,8 +375,12 @@ void fuse_send_init(struct fuse_conn *fc)
         req->in.args[0].size = sizeof(*arg);
         req->in.args[0].value = arg;
         req->out.numargs = 1;
-        req->out.args[0].size = sizeof(*arg);
-        req->out.args[0].value = arg;
+        /* Variable length arguement used for backward compatibility
+           with interface version < 7.5.  Rest of init_out is zeroed
+           by do_get_request(), so a short reply is not a problem */
+        req->out.argvar = 1;
+        req->out.args[0].size = sizeof(struct fuse_init_out);
+        req->out.args[0].value = &req->misc.init_out;
         request_send_background(fc, req);
 }
 
@@ -615,6 +629,7 @@ static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
         struct fuse_copy_state cs;
         unsigned reqsize;
 
+ restart:
         spin_lock(&fuse_lock);
         fc = file->private_data;
         err = -EPERM;
@@ -630,20 +645,25 @@ static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
 
         req = list_entry(fc->pending.next, struct fuse_req, list);
         list_del_init(&req->list);
-        spin_unlock(&fuse_lock);
 
         in = &req->in;
-        reqsize = req->in.h.len;
-        fuse_copy_init(&cs, 1, req, iov, nr_segs);
-        err = -EINVAL;
-        if (iov_length(iov, nr_segs) >= reqsize) {
-                err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
-                if (!err)
-                        err = fuse_copy_args(&cs, in->numargs, in->argpages,
-                                             (struct fuse_arg *) in->args, 0);
+        reqsize = in->h.len;
+        /* If request is too large, reply with an error and restart the read */
+        if (iov_length(iov, nr_segs) < reqsize) {
+                req->out.h.error = -EIO;
+                /* SETXATTR is special, since it may contain too large data */
+                if (in->h.opcode == FUSE_SETXATTR)
+                        req->out.h.error = -E2BIG;
+                request_end(fc, req);
+                goto restart;
         }
+        spin_unlock(&fuse_lock);
+        fuse_copy_init(&cs, 1, req, iov, nr_segs);
+        err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
+        if (!err)
+                err = fuse_copy_args(&cs, in->numargs, in->argpages,
+                                     (struct fuse_arg *) in->args, 0);
         fuse_copy_finish(&cs);
-
         spin_lock(&fuse_lock);
         req->locked = 0;
         if (!err && req->interrupted)
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 51f5da652771..417bcee466f6 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -13,8 +13,16 @@
 #include <linux/gfp.h>
 #include <linux/sched.h>
 #include <linux/namei.h>
-#include <linux/mount.h>
 
+/*
+ * FUSE caches dentries and attributes with separate timeout.  The
+ * time in jiffies until the dentry/attributes are valid is stored in
+ * dentry->d_time and fuse_inode->i_time respectively.
+ */
+
+/*
+ * Calculate the time in jiffies until a dentry/attributes are valid
+ */
 static inline unsigned long time_to_jiffies(unsigned long sec,
                                             unsigned long nsec)
 {
@@ -22,6 +30,50 @@ static inline unsigned long time_to_jiffies(unsigned long sec,
         return jiffies + timespec_to_jiffies(&ts);
 }
 
+/*
+ * Set dentry and possibly attribute timeouts from the lookup/mk*
+ * replies
+ */
+static void fuse_change_timeout(struct dentry *entry, struct fuse_entry_out *o)
+{
+        entry->d_time = time_to_jiffies(o->entry_valid, o->entry_valid_nsec);
+        if (entry->d_inode)
+                get_fuse_inode(entry->d_inode)->i_time =
+                        time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
+}
+
+/*
+ * Mark the attributes as stale, so that at the next call to
+ * ->getattr() they will be fetched from userspace
+ */
+void fuse_invalidate_attr(struct inode *inode)
+{
+        get_fuse_inode(inode)->i_time = jiffies - 1;
+}
+
+/*
+ * Just mark the entry as stale, so that a next attempt to look it up
+ * will result in a new lookup call to userspace
+ *
+ * This is called when a dentry is about to become negative and the
+ * timeout is unknown (unlink, rmdir, rename and in some cases
+ * lookup)
+ */
+static void fuse_invalidate_entry_cache(struct dentry *entry)
+{
+        entry->d_time = jiffies - 1;
+}
+
+/*
+ * Same as fuse_invalidate_entry_cache(), but also try to remove the
+ * dentry from the hash
+ */
+static void fuse_invalidate_entry(struct dentry *entry)
+{
+        d_invalidate(entry);
+        fuse_invalidate_entry_cache(entry);
+}
+
 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
                              struct dentry *entry,
                              struct fuse_entry_out *outarg)
@@ -37,17 +89,34 @@ static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
         req->out.args[0].value = outarg;
 }
 
+/*
+ * Check whether the dentry is still valid
+ *
+ * If the entry validity timeout has expired and the dentry is
+ * positive, try to redo the lookup.  If the lookup results in a
+ * different inode, then let the VFS invalidate the dentry and redo
+ * the lookup once more.  If the lookup results in the same inode,
+ * then refresh the attributes, timeouts and mark the dentry valid.
+ */
 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
 {
-        if (!entry->d_inode || is_bad_inode(entry->d_inode))
+        struct inode *inode = entry->d_inode;
+
+        if (inode && is_bad_inode(inode))
                 return 0;
         else if (time_after(jiffies, entry->d_time)) {
                 int err;
                 struct fuse_entry_out outarg;
-                struct inode *inode = entry->d_inode;
-                struct fuse_inode *fi = get_fuse_inode(inode);
-                struct fuse_conn *fc = get_fuse_conn(inode);
-                struct fuse_req *req = fuse_get_request(fc);
+                struct fuse_conn *fc;
+                struct fuse_req *req;
+
+                /* Doesn't hurt to "reset" the validity timeout */
+                fuse_invalidate_entry_cache(entry);
+                if (!inode)
+                        return 0;
+
+                fc = get_fuse_conn(inode);
+                req = fuse_get_request(fc);
                 if (!req)
                         return 0;
 
@@ -55,6 +124,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                 request_send(fc, req);
                 err = req->out.h.error;
                 if (!err) {
+                        struct fuse_inode *fi = get_fuse_inode(inode);
                         if (outarg.nodeid != get_node_id(inode)) {
                                 fuse_send_forget(fc, req, outarg.nodeid, 1);
                                 return 0;
@@ -66,18 +136,18 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                         return 0;
 
                 fuse_change_attributes(inode, &outarg.attr);
-                entry->d_time = time_to_jiffies(outarg.entry_valid,
-                                                outarg.entry_valid_nsec);
-                fi->i_time = time_to_jiffies(outarg.attr_valid,
-                                             outarg.attr_valid_nsec);
+                fuse_change_timeout(entry, &outarg);
         }
         return 1;
 }
 
+/*
+ * Check if there's already a hashed alias of this directory inode.
+ * If yes, then lookup and mkdir must not create a new alias.
+ */
 static int dir_alias(struct inode *inode)
 {
         if (S_ISDIR(inode->i_mode)) {
-                /* Don't allow creating an alias to a directory  */
                 struct dentry *alias = d_find_alias(inode);
                 if (alias) {
                         dput(alias);
@@ -96,8 +166,14 @@ static struct dentry_operations fuse_dentry_operations = {
         .d_revalidate   = fuse_dentry_revalidate,
 };
 
-static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
-                            struct inode **inodep)
+static inline int valid_mode(int m)
+{
+        return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
+                S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
+}
+
+static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
+                                  struct nameidata *nd)
 {
         int err;
         struct fuse_entry_out outarg;
@@ -106,53 +182,49 @@ static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
         struct fuse_req *req;
 
         if (entry->d_name.len > FUSE_NAME_MAX)
-                return -ENAMETOOLONG;
+                return ERR_PTR(-ENAMETOOLONG);
 
         req = fuse_get_request(fc);
         if (!req)
-                return -EINTR;
+                return ERR_PTR(-EINTR);
 
         fuse_lookup_init(req, dir, entry, &outarg);
         request_send(fc, req);
         err = req->out.h.error;
-        if (!err && invalid_nodeid(outarg.nodeid))
+        if (!err && ((outarg.nodeid && invalid_nodeid(outarg.nodeid)) ||
+                     !valid_mode(outarg.attr.mode)))
                 err = -EIO;
-        if (!err) {
+        if (!err && outarg.nodeid) {
                 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
                                   &outarg.attr);
                 if (!inode) {
                         fuse_send_forget(fc, req, outarg.nodeid, 1);
-                        return -ENOMEM;
+                        return ERR_PTR(-ENOMEM);
                 }
         }
         fuse_put_request(fc, req);
         if (err && err != -ENOENT)
-                return err;
+                return ERR_PTR(err);
 
-        if (inode) {
-                struct fuse_inode *fi = get_fuse_inode(inode);
-                entry->d_time = time_to_jiffies(outarg.entry_valid,
-                                                outarg.entry_valid_nsec);
-                fi->i_time = time_to_jiffies(outarg.attr_valid,
-                                             outarg.attr_valid_nsec);
+        if (inode && dir_alias(inode)) {
+                iput(inode);
+                return ERR_PTR(-EIO);
         }
-
+        d_add(entry, inode);
         entry->d_op = &fuse_dentry_operations;
-        *inodep = inode;
-        return 0;
-}
-
-void fuse_invalidate_attr(struct inode *inode)
-{
-        get_fuse_inode(inode)->i_time = jiffies - 1;
-}
-
-static void fuse_invalidate_entry(struct dentry *entry)
-{
-        d_invalidate(entry);
-        entry->d_time = jiffies - 1;
+        if (!err)
+                fuse_change_timeout(entry, &outarg);
+        else
+                fuse_invalidate_entry_cache(entry);
+        return NULL;
 }
 
+/*
+ * Atomic create+open operation
+ *
+ * If the filesystem doesn't support this, then fall back to separate
+ * 'mknod' + 'open' requests.
+ */
 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
                             struct nameidata *nd)
 {
@@ -163,7 +235,6 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         struct fuse_open_in inarg;
         struct fuse_open_out outopen;
         struct fuse_entry_out outentry;
-        struct fuse_inode *fi;
         struct fuse_file *ff;
         struct file *file;
         int flags = nd->intent.open.flags - 1;
@@ -172,10 +243,6 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         if (fc->no_create)
                 goto out;
 
-        err = -ENAMETOOLONG;
-        if (entry->d_name.len > FUSE_NAME_MAX)
-                goto out;
-
         err = -EINTR;
         req = fuse_get_request(fc);
         if (!req)
@@ -220,17 +287,15 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         if (!inode) {
                 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
                 ff->fh = outopen.fh;
+                /* Special release, with inode = NULL, this will
+                   trigger a 'forget' request when the release is
+                   complete */
                 fuse_send_release(fc, ff, outentry.nodeid, NULL, flags, 0);
                 goto out_put_request;
         }
         fuse_put_request(fc, req);
-        entry->d_time = time_to_jiffies(outentry.entry_valid,
-                                        outentry.entry_valid_nsec);
-        fi = get_fuse_inode(inode);
-        fi->i_time = time_to_jiffies(outentry.attr_valid,
-                                     outentry.attr_valid_nsec);
-
         d_instantiate(entry, inode);
+        fuse_change_timeout(entry, &outentry);
         file = lookup_instantiate_filp(nd, entry, generic_file_open);
         if (IS_ERR(file)) {
                 ff->fh = outopen.fh;
@@ -248,13 +313,15 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         return err;
 }
 
+/*
+ * Code shared between mknod, mkdir, symlink and link
+ */
 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
                             struct inode *dir, struct dentry *entry,
                             int mode)
 {
         struct fuse_entry_out outarg;
         struct inode *inode;
-        struct fuse_inode *fi;
         int err;
 
         req->in.h.nodeid = get_node_id(dir);
@@ -268,10 +335,13 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
                 fuse_put_request(fc, req);
                 return err;
         }
-        if (invalid_nodeid(outarg.nodeid)) {
-                fuse_put_request(fc, req);
-                return -EIO;
-        }
+        err = -EIO;
+        if (invalid_nodeid(outarg.nodeid))
+                goto out_put_request;
+
+        if ((outarg.attr.mode ^ mode) & S_IFMT)
+                goto out_put_request;
+
         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
                           &outarg.attr);
         if (!inode) {
@@ -280,22 +350,19 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
         }
         fuse_put_request(fc, req);
 
-        /* Don't allow userspace to do really stupid things... */
-        if (((inode->i_mode ^ mode) & S_IFMT) || dir_alias(inode)) {
+        if (dir_alias(inode)) {
                 iput(inode);
                 return -EIO;
         }
 
-        entry->d_time = time_to_jiffies(outarg.entry_valid,
-                                        outarg.entry_valid_nsec);
-
-        fi = get_fuse_inode(inode);
-        fi->i_time = time_to_jiffies(outarg.attr_valid,
-                                     outarg.attr_valid_nsec);
-
         d_instantiate(entry, inode);
+        fuse_change_timeout(entry, &outarg);
         fuse_invalidate_attr(dir);
         return 0;
+
+ out_put_request:
+        fuse_put_request(fc, req);
+        return err;
 }
 
 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
@@ -355,12 +422,7 @@ static int fuse_symlink(struct inode *dir, struct dentry *entry,
 {
         struct fuse_conn *fc = get_fuse_conn(dir);
         unsigned len = strlen(link) + 1;
-        struct fuse_req *req;
-
-        if (len > FUSE_SYMLINK_MAX)
-                return -ENAMETOOLONG;
-
-        req = fuse_get_request(fc);
+        struct fuse_req *req = fuse_get_request(fc);
         if (!req)
                 return -EINTR;
 
@@ -399,6 +461,7 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry)
                 inode->i_nlink = 0;
                 fuse_invalidate_attr(inode);
                 fuse_invalidate_attr(dir);
+                fuse_invalidate_entry_cache(entry);
         } else if (err == -EINTR)
                 fuse_invalidate_entry(entry);
         return err;
@@ -424,6 +487,7 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry)
         if (!err) {
                 entry->d_inode->i_nlink = 0;
                 fuse_invalidate_attr(dir);
+                fuse_invalidate_entry_cache(entry);
         } else if (err == -EINTR)
                 fuse_invalidate_entry(entry);
         return err;
@@ -459,6 +523,10 @@ static int fuse_rename(struct inode *olddir, struct dentry *oldent,
                 fuse_invalidate_attr(olddir);
                 if (olddir != newdir)
                         fuse_invalidate_attr(newdir);
+
+                /* newent will end up negative */
+                if (newent->d_inode)
+                        fuse_invalidate_entry_cache(newent);
         } else if (err == -EINTR) {
                 /* If request was interrupted, DEITY only knows if the
                    rename actually took place.  If the invalidation
@@ -566,6 +634,15 @@ static int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
         return 0;
 }
 
+/*
+ * Check whether the inode attributes are still valid
+ *
+ * If the attribute validity timeout has expired, then fetch the fresh
+ * attributes with a 'getattr' request
+ *
+ * I'm not sure why cached attributes are never returned for the root
+ * inode, this is probably being too cautious.
+ */
 static int fuse_revalidate(struct dentry *entry)
 {
         struct inode *inode = entry->d_inode;
@@ -613,6 +690,19 @@ static int fuse_access(struct inode *inode, int mask)
         return err;
 }
 
+/*
+ * Check permission.  The two basic access models of FUSE are:
+ *
+ * 1) Local access checking ('default_permissions' mount option) based
+ * on file mode.  This is the plain old disk filesystem permission
+ * modell.
+ *
+ * 2) "Remote" access checking, where server is responsible for
+ * checking permission in each inode operation.  An exception to this
+ * is if ->permission() was invoked from sys_access() in which case an
+ * access request is sent.  Execute permission is still checked
+ * locally based on file mode.
+ */
 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
 {
         struct fuse_conn *fc = get_fuse_conn(inode);
@@ -631,14 +721,10 @@ static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
                                 err = generic_permission(inode, mask, NULL);
                 }
 
-                /* FIXME: Need some mechanism to revoke permissions:
-                   currently if the filesystem suddenly changes the
-                   file mode, we will not be informed about it, and
-                   continue to allow access to the file/directory.
-
-                   This is actually not so grave, since the user can
-                   simply keep access to the file/directory anyway by
-                   keeping it open... */
+                /* Note: the opposite of the above test does not
+                   exist.  So if permissions are revoked this won't be
+                   noticed immediately, only after the attribute
+                   timeout has expired */
 
                 return err;
         } else {
@@ -691,7 +777,12 @@ static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
         struct page *page;
         struct inode *inode = file->f_dentry->d_inode;
         struct fuse_conn *fc = get_fuse_conn(inode);
-        struct fuse_req *req = fuse_get_request(fc);
+        struct fuse_req *req;
+
+        if (is_bad_inode(inode))
+                return -EIO;
+
+        req = fuse_get_request(fc);
         if (!req)
                 return -EINTR;
 
@@ -806,6 +897,15 @@ static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
         }
 }
 
+/*
+ * Set attributes, and at the same time refresh them.
+ *
+ * Truncation is slightly complicated, because the 'truncate' request
+ * may fail, in which case we don't want to touch the mapping.
+ * vmtruncate() doesn't allow for this case.  So do the rlimit
+ * checking by hand and call vmtruncate() only after the file has
+ * actually been truncated.
+ */
 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 {
         struct inode *inode = entry->d_inode;
@@ -883,23 +983,6 @@ static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
         return err;
 }
 
-static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
-                                  struct nameidata *nd)
-{
-        struct inode *inode;
-        int err;
-
-        err = fuse_lookup_iget(dir, entry, &inode);
-        if (err)
-                return ERR_PTR(err);
-        if (inode && dir_alias(inode)) {
-                iput(inode);
-                return ERR_PTR(-EIO);
-        }
-        d_add(entry, inode);
-        return NULL;
-}
-
 static int fuse_setxattr(struct dentry *entry, const char *name,
                          const void *value, size_t size, int flags)
 {
@@ -909,9 +992,6 @@ static int fuse_setxattr(struct dentry *entry, const char *name,
         struct fuse_setxattr_in inarg;
         int err;
 
-        if (size > FUSE_XATTR_SIZE_MAX)
-                return -E2BIG;
-
         if (fc->no_setxattr)
                 return -EOPNOTSUPP;
 
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 2ca86141d13a..05dedddf4289 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -163,6 +163,9 @@ static int fuse_flush(struct file *file)
         struct fuse_flush_in inarg;
         int err;
 
+        if (is_bad_inode(inode))
+                return -EIO;
+
         if (fc->no_flush)
                 return 0;
 
@@ -199,6 +202,9 @@ int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
         struct fuse_fsync_in inarg;
         int err;
 
+        if (is_bad_inode(inode))
+                return -EIO;
+
         if ((!isdir && fc->no_fsync) || (isdir && fc->no_fsyncdir))
                 return 0;
 
@@ -272,16 +278,22 @@ static int fuse_readpage(struct file *file, struct page *page)
 {
         struct inode *inode = page->mapping->host;
         struct fuse_conn *fc = get_fuse_conn(inode);
-        loff_t pos = (loff_t) page->index << PAGE_CACHE_SHIFT;
-        struct fuse_req *req = fuse_get_request(fc);
-        int err = -EINTR;
+        struct fuse_req *req;
+        int err;
+
+        err = -EIO;
+        if (is_bad_inode(inode))
+                goto out;
+
+        err = -EINTR;
+        req = fuse_get_request(fc);
         if (!req)
                 goto out;
 
         req->out.page_zeroing = 1;
         req->num_pages = 1;
         req->pages[0] = page;
-        fuse_send_read(req, file, inode, pos, PAGE_CACHE_SIZE);
+        fuse_send_read(req, file, inode, page_offset(page), PAGE_CACHE_SIZE);
         err = req->out.h.error;
         fuse_put_request(fc, req);
         if (!err)
@@ -295,7 +307,7 @@ static int fuse_readpage(struct file *file, struct page *page)
 static int fuse_send_readpages(struct fuse_req *req, struct file *file,
                                struct inode *inode)
 {
-        loff_t pos = (loff_t) req->pages[0]->index << PAGE_CACHE_SHIFT;
+        loff_t pos = page_offset(req->pages[0]);
         size_t count = req->num_pages << PAGE_CACHE_SHIFT;
         unsigned i;
         req->out.page_zeroing = 1;
@@ -345,6 +357,10 @@ static int fuse_readpages(struct file *file, struct address_space *mapping,
         struct fuse_conn *fc = get_fuse_conn(inode);
         struct fuse_readpages_data data;
         int err;
+
+        if (is_bad_inode(inode))
+                return -EIO;
+
         data.file = file;
         data.inode = inode;
         data.req = fuse_get_request(fc);
@@ -402,8 +418,13 @@ static int fuse_commit_write(struct file *file, struct page *page,
         unsigned count = to - offset;
         struct inode *inode = page->mapping->host;
         struct fuse_conn *fc = get_fuse_conn(inode);
-        loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + offset;
-        struct fuse_req *req = fuse_get_request(fc);
+        loff_t pos = page_offset(page) + offset;
+        struct fuse_req *req;
+
+        if (is_bad_inode(inode))
+                return -EIO;
+
+        req = fuse_get_request(fc);
         if (!req)
                 return -EINTR;
 
@@ -454,7 +475,7 @@ static int fuse_get_user_pages(struct fuse_req *req, const char __user *buf,
 
         nbytes = min(nbytes, (unsigned) FUSE_MAX_PAGES_PER_REQ << PAGE_SHIFT);
         npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        npages = min(npages, FUSE_MAX_PAGES_PER_REQ);
+        npages = min(max(npages, 1), FUSE_MAX_PAGES_PER_REQ);
         down_read(&current->mm->mmap_sem);
         npages = get_user_pages(current, current->mm, user_addr, npages, write,
                                 0, req->pages, NULL);
@@ -475,12 +496,16 @@ static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
         size_t nmax = write ? fc->max_write : fc->max_read;
         loff_t pos = *ppos;
         ssize_t res = 0;
-        struct fuse_req *req = fuse_get_request(fc);
+        struct fuse_req *req;
+
+        if (is_bad_inode(inode))
+                return -EIO;
+
+        req = fuse_get_request(fc);
         if (!req)
                 return -EINTR;
 
         while (count) {
-                size_t tmp;
                 size_t nres;
                 size_t nbytes = min(count, nmax);
                 int err = fuse_get_user_pages(req, buf, nbytes, !write);
@@ -488,8 +513,8 @@ static ssize_t fuse_direct_io(struct file *file, const char __user *buf,
                         res = err;
                         break;
                 }
-                tmp = (req->num_pages << PAGE_SHIFT) - req->page_offset;
-                nbytes = min(nbytes, tmp);
+                nbytes = (req->num_pages << PAGE_SHIFT) - req->page_offset;
+                nbytes = min(count, nbytes);
                 if (write)
                         nres = fuse_send_write(req, file, inode, pos, nbytes);
                 else
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 0ea5301f86be..74c8d098a14a 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -21,6 +21,9 @@
 /** If more requests are outstanding, then the operation will block */
 #define FUSE_MAX_OUTSTANDING 10
 
+/** It could be as large as PATH_MAX, but would that have any uses? */
+#define FUSE_NAME_MAX 1024
+
 /** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
     module will check permissions based on the file mode.  Otherwise no
     permission checking is done in the kernel */
@@ -108,9 +111,6 @@ struct fuse_out {
         struct fuse_arg args[3];
 };
 
-struct fuse_req;
-struct fuse_conn;
-
 /**
  * A request to the client
  */
@@ -159,7 +159,8 @@ struct fuse_req {
         union {
                 struct fuse_forget_in forget_in;
                 struct fuse_release_in release_in;
-                struct fuse_init_in_out init_in_out;
+                struct fuse_init_in init_in;
+                struct fuse_init_out init_out;
         } misc;
 
         /** page vector */
@@ -272,6 +273,9 @@ struct fuse_conn {
         /** Is create not implemented by fs? */
         unsigned no_create : 1;
 
+        /** Negotiated minor version */
+        unsigned minor;
+
         /** Backing dev info */
         struct backing_dev_info bdi;
 };
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index e69a546844d0..04c80cc957a3 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -135,12 +135,8 @@ static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr)
                 fuse_init_common(inode);
                 init_special_inode(inode, inode->i_mode,
                                    new_decode_dev(attr->rdev));
-        } else {
-                /* Don't let user create weird files */
-                inode->i_mode = S_IFREG;
-                fuse_init_common(inode);
-                fuse_init_file_inode(inode);
-        }
+        } else
+                BUG();
 }
 
 static int fuse_inode_eq(struct inode *inode, void *_nodeidp)
@@ -218,6 +214,7 @@ static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr
 {
         stbuf->f_type    = FUSE_SUPER_MAGIC;
         stbuf->f_bsize   = attr->bsize;
+        stbuf->f_frsize  = attr->frsize;
         stbuf->f_blocks  = attr->blocks;
         stbuf->f_bfree   = attr->bfree;
         stbuf->f_bavail  = attr->bavail;
@@ -238,10 +235,12 @@ static int fuse_statfs(struct super_block *sb, struct kstatfs *buf)
         if (!req)
                 return -EINTR;
 
+        memset(&outarg, 0, sizeof(outarg));
         req->in.numargs = 0;
         req->in.h.opcode = FUSE_STATFS;
         req->out.numargs = 1;
-        req->out.args[0].size = sizeof(outarg);
+        req->out.args[0].size =
+                fc->minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(outarg);
         req->out.args[0].value = &outarg;
         request_send(fc, req);
         err = req->out.h.error;
@@ -482,7 +481,6 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
         fc->max_read = d.max_read;
         if (fc->max_read / PAGE_CACHE_SIZE < fc->bdi.ra_pages)
                 fc->bdi.ra_pages = fc->max_read / PAGE_CACHE_SIZE;
-        fc->max_write = FUSE_MAX_IN / 2;
 
         err = -ENOMEM;
         root = get_root_inode(sb, d.rootmode);