drop unused dentry argument to ->fsync

[safe/jmp/linux-2.6] / fs / fuse / dir.c

diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 1e941b3..3cdc5f7 100644 (file)
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -1,6 +1,6 @@
 /*
   FUSE: Filesystem in Userspace
 /*
   FUSE: Filesystem in Userspace

-  Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
+  Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>

 
   This program can be distributed under the terms of the GNU GPL.
   See the file COPYING.
 
   This program can be distributed under the terms of the GNU GPL.
   See the file COPYING.


@@ -97,7 +97,7 @@ void fuse_invalidate_attr(struct inode *inode)
  * timeout is unknown (unlink, rmdir, rename and in some cases
  * lookup)
  */
  * timeout is unknown (unlink, rmdir, rename and in some cases
  * lookup)
  */

-static void fuse_invalidate_entry_cache(struct dentry *entry)
+void fuse_invalidate_entry_cache(struct dentry *entry)

 {
        fuse_dentry_settime(entry, 0);
 }
 {
        fuse_dentry_settime(entry, 0);
 }


@@ -112,20 +112,39 @@ static void fuse_invalidate_entry(struct dentry *entry)
        fuse_invalidate_entry_cache(entry);
 }
 
        fuse_invalidate_entry_cache(entry);
 }
 

-static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
-                            struct dentry *entry,
+static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
+                            u64 nodeid, struct qstr *name,

                             struct fuse_entry_out *outarg)
 {
                             struct fuse_entry_out *outarg)
 {

+       memset(outarg, 0, sizeof(struct fuse_entry_out));

        req->in.h.opcode = FUSE_LOOKUP;
        req->in.h.opcode = FUSE_LOOKUP;

-       req->in.h.nodeid = get_node_id(dir);
+       req->in.h.nodeid = nodeid;

        req->in.numargs = 1;
        req->in.numargs = 1;

-       req->in.args[0].size = entry->d_name.len + 1;
-       req->in.args[0].value = entry->d_name.name;
+       req->in.args[0].size = name->len + 1;
+       req->in.args[0].value = name->name;

        req->out.numargs = 1;
        req->out.numargs = 1;

-       req->out.args[0].size = sizeof(struct fuse_entry_out);
+       if (fc->minor < 9)
+               req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
+       else
+               req->out.args[0].size = sizeof(struct fuse_entry_out);

        req->out.args[0].value = outarg;
 }
 
        req->out.args[0].value = outarg;
 }
 

+u64 fuse_get_attr_version(struct fuse_conn *fc)
+{
+       u64 curr_version;
+
+       /*
+        * The spin lock isn't actually needed on 64bit archs, but we
+        * don't yet care too much about such optimizations.
+        */
+       spin_lock(&fc->lock);
+       curr_version = fc->attr_version;
+       spin_unlock(&fc->lock);
+
+       return curr_version;
+}
+

 /*
  * Check whether the dentry is still valid
  *
 /*
  * Check whether the dentry is still valid
  *


@@ -165,13 +184,12 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                        return 0;
                }
 
                        return 0;
                }
 

-               spin_lock(&fc->lock);
-               attr_version = fc->attr_version;
-               spin_unlock(&fc->lock);
+               attr_version = fuse_get_attr_version(fc);

 
                parent = dget_parent(entry);
 
                parent = dget_parent(entry);

-               fuse_lookup_init(req, parent->d_inode, entry, &outarg);
-               request_send(fc, req);
+               fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
+                                &entry->d_name, &outarg);
+               fuse_request_send(fc, req);

                dput(parent);
                err = req->out.h.error;
                fuse_put_request(fc, req);
                dput(parent);
                err = req->out.h.error;
                fuse_put_request(fc, req);


@@ -186,7 +204,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                                return 0;
                        }
                        spin_lock(&fc->lock);
                                return 0;
                        }
                        spin_lock(&fc->lock);

-                       fi->nlookup ++;
+                       fi->nlookup++;

                        spin_unlock(&fc->lock);
                }
                fuse_put_request(fc, forget_req);
                        spin_unlock(&fc->lock);
                }
                fuse_put_request(fc, forget_req);


@@ -206,7 +224,7 @@ static int invalid_nodeid(u64 nodeid)
        return !nodeid || nodeid == FUSE_ROOT_ID;
 }
 
        return !nodeid || nodeid == FUSE_ROOT_ID;
 }
 

-static struct dentry_operations fuse_dentry_operations = {
+const struct dentry_operations fuse_dentry_operations = {

        .d_revalidate   = fuse_dentry_revalidate,
 };
 
        .d_revalidate   = fuse_dentry_revalidate,
 };
 


@@ -220,100 +238,127 @@ int fuse_valid_type(int m)
  * Add a directory inode to a dentry, ensuring that no other dentry
  * refers to this inode.  Called with fc->inst_mutex.
  */
  * Add a directory inode to a dentry, ensuring that no other dentry
  * refers to this inode.  Called with fc->inst_mutex.
  */

