fuse: implement statx

Allow querying btime.  When btime is requested in mask, then FUSE_STATX
request is sent.  Otherwise keep using FUSE_GETATTR.

The userspace interface for statx matches that of the statx(2) API.
However there are limitations on how this interface is used:

 - returned basic stats and btime are used, stx_attributes, etc. are
   ignored

 - always query basic stats and btime, regardless of what was requested

 - requested sync type is ignored, the default is passed to the server

 - if server returns with some attributes missing from the result_mask,
   then no attributes will be cached

 - btime is not cached yet (next patch will fix that)

For new inodes initialize fi->inval_mask to "all invalid", instead of "all
valid" as previously.  Also only clear basic stats from inval_mask when
caching attributes.  This will result in the caching logic not thinking
that btime is cached.

Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>

diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 04006db6e17324e13b9c8fc6579aa9db6b25faf9..e7f63e60118c8e85036733ca310813ff42859573 100644 (file)
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -350,10 +350,14 @@ int fuse_valid_type(int m)
                S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 }
 
+static bool fuse_valid_size(u64 size)
+{
+       return size <= LLONG_MAX;
+}
+
 bool fuse_invalid_attr(struct fuse_attr *attr)
 {
-       return !fuse_valid_type(attr->mode) ||
-               attr->size > LLONG_MAX;
+       return !fuse_valid_type(attr->mode) || !fuse_valid_size(attr->size);
 }
 
 int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
@@ -1143,6 +1147,84 @@ static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
        stat->blksize = 1 << blkbits;
 }
 
