io_uring: add xattr support
v7 cover io_uring: add xattr support
This adds the xattr support to io_uring. The intent is to have a more complete support for file operations in io_uring.
This change adds support for the following functions to io_uring:
- fgetxattr
- fsetxattr
- getxattr
- setxattr
Patch 1: fs: split off do_user_path_at_empty from user_path_at_empty()
This splits off a new function do_user_path_at_empty from user_path_at_empty that is based on filename and not on a user-specified string.
Patch 2: fs: split off setxattr_copy and do_setxattr function from setxattr
Split off the setup part of the setxattr function in the setxattr_copy function. Split off the processing part in do_setxattr.
Patch 3: fs: split off do_getxattr from getxattr
Split of the do_getxattr part from getxattr. This will allow it to be invoked it from io_uring.
Patch 4: io_uring: add fsetxattr and setxattr support
This adds new functions to support the fsetxattr and setxattr functions.
Patch 5: io_uring: add fgetxattr and getxattr support
This adds new functions to support the fgetxattr and getxattr functions.
There are two additional patches:
liburing: Add support for xattr api's.
This also includes the tests for the new code.
xfstests: Add support for io_uring xattr support.
V7: - split off setxattr in two functions as recommeneded by
Christian.
V6: - reverted addition of kname array to xattr_ctx structure
Adding the kname array increases the io_kiocb beyond 64 bytes (increases it to 224 bytes). We try hard to limit it to 64 bytes. Keeping the original interface also is a bit more efficient.
- addressed Pavel's reordering comment
- addressed Pavel's putname comment
- addressed Pavel's kvfree comment
- rebased on for-5.17/io_uring-getdents64
V5: - add kname array to xattr_ctx structure
V4: - rebased patch series
V3: - remove req->file checks in prep functions
- change size parameter in do_xattr
V2: - split off function do_user_path_empty instead of changing
the function signature of user_path_at
- Fix datatype size problem in do_getxattr
Stefan Roesch (5):
fs: split off do_user_path_at_empty from user_path_at_empty()
fs: split off setxattr_copy and do_setxattr function from setxattr
fs: split off do_getxattr from getxattr
io_uring: add fsetxattr and setxattr support
io_uring: add fgetxattr and getxattr support
fs/internal.h | 25 +++ fs/io_uring.c | 315 ++++++++++++++++++++++++++++++++++ fs/namei.c | 10 +- fs/xattr.c | 119 +++++++++---- include/linux/namei.h | 2 + include/uapi/linux/io_uring.h | 8 +- 6 files changed, 442 insertions(+), 37 deletions(-)
base-commit: b4518682080d3a1cdd6ea45a54ff6772b8b2797a
Signature · 1 line
2.30.2
PATCH v7 1/5 fs: split off do_user_path_at_empty from user_path_at_empty()
This splits off a do_user_path_at_empty function from the user_path_at_empty_function. This is required so it can be called from io_uring.
--- fs/namei.c | 10 ++++++++-- include/linux/namei.h | 2 ++ 2 files changed, 10 insertions(+), 2 deletions(-)
fs/namei.c +8 -2
@@ -2794,12 +2794,18 @@ int path_pts(struct path *path) }#endif +int do_user_path_at_empty (int dfd,struct filename *filename,unsigned int flags, +struct path *path) +{ +return filename_lookup (dfd, filename, flags, path,NULL ); +} +int user_path_at_empty (int dfd,const char __user *name,unsigned flags, -struct path *path,int *empty) +struct path *path,int *empty) {struct filename *filename =getname_flags (name, flags, empty); -int ret =filename_lookup (dfd, filename, flags, path,NULL ); +int ret =do_user_path_at_empty (dfd, filename, flags, path);putname (filename);return ret; }
include/linux/namei.h +2 -0
@@ -49,6 +49,8 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT};extern int path_pts (struct path *path); +extern int do_user_path_at_empty (int dfd,struct filename *filename, +unsigned int flags,struct path *path);extern int user_path_at_empty (int ,const char __user *,unsigned ,struct path *,int *empty); static inline int user_path_at(int dfd, const char __user *name, unsigned flags,
Signature · 1 line
2.30.2
PATCH v7 2/5 fs: split off setxattr_copy and do_setxattr function from setxattr
In reply to Stefan RoeschThis splits of the setup part of the function setxattr in its own dedicated function called setxattr_copy. In addition it also exposes a new function called do_setxattr for making the setxattr call.
This makes it possible to call these two functions from io_uring in the processing of an xattr request.
--- fs/internal.h | 19 +++++++++++ fs/xattr.c | 87 ++++++++++++++++++++++++++++++++++++++------------- 2 files changed, 84 insertions(+), 22 deletions(-)
fs/internal.h +19 -0
@@ -202,3 +202,22 @@ struct linux_dirent64;int vfs_getdents (struct file *file,struct linux_dirent64 __user *dirent,unsigned int count,loff_t *pos); + +/* +* fs/xattr.c: +*/ +struct xattr_ctx { +/* Value of attribute */ +const void __user *value; +size_t size; +/* Attribute name */ +char *kname; +int kname_sz; +unsigned int flags; +}; + + +int setxattr_copy (const char __user *name,struct xattr_ctx *ctx, +void **xattr_val); +int do_setxattr (struct user_namespace *mnt_userns,struct dentry *dentry, +struct xattr_ctx *ctx,void *xattr_val);
fs/xattr.c +65 -22
114 lines not on this page · raw message
Signature · 1 line
2.30.2
Re: [PATCH v7 2/5] fs: split off setxattr_copy and do_setxattr function from setxattr
fs/internal.h struct linux_dirent64; · line 215
Quoted 4 lines · Stefan Roesch
fs/internal.h +3
-0+/* Attribute name */ +char *kname; +int kname_sz;
I still don't like this.
Clearly the "just embed the kname in the context" didn't work, but I hate how this adds that "pointer and size", when the size really should be part of the type.
The patch takes what used to be a fixed size, and turns it into something we pass along as an argument - for no actual good reason. The 'size' isn't even the size of the name, it's literally the size of the allocation that has a fixed definition.
Can we perhaps do it another way, by just encoding the size in the type itself - but keeping it as a pointer.
We have a fixed size for attribute names, so maybe we can do
struct xattr_name {
char name[XATTR_NAME_MAX + 1];
};and actually use that.
Because I don't see that kname_sz is ever validly anything else, and ever has any actual value to be passed around?
Maybe some day we'd actually make that "xattr_name" structure also have the actual length of the name in it, but that would still *not* be the size of the allocation.
I think it's actively misleading to have "kname_sz' that isn't actually the size of the name, but I also think it's stupid to have a variable for what is a constant value.
Linus
Re: [PATCH v7 2/5] fs: split off setxattr_copy and do_setxattr function from setxattr
Quoted 35 lines · Linus Torvalds
fs/internal.h struct linux_dirent64; · line 215
Quoted 4 lines · Stefan Roesch
fs/internal.h +3
-0+/* Attribute name */ +char *kname; +int kname_sz;I still don't like this.
Clearly the "just embed the kname in the context" didn't work, but I hate how this adds that "pointer and size", when the size really should be part of the type.
The patch takes what used to be a fixed size, and turns it into something we pass along as an argument - for no actual good reason. The 'size' isn't even the size of the name, it's literally the size of the allocation that has a fixed definition.
Can we perhaps do it another way, by just encoding the size in the type itself - but keeping it as a pointer.
We have a fixed size for attribute names, so maybe we can do
struct xattr_name { char name[XATTR_NAME_MAX + 1]; };and actually use that.
Because I don't see that
kname_szis ever validly anything else, and ever has any actual value to be passed around?Maybe some day we'd actually make that "
xattr_name" structure also have the actual length of the name in it, but that would still *not* be the size of the allocation.
Quoted 6 lines
I think it's actively misleading to have "
kname_sz' that isn't actually the size of the name, but I also think it's stupid to have a variable for what is a constant value.Linus
Linus, I added the xattr_name struct and removed the kname_sz field from the xattr_ctx struct. In addition the xattr_name struct is used in xattr.c and io_uring.c.
PATCH v7 3/5 fs: split off do_getxattr from getxattr
In reply to Stefan RoeschThis splits off do_getxattr function from the getxattr function. This will allow io_uring to call it from its io worker.
--- fs/internal.h | 6 ++++++ fs/xattr.c | 32 ++++++++++++++++++++------------ 2 files changed, 26 insertions(+), 12 deletions(-)
fs/internal.h +6 -0
@@ -217,6 +217,12 @@ struct xattr_ctx { }; +ssize_t do_getxattr (struct user_namespace *mnt_userns, +struct dentry *d, +const char *kname, +void __user *value, +size_t size); +int setxattr_copy (const char __user *name,struct xattr_ctx *ctx,void **xattr_val); int do_setxattr(struct user_namespace *mnt_userns, struct dentry *dentry,
fs/xattr.c +20 -12
@@ -684,19 +684,12 @@ SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,/* * Extended attribute GET operations */ -static ssize_t -getxattr (struct user_namespace *mnt_userns,struct dentry *d, -const char __user *name,void __user *value,size_t size) +ssize_t +do_getxattr (struct user_namespace *mnt_userns,struct dentry *d, +const char *kname,void __user *value,size_t size) { -ssize_t error;void *kvalue =NULL ; -char kname[XATTR_NAME_MAX +1 ]; - - error =strncpy_from_user (kname, name,sizeof (kname)); -if (error ==0 || error ==sizeof (kname)) - error = -ERANGE ; -if (error <0 ) -return error; +ssize_t error;if (size) {if (size >XATTR_SIZE_MAX )
@@ -720,10 +713,25 @@ getxattr(struct user_namespace *mnt_userns, struct dentry *d, }kvfree (kvalue); -return error; } +static ssize_t +getxattr (struct user_namespace *mnt_userns,struct dentry *d, +const char __user *name,void __user *value,size_t size) +{ +ssize_t error; +char kname[XATTR_NAME_MAX +1 ]; + + error =strncpy_from_user (kname, name,sizeof (kname)); +if (error ==0 || error ==sizeof (kname)) + error = -ERANGE ; +if (error <0 ) +return error; + +return do_getxattr (mnt_userns, d, kname, value, size); +} +static ssize_t path_getxattr (const char __user *pathname,const char __user *name,void __user *value,size_t size,unsigned int lookup_flags)
Signature · 1 line
2.30.2
PATCH v7 4/5 io_uring: add fsetxattr and setxattr support
In reply to Stefan RoeschThis adds support to io_uring for the fsetxattr and setxattr API.
--- fs/io_uring.c | 167 ++++++++++++++++++++++++++++++++++ include/uapi/linux/io_uring.h | 6 +- 2 files changed, 172 insertions(+), 1 deletion(-)
fs/io_uring.c +167 -0
@@ -82,6 +82,7 @@#include <linux/audit.h> #include <linux/security.h> #include <linux/atomic-ref.h> +#include <linux/xattr.h> #define CREATE_TRACE_POINTS #include <trace/events/io_uring.h>
@@ -726,6 +727,13 @@ struct io_async_rw {struct wait_page_queue wpq; }; +struct io_xattr { +struct file *file; +struct xattr_ctx ctx; +void *value; +struct filename *filename; +}; +enum {REQ_F_FIXED_FILE_BIT =IOSQE_FIXED_FILE_BIT ,REQ_F_IO_DRAIN_BIT =IOSQE_IO_DRAIN_BIT ,
@@ -866,6 +874,7 @@ struct io_kiocb {struct io_symlink symlink;struct io_hardlink hardlink;struct io_getdents getdents; +struct io_xattr xattr; };u8 opcode;
@@ -1118,6 +1127,10 @@ static const struct io_op_def io_op_defs[] = { [IORING_OP_GETDENTS ] = { .needs_file =1 , }, + [IORING_OP_FSETXATTR ] = { + .needs_file =1 + }, + [IORING_OP_SETXATTR] = {}, };/* requests with any of those set should undergo io_disarm_next() */
@@ -3887,6 +3900,141 @@ static int io_renameat(struct io_kiocb *req, unsigned int issue_flags)return 0 ; } +static int __io_setxattr_prep (struct io_kiocb *req, +const struct io_uring_sqe *sqe) +{ +struct io_xattr *ix = &req->xattr; +const char __user *name; +int ret; + +if (unlikely (req->ctx->flags &IORING_SETUP_IOPOLL )) +return -EINVAL ; +if (unlikely (sqe->ioprio)) +return -EINVAL ; +if (unlikely (req->flags &REQ_F_FIXED_FILE )) +return -EBADF ; + + ix->filename =NULL ; + name =u64_to_user_ptr (READ_ONCE (sqe->addr)); + ix->ctx.value =u64_to_user_ptr (READ_ONCE (sqe->addr2)); + ix->ctx.size =READ_ONCE (sqe->len); + ix->ctx.flags =READ_ONCE (sqe->xattr_flags); + + ix->ctx.kname =kmalloc (XATTR_NAME_MAX +1 ,GFP_KERNEL ); +if (!ix->ctx.kname) +return -ENOMEM ; + ix->ctx.kname_sz =XATTR_NAME_MAX +1 ; + + ret =setxattr_copy (name, &ix->ctx, &ix->value); +if (ret) { +kfree (ix->ctx.kname); +return ret; + } + + req->flags |=REQ_F_NEED_CLEANUP ; +return 0 ; +} + +static int io_setxattr_prep (struct io_kiocb *req, +const struct io_uring_sqe *sqe) +{ +struct io_xattr *ix = &req->xattr; +const char __user *path; +int ret; + + ret =__io_setxattr_prep (req, sqe); +if (ret) +return ret; + + path =u64_to_user_ptr (READ_ONCE (sqe->addr3)); + + ix->filename =getname_flags (path,LOOKUP_FOLLOW ,NULL ); +if (IS_ERR (ix->filename)) { + ret =PTR_ERR (ix->filename); + ix->filename =NULL ; + } + +return ret; +} + +static int io_fsetxattr_prep (struct io_kiocb *req, +const struct io_uring_sqe *sqe) +{ +return __io_setxattr_prep (req, sqe); +} + +static int __io_setxattr (struct io_kiocb *req,unsigned int issue_flags, +struct path *path) +{ +struct io_xattr *ix = &req->xattr; +int ret; + + ret =mnt_want_write (path->mnt); +if (!ret) { + ret =do_setxattr (mnt_user_ns (path->mnt), path->dentry, + &ix->ctx, ix->value); +mnt_drop_write (path->mnt); + } + +return ret; +} + +static int io_fsetxattr (struct io_kiocb *req,unsigned int issue_flags) +{ +struct io_xattr *ix = &req->xattr; +int ret; + +if (issue_flags &IO_URING_F_NONBLOCK ) +return -EAGAIN ; + + ret =__io_setxattr (req, issue_flags, &req->file->f_path); + + req->flags &= ~REQ_F_NEED_CLEANUP ; +kfree (ix->ctx.kname); + +if (ix->value) +kvfree (ix->value); +if (ret <0 ) +req_set_fail (req); + +io_req_complete (req, ret); +return 0 ; +} + +static int io_setxattr (struct io_kiocb *req,unsigned int issue_flags) +{ +struct io_xattr *ix = &req->xattr; +unsigned int lookup_flags =LOOKUP_FOLLOW ; +struct path path; +int ret; + +if (issue_flags &IO_URING_F_NONBLOCK ) +return -EAGAIN ; + +retry: + ret =do_user_path_at_empty (AT_FDCWD , ix->filename, lookup_flags, &path); +if (!ret) { + ret =__io_setxattr (req, issue_flags, &path); +path_put (&path); +if (retry_estale (ret, lookup_flags)) { + lookup_flags |=LOOKUP_REVAL ; + goto retry; + } + } +putname (ix->filename); + + req->flags &= ~REQ_F_NEED_CLEANUP ; +kfree (ix->ctx.kname); + +if (ix->value) +kvfree (ix->value); +if (ret <0 ) +req_set_fail (req); + +io_req_complete (req, ret); +return 0 ; +} +static int io_unlinkat_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe) {
@@ -6623,6 +6771,10 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)return io_linkat_prep (req, sqe);case IORING_OP_GETDENTS :return io_getdents_prep (req, sqe); +case IORING_OP_FSETXATTR : +return io_fsetxattr_prep (req, sqe); +case IORING_OP_SETXATTR : +return io_setxattr_prep (req, sqe); } printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
@@ -6764,6 +6916,14 @@ static void io_clean_op(struct io_kiocb *req)putname (req->hardlink.oldpath);putname (req->hardlink.newpath);break ; +case IORING_OP_SETXATTR : +if (req->xattr.filename) +putname (req->xattr.filename); + fallthrough; +case IORING_OP_FSETXATTR : +kfree (req->xattr.ctx.kname); +kvfree (req->xattr.value); +break ; } }if ((req->flags &REQ_F_POLLED ) && req->apoll) {
@@ -6909,6 +7069,12 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)case IORING_OP_GETDENTS : ret =io_getdents (req, issue_flags);break ; +case IORING_OP_FSETXATTR : + ret =io_fsetxattr (req, issue_flags); +break ; +case IORING_OP_SETXATTR : + ret =io_setxattr (req, issue_flags); +break ;default : ret = -EINVAL ;break ;
@@ -11277,6 +11443,7 @@ static int __init io_uring_init(void)BUILD_BUG_SQE_ELEM (42 , __u16, personality);BUILD_BUG_SQE_ELEM (44 , __s32, splice_fd_in);BUILD_BUG_SQE_ELEM (44 , __u32, file_index); +BUILD_BUG_SQE_ELEM (48 , __u64, addr3);BUILD_BUG_ON (sizeof (struct io_uring_files_update ) !=sizeof (struct io_uring_rsrc_update ));
include/uapi/linux/io_uring.h +5 -1
@@ -45,6 +45,7 @@ struct io_uring_sqe {__u32 rename_flags;__u32 unlink_flags;__u32 hardlink_flags; +__u32 xattr_flags; };__u64 user_data;/* data to be passed back at completion time */ /* pack this to avoid bogus arm OABI complaints */
@@ -60,7 +61,8 @@ struct io_uring_sqe {__s32 splice_fd_in;__u32 file_index; }; -__u64 __pad2[2 ]; +__u64 addr3; +__u64 __pad2[1 ]; };enum {
@@ -144,6 +146,8 @@ enum {IORING_OP_SYMLINKAT ,IORING_OP_LINKAT ,IORING_OP_GETDENTS , +IORING_OP_FSETXATTR , +IORING_OP_SETXATTR ,/* this goes last, obviously */ IORING_OP_LAST,
Signature · 1 line
2.30.2
PATCH v7 5/5 io_uring: add fgetxattr and getxattr support
In reply to Stefan RoeschThis adds support to io_uring for the fgetxattr and getxattr API.
--- fs/io_uring.c | 148 ++++++++++++++++++++++++++++++++++ include/uapi/linux/io_uring.h | 2 + 2 files changed, 150 insertions(+)
fs/io_uring.c +148 -0
@@ -1131,6 +1131,10 @@ static const struct io_op_def io_op_defs[] = { .needs_file = 1 }, [IORING_OP_SETXATTR] = {}, + [IORING_OP_FGETXATTR ] = { + .needs_file =1 + }, + [IORING_OP_GETXATTR] = {}, };/* requests with any of those set should undergo io_disarm_next() */
@@ -3900,6 +3904,133 @@ static int io_renameat(struct io_kiocb *req, unsigned int issue_flags)return 0 ; } +static int __io_getxattr_prep (struct io_kiocb *req, +const struct io_uring_sqe *sqe) +{ +struct io_xattr *ix = &req->xattr; +const char __user *name; +int ret; + +if (unlikely (req->ctx->flags &IORING_SETUP_IOPOLL )) +return -EINVAL ; +if (unlikely (sqe->ioprio)) +return -EINVAL ; +if (unlikely (req->flags &REQ_F_FIXED_FILE )) +return -EBADF ; + + ix->filename =NULL ; + ix->value =NULL ; + name =u64_to_user_ptr (READ_ONCE (sqe->addr)); + ix->ctx.value =u64_to_user_ptr (READ_ONCE (sqe->addr2)); + ix->ctx.size =READ_ONCE (sqe->len); + ix->ctx.flags =READ_ONCE (sqe->xattr_flags); + +if (ix->ctx.flags) +return -EINVAL ; + + ix->ctx.kname =kmalloc (XATTR_NAME_MAX +1 ,GFP_KERNEL ); +if (!ix->ctx.kname) +return -ENOMEM ; + + ret =strncpy_from_user (ix->ctx.kname, name,XATTR_NAME_MAX +1 ); +if (!ret || ret ==XATTR_NAME_MAX +1 ) + ret = -ERANGE ; +if (ret <0 ) { +kfree (ix->ctx.kname); +return ret; + } + + req->flags |=REQ_F_NEED_CLEANUP ; +return 0 ; +} + +static int io_fgetxattr_prep (struct io_kiocb *req, +const struct io_uring_sqe *sqe) +{ +return __io_getxattr_prep (req, sqe); +} + +static int io_getxattr_prep (struct io_kiocb *req, +const struct io_uring_sqe *sqe) +{ +struct io_xattr *ix = &req->xattr; +const char __user *path; +int ret; + + ret =__io_getxattr_prep (req, sqe); +if (ret) +return ret; + + path =u64_to_user_ptr (READ_ONCE (sqe->addr3)); + + ix->filename =getname_flags (path,LOOKUP_FOLLOW ,NULL ); +if (IS_ERR (ix->filename)) { + ret =PTR_ERR (ix->filename); + ix->filename =NULL ; + } + +return ret; +} + +static int io_fgetxattr (struct io_kiocb *req,unsigned int issue_flags) +{ +struct io_xattr *ix = &req->xattr; +int ret; + +if (issue_flags &IO_URING_F_NONBLOCK ) +return -EAGAIN ; + + ret =do_getxattr (mnt_user_ns (req->file->f_path.mnt), + req->file->f_path.dentry, + ix->ctx.kname, + (void __user *)ix->ctx.value, + ix->ctx.size); + + req->flags &= ~REQ_F_NEED_CLEANUP ; +kfree (ix->ctx.kname); +if (ret <0 ) +req_set_fail (req); + +io_req_complete (req, ret); +return 0 ; +} + +static int io_getxattr (struct io_kiocb *req,unsigned int issue_flags) +{ +struct io_xattr *ix = &req->xattr; +unsigned int lookup_flags =LOOKUP_FOLLOW ; +struct path path; +int ret; + +if (issue_flags &IO_URING_F_NONBLOCK ) +return -EAGAIN ; + +retry: + ret =do_user_path_at_empty (AT_FDCWD , ix->filename, lookup_flags, &path); +if (!ret) { + ret =do_getxattr (mnt_user_ns (path.mnt), + path.dentry, + ix->ctx.kname, + (void __user *)ix->ctx.value, + ix->ctx.size); + +path_put (&path); +if (retry_estale (ret, lookup_flags)) { + lookup_flags |=LOOKUP_REVAL ; + goto retry; + } + } +putname (ix->filename); + + req->flags &= ~REQ_F_NEED_CLEANUP ; +kfree (ix->ctx.kname); +if (ret <0 ) +req_set_fail (req); + +io_req_complete (req, ret); +return 0 ; +} +static int __io_setxattr_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe) {
@@ -6775,6 +6906,10 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)return io_fsetxattr_prep (req, sqe);case IORING_OP_SETXATTR :return io_setxattr_prep (req, sqe); +case IORING_OP_FGETXATTR : +return io_fgetxattr_prep (req, sqe); +case IORING_OP_GETXATTR : +return io_getxattr_prep (req, sqe); } printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
@@ -6924,6 +7059,13 @@ static void io_clean_op(struct io_kiocb *req)kfree (req->xattr.ctx.kname);kvfree (req->xattr.value);break ; +case IORING_OP_GETXATTR : +if (req->xattr.filename) +putname (req->xattr.filename); + fallthrough; +case IORING_OP_FGETXATTR : +kfree (req->xattr.ctx.kname); +break ; } }if ((req->flags &REQ_F_POLLED ) && req->apoll) {
@@ -7075,6 +7217,12 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)case IORING_OP_SETXATTR : ret =io_setxattr (req, issue_flags);break ; +case IORING_OP_FGETXATTR : + ret =io_fgetxattr (req, issue_flags); +break ; +case IORING_OP_GETXATTR : + ret =io_getxattr (req, issue_flags); +break ;default : ret = -EINVAL ;break ;
include/uapi/linux/io_uring.h +2 -0
@@ -148,6 +148,8 @@ enum {IORING_OP_GETDENTS ,IORING_OP_FSETXATTR ,IORING_OP_SETXATTR , +IORING_OP_FGETXATTR , +IORING_OP_GETXATTR ,/* this goes last, obviously */ IORING_OP_LAST,
Signature · 1 line
2.30.2