Pass fuse_file_info to getattr, chown, chmod, truncate, utimens handlers

This obsoletes the ftruncate & fgetattr handlers.

Fixes #58.

diff --git a/ChangeLog.rst b/ChangeLog.rst
index 528efb09c4ebfe91c6cb6cfb94e78997c0c4baf9..d18fc3e9e71e481ed807029535ab646b13a2a4b3 100644 (file)
--- a/ChangeLog.rst
+++ b/ChangeLog.rst
@@ -1,6 +1,13 @@
 Unreleased Changes
 ==================
 
+* The chmod, chown, truncate, utimens and getattr handlers of the
+  high-level API now all receive an additional struct fuse_file_info
+  pointer. This pointer is NULL if the file is not currently open.
+
+  The fgetattr and ftruncate handlers have become obsolote and have
+  been removed.
+
 * The `fuse_session_new` function no longer accepts the ``-o
   clone_fd`` option. Instead, this has become a parameter of the
   `fuse_session_loop_mt` and ``fuse_loop_mt` functions.

diff --git a/example/hello.c b/example/hello.c
index bf6ccf4a873a67adeb6f6d08b31a4c7b695a931e..c587d729c9c317ca18d8eb401199063911302cfe 100644 (file)
--- a/example/hello.c
+++ b/example/hello.c
@@ -68,8 +68,10 @@ static const struct fuse_opt option_spec[] = {
        FUSE_OPT_END
 };
 
-static int hello_getattr(const char *path, struct stat *stbuf)
+static int hello_getattr(const char *path, struct stat *stbuf,
+                        struct fuse_file_info *fi)
 {
+       (void) fi;
        int res = 0;
 
        memset(stbuf, 0, sizeof(struct stat));

diff --git a/example/ioctl.c b/example/ioctl.c
index ee58f034518b8475dd77fbf0064da62d13602486..0a4c14dfc4a5d5c8fa3f8952deb966fc2d95ad48 100644 (file)
--- a/example/ioctl.c
+++ b/example/ioctl.c
@@ -83,8 +83,10 @@ static int fioc_file_type(const char *path)
        return FIOC_NONE;
 }
 
-static int fioc_getattr(const char *path, struct stat *stbuf)
+static int fioc_getattr(const char *path, struct stat *stbuf,
+                       struct fuse_file_info *fi)
 {
+       (void) fi;
        stbuf->st_uid = getuid();
        stbuf->st_gid = getgid();
        stbuf->st_atime = stbuf->st_mtime = time(NULL);
@@ -160,8 +162,10 @@ static int fioc_write(const char *path, const char *buf, size_t size,
        return fioc_do_write(buf, size, offset);
 }
 
-static int fioc_truncate(const char *path, off_t size)
+static int fioc_truncate(const char *path, off_t size,
+                        struct fuse_file_info *fi)
 {
+       (void) fi;
        if (fioc_file_type(path) != FIOC_FILE)
                return -EINVAL;
 

diff --git a/example/passthrough.c b/example/passthrough.c
index cf72cb255cab779fb970ab1f1d44e74c90c5e811..d3d0fde6f9ea05c0026660da013776e8de8d2199 100644 (file)
--- a/example/passthrough.c
+++ b/example/passthrough.c
@@ -48,8 +48,10 @@
 #include <sys/xattr.h>
 #endif
 
-static int xmp_getattr(const char *path, struct stat *stbuf)
+static int xmp_getattr(const char *path, struct stat *stbuf,
+                      struct fuse_file_info *fi)
 {
+       (void) fi;
        int res;
 
        res = lstat(path, stbuf);
@@ -200,8 +202,10 @@ static int xmp_link(const char *from, const char *to)
        return 0;
 }
 
-static int xmp_chmod(const char *path, mode_t mode)
+static int xmp_chmod(const char *path, mode_t mode,
+                    struct fuse_file_info *fi)
 {
+       (void) fi;
        int res;
 
        res = chmod(path, mode);
@@ -211,8 +215,10 @@ static int xmp_chmod(const char *path, mode_t mode)
        return 0;
 }
 
-static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+static int xmp_chown(const char *path, uid_t uid, gid_t gid,
+                    struct fuse_file_info *fi)
 {
+       (void) fi;
        int res;
 
        res = lchown(path, uid, gid);
@@ -222,8 +228,10 @@ static int xmp_chown(const char *path, uid_t uid, gid_t gid)
        return 0;
 }
 
-static int xmp_truncate(const char *path, off_t size)
+static int xmp_truncate(const char *path, off_t size,
+                       struct fuse_file_info *fi)
 {
+       (void) fi;
        int res;
 
        res = truncate(path, size);
@@ -234,8 +242,10 @@ static int xmp_truncate(const char *path, off_t size)
 }
 
 #ifdef HAVE_UTIMENSAT
-static int xmp_utimens(const char *path, const struct timespec ts[2])
+static int xmp_utimens(const char *path, const struct timespec ts[2],
+                      struct fuse_file_info *fi)
 {
+       (void) fi;
        int res;
 
        /* don't use utime/utimes since they follow symlinks */

diff --git a/example/passthrough_fh.c b/example/passthrough_fh.c
index a179f657d0d615cb38374742edb0b1b09abfa57a..35d909f018187821c42c3639c6a6c1d95d311775 100644 (file)
--- a/example/passthrough_fh.c
+++ b/example/passthrough_fh.c
@@ -52,25 +52,17 @@
 #endif
 #include <sys/file.h> /* flock(2) */
 
-static int xmp_getattr(const char *path, struct stat *stbuf)
-{
-       int res;
-
-       res = lstat(path, stbuf);
-       if (res == -1)
-               return -errno;
-
-       return 0;
-}
-
-static int xmp_fgetattr(const char *path, struct stat *stbuf,
+static int xmp_getattr(const char *path, struct stat *stbuf,
                        struct fuse_file_info *fi)
 {
        int res;
 
        (void) path;
 
-       res = fstat(fi->fh, stbuf);
+       if(fi)
+               res = fstat(fi->fh, stbuf);
+       else
+               res = lstat(path, stbuf);
        if (res == -1)
                return -errno;
 
@@ -272,47 +264,46 @@ static int xmp_link(const char *from, const char *to)
        return 0;
 }
 
-static int xmp_chmod(const char *path, mode_t mode)
-{
-       int res;
-
-       res = chmod(path, mode);
-       if (res == -1)
-               return -errno;
-
-       return 0;
-}
-
-static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+static int xmp_chmod(const char *path, mode_t mode,
+                    struct fuse_file_info *fi)
 {
        int res;
 
-       res = lchown(path, uid, gid);
+       if(fi)
+               res = fchmod(fi->fh, mode);
+       else
+               res = chmod(path, mode);
        if (res == -1)
                return -errno;
 
        return 0;
 }
 
-static int xmp_truncate(const char *path, off_t size)
+static int xmp_chown(const char *path, uid_t uid, gid_t gid,
+                    struct fuse_file_info *fi)
 {
        int res;
 
-       res = truncate(path, size);
+       if (fi)
+               res = fchown(fi->fh, uid, gid);
+       else
+               res = lchown(path, uid, gid);
        if (res == -1)
                return -errno;
 
        return 0;
 }
 
-static int xmp_ftruncate(const char *path, off_t size,
+static int xmp_truncate(const char *path, off_t size,
                         struct fuse_file_info *fi)
 {
        int res;
 
-       (void) path;
+       if(fi)
+               res = ftruncate(fi->fh, size);
+       else
+               res = truncate(path, size);
 
-       res = ftruncate(fi->fh, size);
        if (res == -1)
                return -errno;
 
@@ -320,12 +311,16 @@ static int xmp_ftruncate(const char *path, off_t size,
 }
 
 #ifdef HAVE_UTIMENSAT
-static int xmp_utimens(const char *path, const struct timespec ts[2])
+static int xmp_utimens(const char *path, const struct timespec ts[2],
+                      struct fuse_file_info *fi)
 {
        int res;
 
        /* don't use utime/utimes since they follow symlinks */
-       res = utimensat(0, path, ts, AT_SYMLINK_NOFOLLOW);
+       if (fi)
+               res = futimens(fi->fh, ts);
+       else
+               res = utimensat(0, path, ts, AT_SYMLINK_NOFOLLOW);
        if (res == -1)
                return -errno;
 
@@ -550,7 +545,6 @@ static int xmp_flock(const char *path, struct fuse_file_info *fi, int op)
 
 static struct fuse_operations xmp_oper = {
        .getattr        = xmp_getattr,
-       .fgetattr       = xmp_fgetattr,
        .access         = xmp_access,
        .readlink       = xmp_readlink,
        .opendir        = xmp_opendir,
@@ -566,7 +560,6 @@ static struct fuse_operations xmp_oper = {
        .chmod          = xmp_chmod,
        .chown          = xmp_chown,
        .truncate       = xmp_truncate,
-       .ftruncate      = xmp_ftruncate,
 #ifdef HAVE_UTIMENSAT
        .utimens        = xmp_utimens,
 #endif

diff --git a/example/poll.c b/example/poll.c
index 61c53659bc6b82ecce33c5c652aae5d0ff96a12a..10175a3982beef92d41d2ccdfd7a9d80b3348fc0 100644 (file)
--- a/example/poll.c
+++ b/example/poll.c
@@ -64,8 +64,10 @@ static int fsel_path_index(const char *path)
        return ch <= '9' ? ch - '0' : ch - 'A' + 10;
 }
 
-static int fsel_getattr(const char *path, struct stat *stbuf)
+static int fsel_getattr(const char *path, struct stat *stbuf,
+                       struct fuse_file_info *fi)
 {
+       (void) fi;
        int idx;
 
        memset(stbuf, 0, sizeof(struct stat));

diff --git a/include/fuse.h b/include/fuse.h
index 5b9082bd88a2182811da87506d32e3c368aca278..fb5f3fb50797c35f527cde00d5927b168aafc21b 100644 (file)
--- a/include/fuse.h
+++ b/include/fuse.h
@@ -105,7 +105,13 @@ struct fuse_operations {
         * the following operations:
         *
         * read, write, flush, release, fsync, readdir, releasedir,
-        * fsyncdir, ftruncate, fgetattr, lock, ioctl and poll
+        * fsyncdir, lock, ioctl and poll
+        *
+        * For the following operations, the path will not be
+        * calculated only if the file is currently open (i.e., the
+        * struct fuse_file_info argument is non-NULL):
+        *
+        * truncate, getattr, chmod, chown, utimens
         *
         * If this flag is set then the path will not be calculaged even if the
         * file wasn't unlinked.  However the path can still be non-NULL if it
@@ -121,10 +127,12 @@ struct fuse_operations {
        /** Get file attributes.
         *
         * Similar to stat().  The 'st_dev' and 'st_blksize' fields are
-        * ignored.      The 'st_ino' field is ignored except if the 'use_ino'
+        * ignored. The 'st_ino' field is ignored except if the 'use_ino'
         * mount option is given.
+        *
+        * *fi* will be NULL if the file is not currenly opened.
         */
-       int (*getattr) (const char *, struct stat *);
+       int (*getattr) (const char *, struct stat *, struct fuse_file_info *fi);
 
        /** Read the target of a symbolic link
         *
@@ -167,14 +175,23 @@ struct fuse_operations {
        /** Create a hard link to a file */
        int (*link) (const char *, const char *);
 
-       /** Change the permission bits of a file */
-       int (*chmod) (const char *, mode_t);
+       /** Change the permission bits of a file
+        *
+        * *fi* will be NULL if the file is not currenly opened.
+        */
+       int (*chmod) (const char *, mode_t, struct fuse_file_info *fi);
 
-       /** Change the owner and group of a file */
-       int (*chown) (const char *, uid_t, gid_t);
+       /** Change the owner and group of a file
+        *
+        * *fi* will be NULL if the file is not currenly opened.
+        */
+       int (*chown) (const char *, uid_t, gid_t, struct fuse_file_info *fi);
 
-       /** Change the size of a file */
-       int (*truncate) (const char *, off_t);
+       /** Change the size of a file
+        *
+        * *fi* will be NULL if the file is not currenly opened.
+        */
+       int (*truncate) (const char *, off_t, struct fuse_file_info *fi);
 
        /** File open operation
         *
@@ -387,34 +404,6 @@ struct fuse_operations {
         */
        int (*create) (const char *, mode_t, struct fuse_file_info *);
 
-       /**
-        * Change the size of an open file
-        *
-        * This method is called instead of the truncate() method if the
-        * truncation was invoked from an ftruncate() system call.
-        *
-        * If this method is not implemented or under Linux kernel
-        * versions earlier than 2.6.15, the truncate() method will be
-        * called instead.
-        *
-        * Introduced in version 2.5
-        */
-       int (*ftruncate) (const char *, off_t, struct fuse_file_info *);
-
-       /**
-        * Get attributes from an open file
-        *
-        * This method is called instead of the getattr() method if the
-        * file information is available.
-        *
-        * Currently this is only called after the create() method if that
-        * is implemented (see above).  Later it may be called for
-        * invocations of fstat() too.
-        *
-        * Introduced in version 2.5
-        */
-       int (*fgetattr) (const char *, struct stat *, struct fuse_file_info *);
-
        /**
         * Perform POSIX file locking operation
         *
@@ -457,11 +446,14 @@ struct fuse_operations {
         * This supersedes the old utime() interface.  New applications
         * should use this.
         *
+        * *fi* will be NULL if the file is not currenly opened.
+        *
         * See the utimensat(2) man page for details.
         *
         * Introduced in version 2.6
         */
-       int (*utimens) (const char *, const struct timespec tv[2]);
+        int (*utimens) (const char *, const struct timespec tv[2],
+                        struct fuse_file_info *fi);
 
        /**
         * Map block index within file to block index within device
@@ -849,9 +841,8 @@ struct fuse_fs;
  * fuse_fs_releasedir and fuse_fs_statfs, which return 0.
  */
 
-int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf);
-int fuse_fs_fgetattr(struct fuse_fs *fs, const char *path, struct stat *buf,
-                    struct fuse_file_info *fi);
+int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf,
+                   struct fuse_file_info *fi);
 int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath,
                   const char *newpath, unsigned int flags);
 int fuse_fs_unlink(struct fuse_fs *fs, const char *path);
@@ -893,13 +884,14 @@ int fuse_fs_lock(struct fuse_fs *fs, const char *path,
                 struct fuse_file_info *fi, int cmd, struct flock *lock);
 int fuse_fs_flock(struct fuse_fs *fs, const char *path,
                  struct fuse_file_info *fi, int op);
-int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode);
-int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid);
-int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size);
-int fuse_fs_ftruncate(struct fuse_fs *fs, const char *path, off_t size,
-                     struct fuse_file_info *fi);
+int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode,
+                 struct fuse_file_info *fi);
+int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid,
+                 struct fuse_file_info *fi);
+int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size,
+                    struct fuse_file_info *fi);
 int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
-                   const struct timespec tv[2]);
+                   const struct timespec tv[2], struct fuse_file_info *fi);
 int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask);
 int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf,
                     size_t len);

diff --git a/lib/fuse.c b/lib/fuse.c
index ff46f78914678979559e1a592ee778baa3169938..612b1b65f474bde33b89cef71397699df461ac25 100644 (file)
--- a/lib/fuse.c
+++ b/lib/fuse.c
@@ -1537,34 +1537,15 @@ static inline void fuse_prepare_interrupt(struct fuse *f, fuse_req_t req,
                fuse_do_prepare_interrupt(req, d);
 }
 
-int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf)
+int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf,
+                   struct fuse_file_info *fi)
 {
        fuse_get_context()->private_data = fs->user_data;
        if (fs->op.getattr) {
                if (fs->debug)
-                       fprintf(stderr, "getattr %s\n", path);
-
-               return fs->op.getattr(path, buf);
-       } else {
-               return -ENOSYS;
-       }
-}
-
-int fuse_fs_fgetattr(struct fuse_fs *fs, const char *path, struct stat *buf,
-                    struct fuse_file_info *fi)
-{
-       fuse_get_context()->private_data = fs->user_data;
-       if (fs->op.fgetattr) {
-               if (fs->debug)
-                       fprintf(stderr, "fgetattr[%llu] %s\n",
+                       fprintf(stderr, "getattr[%llu] %s\n",
                                (unsigned long long) fi->fh, path);
-
-               return fs->op.fgetattr(path, buf, fi);
-       } else if (path && fs->op.getattr) {
-               if (fs->debug)
-                       fprintf(stderr, "getattr %s\n", path);
-
-               return fs->op.getattr(path, buf);
+               return fs->op.getattr(path, buf, fi);
        } else {
                return -ENOSYS;
        }
@@ -2023,67 +2004,50 @@ int fuse_fs_flock(struct fuse_fs *fs, const char *path,
        }
 }
 
-int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid)
+int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid,
+                 gid_t gid, struct fuse_file_info *fi)
 {
        fuse_get_context()->private_data = fs->user_data;
        if (fs->op.chown) {
                if (fs->debug)
-                       fprintf(stderr, "chown %s %lu %lu\n", path,
+                       fprintf(stderr, "chown[%llu] %s %lu %lu\n",
+                               (unsigned long long) fi->fh, path,
                                (unsigned long) uid, (unsigned long) gid);
 
-               return fs->op.chown(path, uid, gid);
-       } else {
-               return -ENOSYS;
-       }
-}
-
-int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size)
-{
-       fuse_get_context()->private_data = fs->user_data;
-       if (fs->op.truncate) {
-               if (fs->debug)
-                       fprintf(stderr, "truncate %s %llu\n", path,
-                               (unsigned long long) size);
-
-               return fs->op.truncate(path, size);
+               return fs->op.chown(path, uid, gid, fi);
        } else {
                return -ENOSYS;
        }
 }
 
-int fuse_fs_ftruncate(struct fuse_fs *fs, const char *path, off_t size,
+int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size,
                      struct fuse_file_info *fi)
 {
        fuse_get_context()->private_data = fs->user_data;
-       if (fs->op.ftruncate) {
+       if (fs->op.truncate) {
                if (fs->debug)
-                       fprintf(stderr, "ftruncate[%llu] %llu\n",
+                       fprintf(stderr, "truncate[%llu] %llu\n",
                                (unsigned long long) fi->fh,
                                (unsigned long long) size);
 
-               return fs->op.ftruncate(path, size, fi);
-       } else if (path && fs->op.truncate) {
-               if (fs->debug)
-                       fprintf(stderr, "truncate %s %llu\n", path,
-                               (unsigned long long) size);
-
-               return fs->op.truncate(path, size);
+               return fs->op.truncate(path, size, fi);
        } else {
                return -ENOSYS;
        }
 }
 
 int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
-                   const struct timespec tv[2])
+                   const struct timespec tv[2], struct fuse_file_info *fi)
 {
        fuse_get_context()->private_data = fs->user_data;
        if (fs->op.utimens) {
                if (fs->debug)
-                       fprintf(stderr, "utimens %s %li.%09lu %li.%09lu\n",
-                               path, tv[0].tv_sec, tv[0].tv_nsec,
+                       fprintf(stderr, "utimens[%llu] %s %li.%09lu %li.%09lu\n",
+                               (unsigned long long) fi->fh, path,
+                               tv[0].tv_sec, tv[0].tv_nsec,
                                tv[1].tv_sec, tv[1].tv_nsec);
 
-               return fs->op.utimens(path, tv);
+               return fs->op.utimens(path, tv, fi);
        } else {
                return -ENOSYS;
        }
@@ -2318,7 +2282,7 @@ static char *hidden_name(struct fuse *f, fuse_ino_t dir, const char *oldname,
                        break;
 
                memset(&buf, 0, sizeof(buf));
-               res = fuse_fs_getattr(f->fs, newpath, &buf);
+               res = fuse_fs_getattr(f->fs, newpath, &buf, NULL);
                if (res == -ENOENT)
                        break;
                free(newpath);
@@ -2409,10 +2373,7 @@ static int lookup_path(struct fuse *f, fuse_ino_t nodeid,
        int res;
 
        memset(e, 0, sizeof(struct fuse_entry_param));
-       if (fi)
-               res = fuse_fs_fgetattr(f->fs, path, &e->attr, fi);
-       else
-               res = fuse_fs_getattr(f->fs, path, &e->attr);
+       res = fuse_fs_getattr(f->fs, path, &e->attr, fi);
        if (res == 0) {
                res = do_lookup(f, nodeid, name, e);
                if (res == 0 && f->conf.debug) {
@@ -2652,17 +2613,14 @@ static void fuse_lib_getattr(fuse_req_t req, fuse_ino_t ino,
 
        memset(&buf, 0, sizeof(buf));
 
-       if (fi != NULL && f->fs->op.fgetattr)
+       if (fi != NULL)
                err = get_path_nullok(f, ino, &path);
        else
                err = get_path(f, ino, &path);
        if (!err) {
                struct fuse_intr_data d;
                fuse_prepare_interrupt(f, req, &d);
-               if (fi)
-                       err = fuse_fs_fgetattr(f->fs, path, &buf, fi);
-               else
-                       err = fuse_fs_getattr(f->fs, path, &buf);
+               err = fuse_fs_getattr(f->fs, path, &buf, fi);
                fuse_finish_interrupt(f, req, &d);
                free_path(f, ino, path);
        }
@@ -2682,11 +2640,12 @@ static void fuse_lib_getattr(fuse_req_t req, fuse_ino_t ino,
                reply_err(req, err);
 }
 
-int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode)
+int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode,
+                 struct fuse_file_info *fi)
 {
        fuse_get_context()->private_data = fs->user_data;
        if (fs->op.chmod)
-               return fs->op.chmod(path, mode);
+               return fs->op.chmod(path, mode, fi);
        else
                return -ENOSYS;
 }
@@ -2700,8 +2659,7 @@ static void fuse_lib_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
        int err;
 
        memset(&buf, 0, sizeof(buf));
-       if (valid == FUSE_SET_ATTR_SIZE && fi != NULL &&
-           f->fs->op.ftruncate && f->fs->op.fgetattr)
+       if (fi != NULL)
                err = get_path_nullok(f, ino, &path);
        else
                err = get_path(f, ino, &path);
@@ -2710,21 +2668,17 @@ static void fuse_lib_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
                fuse_prepare_interrupt(f, req, &d);
                err = 0;
                if (!err && (valid & FUSE_SET_ATTR_MODE))
-                       err = fuse_fs_chmod(f->fs, path, attr->st_mode);
+                       err = fuse_fs_chmod(f->fs, path, attr->st_mode, fi);
                if (!err && (valid & (FUSE_SET_ATTR_UID | FUSE_SET_ATTR_GID))) {
                        uid_t uid = (valid & FUSE_SET_ATTR_UID) ?
                                attr->st_uid : (uid_t) -1;
                        gid_t gid = (valid & FUSE_SET_ATTR_GID) ?
                                attr->st_gid : (gid_t) -1;
-                       err = fuse_fs_chown(f->fs, path, uid, gid);
+                       err = fuse_fs_chown(f->fs, path, uid, gid, fi);
                }
                if (!err && (valid & FUSE_SET_ATTR_SIZE)) {
-                       if (fi)
-                               err = fuse_fs_ftruncate(f->fs, path,
-                                                       attr->st_size, fi);
-                       else
-                               err = fuse_fs_truncate(f->fs, path,
-                                                      attr->st_size);
+                       err = fuse_fs_truncate(f->fs, path,
+                                              attr->st_size, fi);
                }
 #ifdef HAVE_UTIMENSAT
                if (!err &&
@@ -2746,7 +2700,7 @@ static void fuse_lib_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
                        else if (valid & FUSE_SET_ATTR_MTIME)
                                tv[1] = attr->st_mtim;
 
-                       err = fuse_fs_utimens(f->fs, path, tv);
+                       err = fuse_fs_utimens(f->fs, path, tv, fi);
                } else
 #endif
                if (!err &&
@@ -2757,13 +2711,10 @@ static void fuse_lib_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
                        tv[0].tv_nsec = ST_ATIM_NSEC(attr);
                        tv[1].tv_sec = attr->st_mtime;
                        tv[1].tv_nsec = ST_MTIM_NSEC(attr);
-                       err = fuse_fs_utimens(f->fs, path, tv);
+                       err = fuse_fs_utimens(f->fs, path, tv, fi);
                }
                if (!err) {
-                       if (fi)
-                               err = fuse_fs_fgetattr(f->fs, path, &buf, fi);
-                       else
-                               err = fuse_fs_getattr(f->fs, path, &buf);
+                       err = fuse_fs_getattr(f->fs, path, &buf, fi);
                }
                fuse_finish_interrupt(f, req, &d);
                free_path(f, ino, path);
@@ -3116,7 +3067,7 @@ static void open_auto_cache(struct fuse *f, fuse_ino_t ino, const char *path,
                        struct stat stbuf;
                        int err;
                        pthread_mutex_unlock(&f->lock);
-                       err = fuse_fs_fgetattr(f->fs, path, &stbuf, fi);
+                       err = fuse_fs_getattr(f->fs, path, &stbuf, fi);
                        pthread_mutex_lock(&f->lock);
                        if (!err)
                                update_stat(node, &stbuf);

diff --git a/lib/modules/iconv.c b/lib/modules/iconv.c
index 174e2b9a008b292eb1c2401b8ea4a8a65fb139c8..41a072cc67996c5e2c162a35dc139f0b01b1e7c0 100644 (file)
--- a/lib/modules/iconv.c
+++ b/lib/modules/iconv.c
@@ -101,26 +101,14 @@ err:
        return err;
 }
 
-static int iconv_getattr(const char *path, struct stat *stbuf)
+static int iconv_getattr(const char *path, struct stat *stbuf,
+                        struct fuse_file_info *fi)
 {
        struct iconv *ic = iconv_get();
        char *newpath;
        int err = iconv_convpath(ic, path, &newpath, 0);
        if (!err) {
-               err = fuse_fs_getattr(ic->next, newpath, stbuf);
-               free(newpath);
-       }
-       return err;
-}
-
-static int iconv_fgetattr(const char *path, struct stat *stbuf,
-                         struct fuse_file_info *fi)
-{
-       struct iconv *ic = iconv_get();
-       char *newpath;
-       int err = iconv_convpath(ic, path, &newpath, 0);
-       if (!err) {
-               err = fuse_fs_fgetattr(ic->next, newpath, stbuf, fi);
+               err = fuse_fs_getattr(ic->next, newpath, stbuf, fi);
                free(newpath);
        }
        return err;
@@ -315,62 +303,53 @@ static int iconv_link(const char *from, const char *to)
        return err;
 }
 
-static int iconv_chmod(const char *path, mode_t mode)
-{
-       struct iconv *ic = iconv_get();
-       char *newpath;
-       int err = iconv_convpath(ic, path, &newpath, 0);
-       if (!err) {
-               err = fuse_fs_chmod(ic->next, newpath, mode);
-               free(newpath);
-       }
-       return err;
-}
-
-static int iconv_chown(const char *path, uid_t uid, gid_t gid)
+static int iconv_chmod(const char *path, mode_t mode,
+                      struct fuse_file_info *fi)
 {
        struct iconv *ic = iconv_get();
        char *newpath;
        int err = iconv_convpath(ic, path, &newpath, 0);
        if (!err) {
-               err = fuse_fs_chown(ic->next, newpath, uid, gid);
+               err = fuse_fs_chmod(ic->next, newpath, mode, fi);
                free(newpath);
        }
        return err;
 }
 
-static int iconv_truncate(const char *path, off_t size)
+static int iconv_chown(const char *path, uid_t uid, gid_t gid,
+                      struct fuse_file_info *fi)
 {
        struct iconv *ic = iconv_get();
        char *newpath;
        int err = iconv_convpath(ic, path, &newpath, 0);
        if (!err) {
-               err = fuse_fs_truncate(ic->next, newpath, size);
+               err = fuse_fs_chown(ic->next, newpath, uid, gid, fi);
                free(newpath);
        }
        return err;
 }
 
-static int iconv_ftruncate(const char *path, off_t size,
+static int iconv_truncate(const char *path, off_t size,
                           struct fuse_file_info *fi)
 {
        struct iconv *ic = iconv_get();
        char *newpath;
        int err = iconv_convpath(ic, path, &newpath, 0);
        if (!err) {
-               err = fuse_fs_ftruncate(ic->next, newpath, size, fi);
+               err = fuse_fs_truncate(ic->next, newpath, size, fi);
                free(newpath);
        }
        return err;
 }
 
-static int iconv_utimens(const char *path, const struct timespec ts[2])
+static int iconv_utimens(const char *path, const struct timespec ts[2],
+                        struct fuse_file_info *fi)
 {
        struct iconv *ic = iconv_get();
        char *newpath;
        int err = iconv_convpath(ic, path, &newpath, 0);
        if (!err) {
-               err = fuse_fs_utimens(ic->next, newpath, ts);
+               err = fuse_fs_utimens(ic->next, newpath, ts, fi);
                free(newpath);
        }
        return err;
@@ -600,7 +579,6 @@ static const struct fuse_operations iconv_oper = {
        .destroy        = iconv_destroy,
        .init           = iconv_init,
        .getattr        = iconv_getattr,
-       .fgetattr       = iconv_fgetattr,
        .access         = iconv_access,
        .readlink       = iconv_readlink,
        .opendir        = iconv_opendir,
@@ -616,7 +594,6 @@ static const struct fuse_operations iconv_oper = {
        .chmod          = iconv_chmod,
        .chown          = iconv_chown,
        .truncate       = iconv_truncate,
-       .ftruncate      = iconv_ftruncate,
        .utimens        = iconv_utimens,
        .create         = iconv_create,
        .open           = iconv_open_file,

diff --git a/lib/modules/subdir.c b/lib/modules/subdir.c
index a039b3cca6ae854de44307104556c3bb0d05bd0b..c264fb44894885d83fa422b2322a565ddf2c3df3 100644 (file)
--- a/lib/modules/subdir.c
+++ b/lib/modules/subdir.c
@@ -52,26 +52,14 @@ static int subdir_addpath(struct subdir *d, const char *path, char **newpathp)
        return 0;
 }
 
-static int subdir_getattr(const char *path, struct stat *stbuf)
+static int subdir_getattr(const char *path, struct stat *stbuf,
+                         struct fuse_file_info *fi)
 {
        struct subdir *d = subdir_get();
        char *newpath;
        int err = subdir_addpath(d, path, &newpath);
        if (!err) {
-               err = fuse_fs_getattr(d->next, newpath, stbuf);
-               free(newpath);
-       }
-       return err;
-}
-
-static int subdir_fgetattr(const char *path, struct stat *stbuf,
-                          struct fuse_file_info *fi)
-{
-       struct subdir *d = subdir_get();
-       char *newpath;
-       int err = subdir_addpath(d, path, &newpath);
-       if (!err) {
-               err = fuse_fs_fgetattr(d->next, newpath, stbuf, fi);
+               err = fuse_fs_getattr(d->next, newpath, stbuf, fi);
                free(newpath);
        }
        return err;
@@ -301,62 +289,53 @@ static int subdir_link(const char *from, const char *to)
        return err;
 }
 
-static int subdir_chmod(const char *path, mode_t mode)
-{
-       struct subdir *d = subdir_get();
-       char *newpath;
-       int err = subdir_addpath(d, path, &newpath);
-       if (!err) {
-               err = fuse_fs_chmod(d->next, newpath, mode);
-               free(newpath);
-       }
-       return err;
-}
-
-static int subdir_chown(const char *path, uid_t uid, gid_t gid)
+static int subdir_chmod(const char *path, mode_t mode,
+                       struct fuse_file_info *fi)
 {
        struct subdir *d = subdir_get();
        char *newpath;
        int err = subdir_addpath(d, path, &newpath);
        if (!err) {
-               err = fuse_fs_chown(d->next, newpath, uid, gid);
+               err = fuse_fs_chmod(d->next, newpath, mode, fi);
                free(newpath);
        }
        return err;
 }
 
-static int subdir_truncate(const char *path, off_t size)
+static int subdir_chown(const char *path, uid_t uid, gid_t gid,
+                       struct fuse_file_info *fi)
 {
        struct subdir *d = subdir_get();
        char *newpath;
        int err = subdir_addpath(d, path, &newpath);
        if (!err) {
-               err = fuse_fs_truncate(d->next, newpath, size);
+               err = fuse_fs_chown(d->next, newpath, uid, gid, fi);
                free(newpath);
        }
        return err;
 }
 
-static int subdir_ftruncate(const char *path, off_t size,
-                           struct fuse_file_info *fi)
+static int subdir_truncate(const char *path, off_t size,
+                          struct fuse_file_info *fi)
 {
        struct subdir *d = subdir_get();
        char *newpath;
        int err = subdir_addpath(d, path, &newpath);
        if (!err) {
-               err = fuse_fs_ftruncate(d->next, newpath, size, fi);
+               err = fuse_fs_truncate(d->next, newpath, size, fi);
                free(newpath);
        }
        return err;
 }
 
-static int subdir_utimens(const char *path, const struct timespec ts[2])
+static int subdir_utimens(const char *path, const struct timespec ts[2],
+                         struct fuse_file_info *fi)
 {
        struct subdir *d = subdir_get();
        char *newpath;
        int err = subdir_addpath(d, path, &newpath);
        if (!err) {
-               err = fuse_fs_utimens(d->next, newpath, ts);
+               err = fuse_fs_utimens(d->next, newpath, ts, fi);
                free(newpath);
        }
        return err;
@@ -582,7 +561,6 @@ static const struct fuse_operations subdir_oper = {
        .destroy        = subdir_destroy,
        .init           = subdir_init,
        .getattr        = subdir_getattr,
-       .fgetattr       = subdir_fgetattr,
        .access         = subdir_access,
        .readlink       = subdir_readlink,
        .opendir        = subdir_opendir,
@@ -598,7 +576,6 @@ static const struct fuse_operations subdir_oper = {
        .chmod          = subdir_chmod,
        .chown          = subdir_chown,
        .truncate       = subdir_truncate,
-       .ftruncate      = subdir_ftruncate,
        .utimens        = subdir_utimens,
        .create         = subdir_create,
        .open           = subdir_open,