-static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
+static struct dentry *fuse_d_add_directory(struct dentry *entry,
+                                          struct inode *inode)

 {
        struct dentry *alias = d_find_alias(inode);
 {
        struct dentry *alias = d_find_alias(inode);

-       if (alias) {
+       if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {

                /* This tries to shrink the subtree below alias */
                fuse_invalidate_entry(alias);
                dput(alias);
                if (!list_empty(&inode->i_dentry))
                /* This tries to shrink the subtree below alias */
                fuse_invalidate_entry(alias);
                dput(alias);
                if (!list_empty(&inode->i_dentry))

-                       return -EBUSY;
+                       return ERR_PTR(-EBUSY);
+       } else {
+               dput(alias);

        }
        }

-       d_add(entry, inode);
-       return 0;
+       return d_splice_alias(inode, entry);

 }
 
 }
 

-static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
-                                 struct nameidata *nd)
+int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
+                    struct fuse_entry_out *outarg, struct inode **inode)

 {
 {

-       int err;
-       struct fuse_entry_out outarg;
-       struct inode *inode = NULL;
-       struct fuse_conn *fc = get_fuse_conn(dir);
+       struct fuse_conn *fc = get_fuse_conn_super(sb);

        struct fuse_req *req;
        struct fuse_req *forget_req;
        u64 attr_version;
        struct fuse_req *req;
        struct fuse_req *forget_req;
        u64 attr_version;

+       int err;

 
 

-       if (entry->d_name.len > FUSE_NAME_MAX)
-               return ERR_PTR(-ENAMETOOLONG);
+       *inode = NULL;
+       err = -ENAMETOOLONG;
+       if (name->len > FUSE_NAME_MAX)
+               goto out;

 
        req = fuse_get_req(fc);
 
        req = fuse_get_req(fc);

+       err = PTR_ERR(req);

        if (IS_ERR(req))
        if (IS_ERR(req))

-               return ERR_PTR(PTR_ERR(req));
+               goto out;

 
        forget_req = fuse_get_req(fc);
 
        forget_req = fuse_get_req(fc);

+       err = PTR_ERR(forget_req);

        if (IS_ERR(forget_req)) {
                fuse_put_request(fc, req);
        if (IS_ERR(forget_req)) {
                fuse_put_request(fc, req);

-               return ERR_PTR(PTR_ERR(forget_req));
+               goto out;

        }
 
        }
 

-       spin_lock(&fc->lock);
-       attr_version = fc->attr_version;
-       spin_unlock(&fc->lock);
+       attr_version = fuse_get_attr_version(fc);

 
 

-       fuse_lookup_init(req, dir, entry, &outarg);
-       request_send(fc, req);
+       fuse_lookup_init(fc, req, nodeid, name, outarg);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        /* Zero nodeid is same as -ENOENT, but with valid timeout */
        err = req->out.h.error;
        fuse_put_request(fc, req);
        /* Zero nodeid is same as -ENOENT, but with valid timeout */

-       if (!err && outarg.nodeid &&
-           (invalid_nodeid(outarg.nodeid) ||
-            !fuse_valid_type(outarg.attr.mode)))
-               err = -EIO;
-       if (!err && outarg.nodeid) {
-               inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
-                                 &outarg.attr, entry_attr_timeout(&outarg),
-                                 attr_version);
-               if (!inode) {
-                       fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
-                       return ERR_PTR(-ENOMEM);
-               }
+       if (err || !outarg->nodeid)
+               goto out_put_forget;
+
+       err = -EIO;
+       if (!outarg->nodeid)
+               goto out_put_forget;
+       if (!fuse_valid_type(outarg->attr.mode))
+               goto out_put_forget;
+
+       *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
+                          &outarg->attr, entry_attr_timeout(outarg),
+                          attr_version);
+       err = -ENOMEM;
+       if (!*inode) {
+               fuse_send_forget(fc, forget_req, outarg->nodeid, 1);
+               goto out;

        }
        }

+       err = 0;
+
+ out_put_forget:

        fuse_put_request(fc, forget_req);
        fuse_put_request(fc, forget_req);

-       if (err && err != -ENOENT)
-               return ERR_PTR(err);
+ out:
+       return err;
+}
+
+static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
+                                 struct nameidata *nd)
+{
+       int err;
+       struct fuse_entry_out outarg;
+       struct inode *inode;
+       struct dentry *newent;
+       struct fuse_conn *fc = get_fuse_conn(dir);
+       bool outarg_valid = true;
+
+       err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
+                              &outarg, &inode);
+       if (err == -ENOENT) {
+               outarg_valid = false;
+               err = 0;
+       }
+       if (err)
+               goto out_err;
+
+       err = -EIO;
+       if (inode && get_node_id(inode) == FUSE_ROOT_ID)
+               goto out_iput;

 
        if (inode && S_ISDIR(inode->i_mode)) {
                mutex_lock(&fc->inst_mutex);
 
        if (inode && S_ISDIR(inode->i_mode)) {
                mutex_lock(&fc->inst_mutex);

-               err = fuse_d_add_directory(entry, inode);
+               newent = fuse_d_add_directory(entry, inode);

                mutex_unlock(&fc->inst_mutex);
                mutex_unlock(&fc->inst_mutex);

-               if (err) {
-                       iput(inode);
-                       return ERR_PTR(err);
-               }
-       } else
-               d_add(entry, inode);
+               err = PTR_ERR(newent);
+               if (IS_ERR(newent))
+                       goto out_iput;
+       } else {
+               newent = d_splice_alias(inode, entry);
+       }

 
 

+       entry = newent ? newent : entry;

        entry->d_op = &fuse_dentry_operations;
        entry->d_op = &fuse_dentry_operations;

