system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-07-21 10:41:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fuse: implement statx

Browse source 
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>
This commit is contained in:
Miklos Szeredi 2023-08-10 12:45:05 +02:00
parent 9dc10a54ab
commit d3045530bd
3 changed files with 107 additions and 7 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

106
fs/fuse/dir.c
View file

@ -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;

3
fs/fuse/fuse_i.h
View file

@ -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;

5
fs/fuse/inode.c
View file

@ -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);