On Tue, Nov 02, 2021 at 01:25:59PM +0800, Jeffle Xu wrote: > We add 'always', 'never', and 'inode' (default). '-o dax' continues to > operate the same which is equivalent to 'always'. > > The following behavior is consistent with that on ext4/xfs: > - The default behavior (when neither '-o dax' nor > '-o dax=always|never|inode' option is specified) is equal to 'inode' > mode, while 'dax=inode' won't be printed among the mount option list. > - The 'inode' mode is only advisory. It will silently fallback to > 'never' mode if fuse server doesn't support that. > > Also noted that by the time of this commit, 'inode' mode is actually > equal to 'always' mode, before the per inode DAX flag is introduced in > the following patch. > > Signed-off-by: Jeffle Xu <jeffl...@linux.alibaba.com> > --- > fs/fuse/dax.c | 9 ++++++++- > fs/fuse/fuse_i.h | 20 ++++++++++++++++++-- > fs/fuse/inode.c | 10 +++++++--- > fs/fuse/virtio_fs.c | 18 +++++++++++++++--- > 4 files changed, 48 insertions(+), 9 deletions(-) > > diff --git a/fs/fuse/dax.c b/fs/fuse/dax.c > index 8c187b04874e..91c8d146dbc4 100644 > --- a/fs/fuse/dax.c > +++ b/fs/fuse/dax.c > @@ -1284,11 +1284,14 @@ static int fuse_dax_mem_range_init(struct > fuse_conn_dax *fcd) > return ret; > } > > -int fuse_dax_conn_alloc(struct fuse_conn *fc, struct dax_device *dax_dev) > +int fuse_dax_conn_alloc(struct fuse_conn *fc, enum fuse_dax_mode dax_mode, > + struct dax_device *dax_dev) > { > struct fuse_conn_dax *fcd; > int err; > > + fc->dax_mode = dax_mode; > + > if (!dax_dev) > return 0; > > @@ -1335,6 +1338,10 @@ static const struct address_space_operations > fuse_dax_file_aops = { > static bool fuse_should_enable_dax(struct inode *inode) > { > struct fuse_conn *fc = get_fuse_conn(inode); > + enum fuse_dax_mode dax_mode = fc->dax_mode; > + > + if (dax_mode == FUSE_DAX_NEVER) > + return false; > > if (!fc->dax) > return false; > diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h > index f55f9f94b1a4..4f9c2358f343 100644 > --- a/fs/fuse/fuse_i.h > +++ b/fs/fuse/fuse_i.h > @@ -480,6 +480,18 @@ struct fuse_dev { > struct list_head entry; > }; > > +enum fuse_dax_mode { > + FUSE_DAX_NONE, /* default */ > + FUSE_DAX_ALWAYS, /* "-o dax=always" */ > + FUSE_DAX_NEVER, /* "-o dax=never" */ > + FUSE_DAX_INODE, /* "-o dax=inode" */ > +}; Hi,
Not sure why do we need FUSE_DAX_NONE. Now default is FUSE_DAX_INODE and "-o dax" will map to FUSE_DAX_ALWAYS. So after this patch series, nobody should be using FUSE_DAX_NONE state at all? So we should be able to get rid of entirely? > + > +static inline bool fuse_is_inode_dax_mode(enum fuse_dax_mode mode) > +{ > + return mode == FUSE_DAX_INODE || mode == FUSE_DAX_NONE; > +} This is confusing. Why FUSE_DAX_NONE is equivalent to inode dax mode. Is it because you want FUSE_DAX_INODE as default. If that's the case, lets get rid of FUSE_DAX_NONE and just set FUSE_DAX_INODE as default? > + > struct fuse_fs_context { > int fd; > struct file *file; > @@ -497,7 +509,7 @@ struct fuse_fs_context { > bool no_control:1; > bool no_force_umount:1; > bool legacy_opts_show:1; > - bool dax:1; > + enum fuse_dax_mode dax_mode; > unsigned int max_read; > unsigned int blksize; > const char *subtype; > @@ -802,6 +814,9 @@ struct fuse_conn { > struct list_head devices; > > #ifdef CONFIG_FUSE_DAX > + /* Dax mode */ > + enum fuse_dax_mode dax_mode; > + > /* Dax specific conn data, non-NULL if DAX is enabled */ > struct fuse_conn_dax *dax; > #endif > @@ -1258,7 +1273,8 @@ ssize_t fuse_dax_read_iter(struct kiocb *iocb, struct > iov_iter *to); > ssize_t fuse_dax_write_iter(struct kiocb *iocb, struct iov_iter *from); > int fuse_dax_mmap(struct file *file, struct vm_area_struct *vma); > int fuse_dax_break_layouts(struct inode *inode, u64 dmap_start, u64 > dmap_end); > -int fuse_dax_conn_alloc(struct fuse_conn *fc, struct dax_device *dax_dev); > +int fuse_dax_conn_alloc(struct fuse_conn *fc, enum fuse_dax_mode mode, > + struct dax_device *dax_dev); > void fuse_dax_conn_free(struct fuse_conn *fc); > bool fuse_dax_inode_alloc(struct super_block *sb, struct fuse_inode *fi); > void fuse_dax_inode_init(struct inode *inode); > diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c > index 12d49a1914e8..15ce56f9cf11 100644 > --- a/fs/fuse/inode.c > +++ b/fs/fuse/inode.c > @@ -734,8 +734,12 @@ static int fuse_show_options(struct seq_file *m, struct > dentry *root) > seq_printf(m, ",blksize=%lu", sb->s_blocksize); > } > #ifdef CONFIG_FUSE_DAX > - if (fc->dax) > - seq_puts(m, ",dax"); > + if (fc->dax_mode == FUSE_DAX_ALWAYS) > + seq_puts(m, ",dax=always"); > + else if (fc->dax_mode == FUSE_DAX_NEVER) > + seq_puts(m, ",dax=never"); > + else if (fc->dax_mode == FUSE_DAX_INODE) > + seq_puts(m, ",dax=inode"); I guess this answers the question about FUSE_DAX_NONE. You want to keep track if user passed in "dax=inode" or you defaulted to dax=inode. And if you defaulted to "dax=inode" you don't want to show it in fuse options. Hmm..., if that's the intent, I would rather keep the names like this. FUSE_DAX_INODE_USER and FUSE_DAX_INODE_DEFAULT. This clearly tells me the difference between two states. > #endif > > return 0; > @@ -1481,7 +1485,7 @@ int fuse_fill_super_common(struct super_block *sb, > struct fuse_fs_context *ctx) > sb->s_subtype = ctx->subtype; > ctx->subtype = NULL; > if (IS_ENABLED(CONFIG_FUSE_DAX)) { > - err = fuse_dax_conn_alloc(fc, ctx->dax_dev); > + err = fuse_dax_conn_alloc(fc, ctx->dax_mode, ctx->dax_dev); > if (err) > goto err; > } > diff --git a/fs/fuse/virtio_fs.c b/fs/fuse/virtio_fs.c > index 94fc874f5de7..e8c404946c63 100644 > --- a/fs/fuse/virtio_fs.c > +++ b/fs/fuse/virtio_fs.c > @@ -88,12 +88,21 @@ struct virtio_fs_req_work { > static int virtio_fs_enqueue_req(struct virtio_fs_vq *fsvq, > struct fuse_req *req, bool in_flight); > > +static const struct constant_table dax_param_enums[] = { > + {"always", FUSE_DAX_ALWAYS }, > + {"never", FUSE_DAX_NEVER }, > + {"inode", FUSE_DAX_INODE }, > + {} > +}; > + > enum { > OPT_DAX, > + OPT_DAX_ENUM, > }; > > static const struct fs_parameter_spec virtio_fs_parameters[] = { > fsparam_flag("dax", OPT_DAX), > + fsparam_enum("dax", OPT_DAX_ENUM, dax_param_enums), > {} > }; > > @@ -110,7 +119,10 @@ static int virtio_fs_parse_param(struct fs_context *fsc, > > switch (opt) { > case OPT_DAX: > - ctx->dax = 1; > + ctx->dax_mode = FUSE_DAX_ALWAYS; > + break; > + case OPT_DAX_ENUM: > + ctx->dax_mode = result.uint_32; > break; > default: > return -EINVAL; > @@ -1326,8 +1338,8 @@ static int virtio_fs_fill_super(struct super_block *sb, > struct fs_context *fsc) > > /* virtiofs allocates and installs its own fuse devices */ > ctx->fudptr = NULL; > - if (ctx->dax) { > - if (!fs->dax_dev) { > + if (ctx->dax_mode != FUSE_DAX_NEVER) { ^^ Why do we need this check. IOW, why following check alone is not sufficient. > + if (ctx->dax_mode == FUSE_DAX_ALWAYS && !fs->dax_dev) { ^^^ If user specified dax mode FUSE_DAX_ALWAYS, we need to make sure fs device supports dax. And second if condition seems sufficient. Vivek > err = -EINVAL; > pr_err("virtio-fs: dax can't be enabled as filesystem" > " device does not support it.\n"); > -- > 2.27.0 > _______________________________________________ Virtio-fs mailing list Virtio-fs@redhat.com https://listman.redhat.com/mailman/listinfo/virtio-fs