-       if (!err)
+       if (outarg_valid)

                fuse_change_entry_timeout(entry, &outarg);
        else
                fuse_invalidate_entry_cache(entry);
                fuse_change_entry_timeout(entry, &outarg);
        else
                fuse_invalidate_entry_cache(entry);

-       return NULL;
-}

 
 

-/*
- * Synchronous release for the case when something goes wrong in CREATE_OPEN
- */
-static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
-                             u64 nodeid, int flags)
-{
-       fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
-       ff->reserved_req->force = 1;
-       request_send(fc, ff->reserved_req);
-       fuse_put_request(fc, ff->reserved_req);
-       kfree(ff);
+       return newent;
+
+ out_iput:
+       iput(inode);
+ out_err:
+       return ERR_PTR(err);

 }
 
 /*
 }
 
 /*


@@ -330,7 +375,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
        struct fuse_conn *fc = get_fuse_conn(dir);
        struct fuse_req *req;
        struct fuse_req *forget_req;
        struct fuse_conn *fc = get_fuse_conn(dir);
        struct fuse_req *req;
        struct fuse_req *forget_req;

-       struct fuse_open_in inarg;
+       struct fuse_create_in inarg;

        struct fuse_open_out outopen;
        struct fuse_entry_out outentry;
        struct fuse_file *ff;
        struct fuse_open_out outopen;
        struct fuse_entry_out outentry;
        struct fuse_file *ff;


@@ -340,6 +385,9 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
        if (fc->no_create)
                return -ENOSYS;
 
        if (fc->no_create)
                return -ENOSYS;
 

+       if (flags & O_DIRECT)
+               return -EINVAL;
+

        forget_req = fuse_get_req(fc);
        if (IS_ERR(forget_req))
                return PTR_ERR(forget_req);
        forget_req = fuse_get_req(fc);
        if (IS_ERR(forget_req))
                return PTR_ERR(forget_req);


@@ -350,27 +398,36 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
                goto out_put_forget_req;
 
        err = -ENOMEM;
                goto out_put_forget_req;
 
        err = -ENOMEM;

-       ff = fuse_file_alloc();
+       ff = fuse_file_alloc(fc);

        if (!ff)
                goto out_put_request;
 
        if (!ff)
                goto out_put_request;
 

+       if (!fc->dont_mask)
+               mode &= ~current_umask();
+

        flags &= ~O_NOCTTY;
        memset(&inarg, 0, sizeof(inarg));
        flags &= ~O_NOCTTY;
        memset(&inarg, 0, sizeof(inarg));

+       memset(&outentry, 0, sizeof(outentry));

        inarg.flags = flags;
        inarg.mode = mode;
        inarg.flags = flags;
        inarg.mode = mode;

+       inarg.umask = current_umask();

        req->in.h.opcode = FUSE_CREATE;
        req->in.h.nodeid = get_node_id(dir);
        req->in.numargs = 2;
        req->in.h.opcode = FUSE_CREATE;
        req->in.h.nodeid = get_node_id(dir);
        req->in.numargs = 2;

-       req->in.args[0].size = sizeof(inarg);
+       req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
+                                               sizeof(inarg);

        req->in.args[0].value = &inarg;
        req->in.args[1].size = entry->d_name.len + 1;
        req->in.args[1].value = entry->d_name.name;
        req->out.numargs = 2;
        req->in.args[0].value = &inarg;
        req->in.args[1].size = entry->d_name.len + 1;
        req->in.args[1].value = entry->d_name.name;
        req->out.numargs = 2;

-       req->out.args[0].size = sizeof(outentry);
+       if (fc->minor < 9)
+               req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
+       else
+               req->out.args[0].size = sizeof(outentry);

        req->out.args[0].value = &outentry;
        req->out.args[1].size = sizeof(outopen);
        req->out.args[1].value = &outopen;
        req->out.args[0].value = &outentry;
        req->out.args[1].size = sizeof(outopen);
        req->out.args[1].value = &outopen;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        if (err) {
                if (err == -ENOSYS)
        err = req->out.h.error;
        if (err) {
                if (err == -ENOSYS)


@@ -383,25 +440,28 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
                goto out_free_ff;
 
        fuse_put_request(fc, req);
                goto out_free_ff;
 
        fuse_put_request(fc, req);

+       ff->fh = outopen.fh;
+       ff->nodeid = outentry.nodeid;
+       ff->open_flags = outopen.open_flags;

        inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
                          &outentry.attr, entry_attr_timeout(&outentry), 0);
        if (!inode) {
                flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
        inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
                          &outentry.attr, entry_attr_timeout(&outentry), 0);
        if (!inode) {
                flags &= ~(O_CREAT | O_EXCL | O_TRUNC);

-               ff->fh = outopen.fh;
-               fuse_sync_release(fc, ff, outentry.nodeid, flags);
+               fuse_sync_release(ff, flags);

                fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
                return -ENOMEM;
        }
        fuse_put_request(fc, forget_req);
        d_instantiate(entry, inode);
        fuse_change_entry_timeout(entry, &outentry);
                fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
                return -ENOMEM;
        }
        fuse_put_request(fc, forget_req);
        d_instantiate(entry, inode);
        fuse_change_entry_timeout(entry, &outentry);

+       fuse_invalidate_attr(dir);

        file = lookup_instantiate_filp(nd, entry, generic_file_open);
        if (IS_ERR(file)) {
        file = lookup_instantiate_filp(nd, entry, generic_file_open);
        if (IS_ERR(file)) {

-               ff->fh = outopen.fh;
-               fuse_sync_release(fc, ff, outentry.nodeid, flags);
+               fuse_sync_release(ff, flags);

                return PTR_ERR(file);
        }
                return PTR_ERR(file);
        }

-       fuse_finish_open(inode, file, ff, &outopen);
+       file->private_data = fuse_file_get(ff);
+       fuse_finish_open(inode, file);

        return 0;
 
  out_free_ff:
        return 0;
 
  out_free_ff:


@@ -431,11 +491,15 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
                return PTR_ERR(forget_req);
        }
 
                return PTR_ERR(forget_req);
        }
 

+       memset(&outarg, 0, sizeof(outarg));

        req->in.h.nodeid = get_node_id(dir);
        req->out.numargs = 1;
        req->in.h.nodeid = get_node_id(dir);
        req->out.numargs = 1;

-       req->out.args[0].size = sizeof(outarg);
+       if (fc->minor < 9)
+               req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
+       else
+               req->out.args[0].size = sizeof(outarg);

        req->out.args[0].value = &outarg;
        req->out.args[0].value = &outarg;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err)
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err)


@@ -490,12 +554,17 @@ static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
        if (IS_ERR(req))
                return PTR_ERR(req);
 
        if (IS_ERR(req))
                return PTR_ERR(req);
 

+       if (!fc->dont_mask)
+               mode &= ~current_umask();
+

        memset(&inarg, 0, sizeof(inarg));
        inarg.mode = mode;
        inarg.rdev = new_encode_dev(rdev);
        memset(&inarg, 0, sizeof(inarg));
        inarg.mode = mode;
        inarg.rdev = new_encode_dev(rdev);

+       inarg.umask = current_umask();

        req->in.h.opcode = FUSE_MKNOD;
        req->in.numargs = 2;
        req->in.h.opcode = FUSE_MKNOD;
        req->in.numargs = 2;

-       req->in.args[0].size = sizeof(inarg);
+       req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
+                                               sizeof(inarg);

        req->in.args[0].value = &inarg;
        req->in.args[1].size = entry->d_name.len + 1;
        req->in.args[1].value = entry->d_name.name;
        req->in.args[0].value = &inarg;
        req->in.args[1].size = entry->d_name.len + 1;
        req->in.args[1].value = entry->d_name.name;


@@ -522,8 +591,12 @@ static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
        if (IS_ERR(req))
                return PTR_ERR(req);
 
        if (IS_ERR(req))
                return PTR_ERR(req);
 

+       if (!fc->dont_mask)
+               mode &= ~current_umask();
+

        memset(&inarg, 0, sizeof(inarg));
        inarg.mode = mode;
        memset(&inarg, 0, sizeof(inarg));
        inarg.mode = mode;

+       inarg.umask = current_umask();

        req->in.h.opcode = FUSE_MKDIR;
        req->in.numargs = 2;
        req->in.args[0].size = sizeof(inarg);
        req->in.h.opcode = FUSE_MKDIR;
        req->in.numargs = 2;
        req->in.args[0].size = sizeof(inarg);


@@ -564,15 +637,17 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry)
        req->in.numargs = 1;
        req->in.args[0].size = entry->d_name.len + 1;
        req->in.args[0].value = entry->d_name.name;
        req->in.numargs = 1;
        req->in.args[0].size = entry->d_name.len + 1;
        req->in.args[0].value = entry->d_name.name;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {
                struct inode *inode = entry->d_inode;
 
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {
                struct inode *inode = entry->d_inode;
 

-               /* Set nlink to zero so the inode can be cleared, if
-                   the inode does have more links this will be
-                   discovered at the next lookup/getattr */
+               /*
+                * Set nlink to zero so the inode can be cleared, if the inode
+                * does have more links this will be discovered at the next
+                * lookup/getattr.
+                */

                clear_nlink(inode);
                fuse_invalidate_attr(inode);
                fuse_invalidate_attr(dir);
                clear_nlink(inode);
                fuse_invalidate_attr(inode);
                fuse_invalidate_attr(dir);