+static void fuse_statx_to_attr(struct fuse_statx *sx, struct fuse_attr *attr)
+{
+       memset(attr, 0, sizeof(*attr));
+       attr->ino = sx->ino;
+       attr->size = sx->size;
+       attr->blocks = sx->blocks;
+       attr->atime = sx->atime.tv_sec;
+       attr->mtime = sx->mtime.tv_sec;
+       attr->ctime = sx->ctime.tv_sec;
+       attr->atimensec = sx->atime.tv_nsec;
+       attr->mtimensec = sx->mtime.tv_nsec;
+       attr->ctimensec = sx->ctime.tv_nsec;
+       attr->mode = sx->mode;
+       attr->nlink = sx->nlink;
+       attr->uid = sx->uid;
+       attr->gid = sx->gid;
+       attr->rdev = new_encode_dev(MKDEV(sx->rdev_major, sx->rdev_minor));
+       attr->blksize = sx->blksize;
+}
+
+static int fuse_do_statx(struct inode *inode, struct file *file,
+                        struct kstat *stat)
+{
+       int err;
+       struct fuse_attr attr;
+       struct fuse_statx *sx;
+       struct fuse_statx_in inarg;
+       struct fuse_statx_out outarg;
+       struct fuse_mount *fm = get_fuse_mount(inode);
+       u64 attr_version = fuse_get_attr_version(fm->fc);
+       FUSE_ARGS(args);
+
+       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;
+
+               inarg.getattr_flags |= FUSE_GETATTR_FH;
+               inarg.fh = ff->fh;
+       }
+       /* For now leave sync hints as the default, request all stats. */
+       inarg.sx_flags = 0;
+       inarg.sx_mask = STATX_BASIC_STATS | STATX_BTIME;
+       args.opcode = FUSE_STATX;
+       args.nodeid = get_node_id(inode);
+       args.in_numargs = 1;
+       args.in_args[0].size = sizeof(inarg);
+       args.in_args[0].value = &inarg;
+       args.out_numargs = 1;
+       args.out_args[0].size = sizeof(outarg);
+       args.out_args[0].value = &outarg;
+       err = fuse_simple_request(fm, &args);
+       if (err)
+               return err;
+
+       sx = &outarg.stat;
+       if (((sx->mask & STATX_SIZE) && !fuse_valid_size(sx->size)) ||
+           ((sx->mask & STATX_TYPE) && (!fuse_valid_type(sx->mode) ||
+                                        inode_wrong_type(inode, sx->mode)))) {
+               make_bad_inode(inode);
+               return -EIO;
+       }
+
+       fuse_statx_to_attr(&outarg.stat, &attr);
+       if ((sx->mask & STATX_BASIC_STATS) == STATX_BASIC_STATS) {
+               fuse_change_attributes(inode, &attr, ATTR_TIMEOUT(&outarg),
+                                      attr_version);
+       }
+       stat->result_mask = sx->mask & (STATX_BASIC_STATS | STATX_BTIME);
+       stat->btime.tv_sec = sx->btime.tv_sec;
+       stat->btime.tv_nsec = min_t(u32, sx->btime.tv_nsec, NSEC_PER_SEC - 1);
+       fuse_fillattr(inode, &attr, stat);
+       stat->result_mask |= STATX_TYPE;
+
+       return 0;
+}
+
 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
                           struct file *file)
 {
@@ -1194,13 +1276,18 @@ static int fuse_update_get_attr(struct inode *inode, struct file *file,
                                unsigned int flags)
 {
        struct fuse_inode *fi = get_fuse_inode(inode);
+       struct fuse_conn *fc = get_fuse_conn(inode);
        int err = 0;
        bool sync;
        u32 inval_mask = READ_ONCE(fi->inval_mask);
        u32 cache_mask = fuse_get_cache_mask(inode);
 
-       /* FUSE only supports basic stats */
-       request_mask &= STATX_BASIC_STATS;
+
+       /* FUSE only supports basic stats and possibly btime */
+       request_mask &= STATX_BASIC_STATS | STATX_BTIME;
+retry:
+       if (fc->no_statx)
+               request_mask &= STATX_BASIC_STATS;
 
        if (!request_mask)
                sync = false;
@@ -1215,7 +1302,16 @@ static int fuse_update_get_attr(struct inode *inode, struct file *file,
 
        if (sync) {
                forget_all_cached_acls(inode);
-               err = fuse_do_getattr(inode, stat, file);
+               /* Try statx if BTIME is requested */
+               if (!fc->no_statx && (request_mask & ~STATX_BASIC_STATS)) {
+                       err = fuse_do_statx(inode, file, stat);
+                       if (err == -ENOSYS) {
+                               fc->no_statx = 1;
+                               goto retry;
+                       }
+               } else {
+                       err = fuse_do_getattr(inode, stat, file);
+               }
        } else if (stat) {
                generic_fillattr(&nop_mnt_idmap, inode, stat);
                stat->mode = fi->orig_i_mode;

diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index cfb97a147b66e93bccc0a6e399b4bbcd8f5b483c..43c7b58d8ab745abab0fb76fd8d5a6173a230eee 100644 (file)
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -795,6 +795,9 @@ struct fuse_conn {
        /* relax restrictions in FOPEN_DIRECT_IO mode */
        unsigned int direct_io_relax:1;
 
+       /* Is statx not implemented by fs? */
+       unsigned int no_statx:1;
+
        /** The number of requests waiting for completion */
        atomic_t num_waiting;
 

diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 4a16185eacae7df4f7b84836b4d05cd62e8a61ae..2a4d192502e70bc58f9116d36b3f04d46e6ac59e 100644 (file)
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -77,7 +77,7 @@ static struct inode *fuse_alloc_inode(struct super_block *sb)
                return NULL;
 
        fi->i_time = 0;
-       fi->inval_mask = 0;
+       fi->inval_mask = ~0;
        fi->nodeid = 0;
        fi->nlookup = 0;
        fi->attr_version = 0;
@@ -172,7 +172,8 @@ void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
 
        fi->attr_version = atomic64_inc_return(&fc->attr_version);
        fi->i_time = attr_valid;
-       WRITE_ONCE(fi->inval_mask, 0);
+       /* Clear basic stats from invalid mask */
+       set_mask_bits(&fi->inval_mask, STATX_BASIC_STATS, 0);
 
        inode->i_ino     = fuse_squash_ino(attr->ino);
        inode->i_mode    = (inode->i_mode & S_IFMT) | (attr->mode & 07777);