@@ -595,7 +670,7 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry)
        req->in.numargs = 1;
        req->in.args[0].size = entry->d_name.len + 1;
        req->in.args[0].value = entry->d_name.name;
        req->in.numargs = 1;
        req->in.args[0].size = entry->d_name.len + 1;
        req->in.args[0].value = entry->d_name.name;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {


@@ -628,17 +703,22 @@ static int fuse_rename(struct inode *olddir, struct dentry *oldent,
        req->in.args[1].value = oldent->d_name.name;
        req->in.args[2].size = newent->d_name.len + 1;
        req->in.args[2].value = newent->d_name.name;
        req->in.args[1].value = oldent->d_name.name;
        req->in.args[2].size = newent->d_name.len + 1;
        req->in.args[2].value = newent->d_name.name;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {

+               /* ctime changes */
+               fuse_invalidate_attr(oldent->d_inode);
+

                fuse_invalidate_attr(olddir);
                if (olddir != newdir)
                        fuse_invalidate_attr(newdir);
 
                /* newent will end up negative */
                fuse_invalidate_attr(olddir);
                if (olddir != newdir)
                        fuse_invalidate_attr(newdir);
 
                /* newent will end up negative */

-               if (newent->d_inode)
+               if (newent->d_inode) {
+                       fuse_invalidate_attr(newent->d_inode);

                        fuse_invalidate_entry_cache(newent);
                        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
        } else if (err == -EINTR) {
                /* If request was interrupted, DEITY only knows if the
                   rename actually took place.  If the invalidation


@@ -719,11 +799,10 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
        if (IS_ERR(req))
                return PTR_ERR(req);
 
        if (IS_ERR(req))
                return PTR_ERR(req);
 

-       spin_lock(&fc->lock);
-       attr_version = fc->attr_version;
-       spin_unlock(&fc->lock);
+       attr_version = fuse_get_attr_version(fc);

 
        memset(&inarg, 0, sizeof(inarg));
 
        memset(&inarg, 0, sizeof(inarg));

+       memset(&outarg, 0, sizeof(outarg));

        /* Directories have separate file-handle space */
        if (file && S_ISREG(inode->i_mode)) {
                struct fuse_file *ff = file->private_data;
        /* Directories have separate file-handle space */
        if (file && S_ISREG(inode->i_mode)) {
                struct fuse_file *ff = file->private_data;


@@ -737,9 +816,12 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
        req->in.args[0].size = sizeof(inarg);
        req->in.args[0].value = &inarg;
        req->out.numargs = 1;
        req->in.args[0].size = sizeof(inarg);
        req->in.args[0].value = &inarg;
        req->out.numargs = 1;

-       req->out.args[0].size = sizeof(outarg);
+       if (fc->minor < 9)
+               req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
+       else
+               req->out.args[0].size = sizeof(outarg);

        req->out.args[0].value = &outarg;
        req->out.args[0].value = &outarg;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (!err) {


@@ -757,6 +839,68 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
        return err;
 }
 
        return err;
 }
 

+int fuse_update_attributes(struct inode *inode, struct kstat *stat,
+                          struct file *file, bool *refreshed)
+{
+       struct fuse_inode *fi = get_fuse_inode(inode);
+       int err;
+       bool r;
+
+       if (fi->i_time < get_jiffies_64()) {
+               r = true;
+               err = fuse_do_getattr(inode, stat, file);
+       } else {
+               r = false;
+               err = 0;
+               if (stat) {
+                       generic_fillattr(inode, stat);
+                       stat->mode = fi->orig_i_mode;
+               }
+       }
+
+       if (refreshed != NULL)
+               *refreshed = r;
+
+       return err;
+}
+
+int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
+                            struct qstr *name)
+{
+       int err = -ENOTDIR;
+       struct inode *parent;
+       struct dentry *dir;
+       struct dentry *entry;
+
+       parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
+       if (!parent)
+               return -ENOENT;
+
+       mutex_lock(&parent->i_mutex);
+       if (!S_ISDIR(parent->i_mode))
+               goto unlock;
+
+       err = -ENOENT;
+       dir = d_find_alias(parent);
+       if (!dir)
+               goto unlock;
+
+       entry = d_lookup(dir, name);
+       dput(dir);
+       if (!entry)
+               goto unlock;
+
+       fuse_invalidate_attr(parent);
+       fuse_invalidate_entry(entry);
+       dput(entry);
+       err = 0;
+
+ unlock:
+       mutex_unlock(&parent->i_mutex);
+       iput(parent);
+       return err;
+}
+

 /*
  * Calling into a user-controlled filesystem gives the filesystem
  * daemon ptrace-like capabilities over the requester process.  This
 /*
  * Calling into a user-controlled filesystem gives the filesystem
  * daemon ptrace-like capabilities over the requester process.  This


@@ -772,18 +916,25 @@ static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
  */
 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
 {
  */
 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
 {

+       const struct cred *cred;
+       int ret;
+

        if (fc->flags & FUSE_ALLOW_OTHER)
                return 1;
 
        if (fc->flags & FUSE_ALLOW_OTHER)
                return 1;
 

-       if (task->euid == fc->user_id &&
-           task->suid == fc->user_id &&
-           task->uid == fc->user_id &&
-           task->egid == fc->group_id &&
-           task->sgid == fc->group_id &&
-           task->gid == fc->group_id)
-               return 1;
+       rcu_read_lock();
+       ret = 0;
+       cred = __task_cred(task);
+       if (cred->euid == fc->user_id &&
+           cred->suid == fc->user_id &&
+           cred->uid  == fc->user_id &&
+           cred->egid == fc->group_id &&
+           cred->sgid == fc->group_id &&
+           cred->gid  == fc->group_id)
+               ret = 1;
+       rcu_read_unlock();

 
 

-       return 0;
+       return ret;

 }
 
 static int fuse_access(struct inode *inode, int mask)
 }
 
 static int fuse_access(struct inode *inode, int mask)


@@ -801,13 +952,13 @@ static int fuse_access(struct inode *inode, int mask)
                return PTR_ERR(req);
 
        memset(&inarg, 0, sizeof(inarg));
                return PTR_ERR(req);
 
        memset(&inarg, 0, sizeof(inarg));

-       inarg.mask = mask;
+       inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);

        req->in.h.opcode = FUSE_ACCESS;
        req->in.h.nodeid = get_node_id(inode);
        req->in.numargs = 1;
        req->in.args[0].size = sizeof(inarg);
        req->in.args[0].value = &inarg;
        req->in.h.opcode = FUSE_ACCESS;
        req->in.h.nodeid = get_node_id(inode);
        req->in.numargs = 1;
        req->in.args[0].size = sizeof(inarg);
        req->in.args[0].value = &inarg;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err == -ENOSYS) {
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err == -ENOSYS) {


@@ -830,7 +981,7 @@ static int fuse_access(struct inode *inode, int mask)
  * access request is sent.  Execute permission is still checked
  * locally based on file mode.
  */
  * 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)
+static int fuse_permission(struct inode *inode, int mask)

 {
        struct fuse_conn *fc = get_fuse_conn(inode);
        bool refreshed = false;
 {
        struct fuse_conn *fc = get_fuse_conn(inode);
        bool refreshed = false;


@@ -844,18 +995,13 @@ static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
         */
        if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
            ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
         */
        if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
            ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {

-               struct fuse_inode *fi = get_fuse_inode(inode);
-               if (fi->i_time < get_jiffies_64()) {
-                       err = fuse_do_getattr(inode, NULL, NULL);
-                       if (err)
-                               return err;
-
-                       refreshed = true;
-               }
+               err = fuse_update_attributes(inode, NULL, NULL, &refreshed);
+               if (err)
+                       return err;

        }
 
        if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
        }
 
        if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {

-               int err = generic_permission(inode, mask, NULL);
+               err = generic_permission(inode, mask, NULL);

 
                /* If permission is denied, try to refresh file
                   attributes.  This is also needed, because the root
 
                /* If permission is denied, try to refresh file
                   attributes.  This is also needed, because the root


@@ -870,7 +1016,7 @@ static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
                   exist.  So if permissions are revoked this won't be
                   noticed immediately, only after the attribute
                   timeout has expired */
                   exist.  So if permissions are revoked this won't be
                   noticed immediately, only after the attribute
                   timeout has expired */

-       } else if (nd && (nd->flags & (LOOKUP_ACCESS | LOOKUP_CHDIR))) {
+       } else if (mask & MAY_ACCESS) {

                err = fuse_access(inode, mask);
        } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
                if (!(inode->i_mode & S_IXUGO)) {
                err = fuse_access(inode, mask);
        } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
                if (!(inode->i_mode & S_IXUGO)) {


@@ -917,7 +1063,6 @@ static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
        struct page *page;
        struct inode *inode = file->f_path.dentry->d_inode;
        struct fuse_conn *fc = get_fuse_conn(inode);
        struct page *page;
        struct inode *inode = file->f_path.dentry->d_inode;
        struct fuse_conn *fc = get_fuse_conn(inode);

-       struct fuse_file *ff = file->private_data;

        struct fuse_req *req;
 
        if (is_bad_inode(inode))
        struct fuse_req *req;
 
        if (is_bad_inode(inode))


@@ -932,10 +1077,11 @@ static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
                fuse_put_request(fc, req);
                return -ENOMEM;
        }
                fuse_put_request(fc, req);
                return -ENOMEM;
        }

+       req->out.argpages = 1;

        req->num_pages = 1;
        req->pages[0] = page;
        req->num_pages = 1;
        req->pages[0] = page;

-       fuse_read_fill(req, ff, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
-       request_send(fc, req);
+       fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);
+       fuse_request_send(fc, req);

        nbytes = req->out.args[0].size;
        err = req->out.h.error;
        fuse_put_request(fc, req);
        nbytes = req->out.args[0].size;
        err = req->out.h.error;
        fuse_put_request(fc, req);


@@ -956,7 +1102,7 @@ static char *read_link(struct dentry *dentry)
        char *link;
 
        if (IS_ERR(req))
        char *link;
 
        if (IS_ERR(req))

-               return ERR_PTR(PTR_ERR(req));
+               return ERR_CAST(req);

 
        link = (char *) __get_free_page(GFP_KERNEL);
        if (!link) {
 
        link = (char *) __get_free_page(GFP_KERNEL);
        if (!link) {


@@ -969,7 +1115,7 @@ static char *read_link(struct dentry *dentry)
        req->out.numargs = 1;
        req->out.args[0].size = PAGE_SIZE - 1;
        req->out.args[0].value = link;
        req->out.numargs = 1;
        req->out.args[0].size = PAGE_SIZE - 1;
        req->out.args[0].value = link;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        if (req->out.h.error) {
                free_page((unsigned long) link);
                link = ERR_PTR(req->out.h.error);
        if (req->out.h.error) {
                free_page((unsigned long) link);
                link = ERR_PTR(req->out.h.error);


@@ -1000,18 +1146,33 @@ static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
 
 static int fuse_dir_open(struct inode *inode, struct file *file)
 {
 
 static int fuse_dir_open(struct inode *inode, struct file *file)
 {

-       return fuse_open_common(inode, file, 1);
+       return fuse_open_common(inode, file, true);

 }
 
 static int fuse_dir_release(struct inode *inode, struct file *file)
 {
 }
 
 static int fuse_dir_release(struct inode *inode, struct file *file)
 {

-       return fuse_release_common(inode, file, 1);
+       fuse_release_common(file, FUSE_RELEASEDIR);
+
+       return 0;
+}
+
+static int fuse_dir_fsync(struct file *file, int datasync)
+{
+       return fuse_fsync_common(file, datasync, 1);

 }
 
 }
 

-static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
+static bool update_mtime(unsigned ivalid)

 {
 {

-       /* nfsd can call this with no file */
-       return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
+       /* Always update if mtime is explicitly set  */
+       if (ivalid & ATTR_MTIME_SET)
+               return true;
+
+       /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
+       if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
+               return false;
+
+       /* In all other cases update */
+       return true;

 }
 
 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
 }
 
 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)


@@ -1026,15 +1187,67 @@ static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
                arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
        if (ivalid & ATTR_SIZE)
                arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
                arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
        if (ivalid & ATTR_SIZE)
                arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;

-       /* You can only _set_ these together (they may change by themselves) */
-       if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
-               arg->valid |= FATTR_ATIME | FATTR_MTIME;
+       if (ivalid & ATTR_ATIME) {
+               arg->valid |= FATTR_ATIME;

                arg->atime = iattr->ia_atime.tv_sec;
                arg->atime = iattr->ia_atime.tv_sec;

+               arg->atimensec = iattr->ia_atime.tv_nsec;
+               if (!(ivalid & ATTR_ATIME_SET))
+                       arg->valid |= FATTR_ATIME_NOW;
+       }
+       if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
+               arg->valid |= FATTR_MTIME;

                arg->mtime = iattr->ia_mtime.tv_sec;
                arg->mtime = iattr->ia_mtime.tv_sec;

+               arg->mtimensec = iattr->ia_mtime.tv_nsec;
+               if (!(ivalid & ATTR_MTIME_SET))
+                       arg->valid |= FATTR_MTIME_NOW;

        }
 }
 
 /*
        }
 }
 
 /*

+ * Prevent concurrent writepages on inode
+ *
+ * This is done by adding a negative bias to the inode write counter
+ * and waiting for all pending writes to finish.
+ */
+void fuse_set_nowrite(struct inode *inode)
+{
+       struct fuse_conn *fc = get_fuse_conn(inode);
+       struct fuse_inode *fi = get_fuse_inode(inode);
+
+       BUG_ON(!mutex_is_locked(&inode->i_mutex));
+
+       spin_lock(&fc->lock);
+       BUG_ON(fi->writectr < 0);
+       fi->writectr += FUSE_NOWRITE;
+       spin_unlock(&fc->lock);
+       wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
+}
+
+/*
+ * Allow writepages on inode
+ *
+ * Remove the bias from the writecounter and send any queued
+ * writepages.
+ */
+static void __fuse_release_nowrite(struct inode *inode)
+{
+       struct fuse_inode *fi = get_fuse_inode(inode);
+
+       BUG_ON(fi->writectr != FUSE_NOWRITE);
+       fi->writectr = 0;
+       fuse_flush_writepages(inode);
+}
+
+void fuse_release_nowrite(struct inode *inode)
+{
+       struct fuse_conn *fc = get_fuse_conn(inode);
+
+       spin_lock(&fc->lock);
+       __fuse_release_nowrite(inode);
+       spin_unlock(&fc->lock);
+}
+
+/*

  * Set attributes, and at the same time refresh them.
  *
  * Truncation is slightly complicated, because the 'truncate' request
  * Set attributes, and at the same time refresh them.
  *
  * Truncation is slightly complicated, because the 'truncate' request


@@ -1050,6 +1263,8 @@ static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
        struct fuse_req *req;
        struct fuse_setattr_in inarg;
        struct fuse_attr_out outarg;
        struct fuse_req *req;
        struct fuse_setattr_in inarg;
        struct fuse_attr_out outarg;

+       bool is_truncate = false;
+       loff_t oldsize;

        int err;
 
        if (!fuse_allow_task(fc, current))
        int err;
 
        if (!fuse_allow_task(fc, current))


@@ -1061,52 +1276,90 @@ static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
                        return err;
        }
 
                        return err;
        }
 

+       if ((attr->ia_valid & ATTR_OPEN) && fc->atomic_o_trunc)
+               return 0;
+

        if (attr->ia_valid & ATTR_SIZE) {
        if (attr->ia_valid & ATTR_SIZE) {

-               unsigned long limit;
-               if (IS_SWAPFILE(inode))
-                       return -ETXTBSY;
-               limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
-               if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
-                       send_sig(SIGXFSZ, current, 0);
-                       return -EFBIG;
-               }
+               err = inode_newsize_ok(inode, attr->ia_size);
+               if (err)
+                       return err;
+               is_truncate = true;

        }
 
        req = fuse_get_req(fc);
        if (IS_ERR(req))
                return PTR_ERR(req);
 
        }
 
        req = fuse_get_req(fc);
        if (IS_ERR(req))
                return PTR_ERR(req);
 

+       if (is_truncate)
+               fuse_set_nowrite(inode);
+

        memset(&inarg, 0, sizeof(inarg));
        memset(&inarg, 0, sizeof(inarg));

+       memset(&outarg, 0, sizeof(outarg));

        iattr_to_fattr(attr, &inarg);
        if (file) {
                struct fuse_file *ff = file->private_data;
                inarg.valid |= FATTR_FH;
                inarg.fh = ff->fh;
        }
        iattr_to_fattr(attr, &inarg);
        if (file) {
                struct fuse_file *ff = file->private_data;
                inarg.valid |= FATTR_FH;
                inarg.fh = ff->fh;
        }

+       if (attr->ia_valid & ATTR_SIZE) {
+               /* For mandatory locking in truncate */
+               inarg.valid |= FATTR_LOCKOWNER;
+               inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
+       }

        req->in.h.opcode = FUSE_SETATTR;
        req->in.h.nodeid = get_node_id(inode);
        req->in.numargs = 1;
        req->in.args[0].size = sizeof(inarg);
        req->in.args[0].value = &inarg;
        req->out.numargs = 1;
        req->in.h.opcode = FUSE_SETATTR;
        req->in.h.nodeid = get_node_id(inode);
        req->in.numargs = 1;
        req->in.args[0].size = sizeof(inarg);
        req->in.args[0].value = &inarg;
        req->out.numargs = 1;

-       req->out.args[0].size = sizeof(outarg);
+       if (fc->minor < 9)
+               req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
+       else
+               req->out.args[0].size = sizeof(outarg);

        req->out.args[0].value = &outarg;
        req->out.args[0].value = &outarg;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err) {
                if (err == -EINTR)
                        fuse_invalidate_attr(inode);
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err) {
                if (err == -EINTR)
                        fuse_invalidate_attr(inode);

-               return err;
+               goto error;

        }
 
        if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
                make_bad_inode(inode);
        }
 
        if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
                make_bad_inode(inode);

-               return -EIO;
+               err = -EIO;
+               goto error;
+       }
+
+       spin_lock(&fc->lock);
+       fuse_change_attributes_common(inode, &outarg.attr,
+                                     attr_timeout(&outarg));
+       oldsize = inode->i_size;
+       i_size_write(inode, outarg.attr.size);
+
+       if (is_truncate) {
+               /* NOTE: this may release/reacquire fc->lock */
+               __fuse_release_nowrite(inode);
+       }
+       spin_unlock(&fc->lock);
+
+       /*
+        * Only call invalidate_inode_pages2() after removing
+        * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
+        */
+       if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
+               truncate_pagecache(inode, oldsize, outarg.attr.size);
+               invalidate_inode_pages2(inode->i_mapping);

        }
 
        }
 

-       fuse_change_attributes(inode, &outarg.attr, attr_timeout(&outarg), 0);

        return 0;
        return 0;

+
+error:
+       if (is_truncate)
+               fuse_release_nowrite(inode);
+
+       return err;

 }
 
 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 }
 
 static int fuse_setattr(struct dentry *entry, struct iattr *attr)


@@ -1121,22 +1374,12 @@ static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
                        struct kstat *stat)
 {
        struct inode *inode = entry->d_inode;
                        struct kstat *stat)
 {
        struct inode *inode = entry->d_inode;

-       struct fuse_inode *fi = get_fuse_inode(inode);

        struct fuse_conn *fc = get_fuse_conn(inode);
        struct fuse_conn *fc = get_fuse_conn(inode);

-       int err;

 
        if (!fuse_allow_task(fc, current))
                return -EACCES;
 
 
        if (!fuse_allow_task(fc, current))
                return -EACCES;
 

-       if (fi->i_time < get_jiffies_64())
-               err = fuse_do_getattr(inode, stat, NULL);
-       else {
-               err = 0;
-               generic_fillattr(inode, stat);
-               stat->mode = fi->orig_i_mode;
-       }
-
-       return err;
+       return fuse_update_attributes(inode, stat, NULL, NULL);

 }
 
 static int fuse_setxattr(struct dentry *entry, const char *name,
 }
 
 static int fuse_setxattr(struct dentry *entry, const char *name,


@@ -1167,7 +1410,7 @@ static int fuse_setxattr(struct dentry *entry, const char *name,
        req->in.args[1].value = name;
        req->in.args[2].size = size;
        req->in.args[2].value = value;
        req->in.args[1].value = name;
        req->in.args[2].size = size;
        req->in.args[2].value = value;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err == -ENOSYS) {
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err == -ENOSYS) {


@@ -1213,7 +1456,7 @@ static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
                req->out.args[0].size = sizeof(outarg);
                req->out.args[0].value = &outarg;
        }
                req->out.args[0].size = sizeof(outarg);
                req->out.args[0].value = &outarg;
        }

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        ret = req->out.h.error;
        if (!ret)
                ret = size ? req->out.args[0].size : outarg.size;
        ret = req->out.h.error;
        if (!ret)
                ret = size ? req->out.args[0].size : outarg.size;


@@ -1263,7 +1506,7 @@ static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
                req->out.args[0].size = sizeof(outarg);
                req->out.args[0].value = &outarg;
        }
                req->out.args[0].size = sizeof(outarg);
                req->out.args[0].value = &outarg;
        }

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        ret = req->out.h.error;
        if (!ret)
                ret = size ? req->out.args[0].size : outarg.size;
        ret = req->out.h.error;
        if (!ret)
                ret = size ? req->out.args[0].size : outarg.size;


@@ -1296,7 +1539,7 @@ static int fuse_removexattr(struct dentry *entry, const char *name)
        req->in.numargs = 1;
        req->in.args[0].size = strlen(name) + 1;
        req->in.args[0].value = name;
        req->in.numargs = 1;
        req->in.args[0].size = strlen(name) + 1;
        req->in.args[0].value = name;

-       request_send(fc, req);
+       fuse_request_send(fc, req);

        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err == -ENOSYS) {
        err = req->out.h.error;
        fuse_put_request(fc, req);
        if (err == -ENOSYS) {