1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/kernel.h> 3 #include <linux/errno.h> 4 #include <linux/fs.h> 5 #include <linux/file.h> 6 #include <linux/mm.h> 7 #include <linux/slab.h> 8 #include <linux/namei.h> 9 #include <linux/io_uring.h> 10 #include <linux/xattr.h> 11 12 #include <uapi/linux/io_uring.h> 13 14 #include "../fs/internal.h" 15 16 #include "io_uring.h" 17 #include "xattr.h" 18 19 struct io_xattr { 20 struct file *file; 21 struct xattr_ctx ctx; 22 struct filename *filename; 23 }; 24 25 void io_xattr_cleanup(struct io_kiocb *req) 26 { 27 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 28 29 if (ix->filename) 30 putname(ix->filename); 31 32 kfree(ix->ctx.kname); 33 kvfree(ix->ctx.kvalue); 34 } 35 36 static void io_xattr_finish(struct io_kiocb *req, int ret) 37 { 38 req->flags &= ~REQ_F_NEED_CLEANUP; 39 40 io_xattr_cleanup(req); 41 io_req_set_res(req, ret, 0); 42 } 43 44 static int __io_getxattr_prep(struct io_kiocb *req, 45 const struct io_uring_sqe *sqe) 46 { 47 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 48 const char __user *name; 49 int ret; 50 51 if (unlikely(req->flags & REQ_F_FIXED_FILE)) 52 return -EBADF; 53 54 ix->filename = NULL; 55 ix->ctx.kvalue = NULL; 56 name = u64_to_user_ptr(READ_ONCE(sqe->addr)); 57 ix->ctx.cvalue = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 58 ix->ctx.size = READ_ONCE(sqe->len); 59 ix->ctx.flags = READ_ONCE(sqe->xattr_flags); 60 61 if (ix->ctx.flags) 62 return -EINVAL; 63 64 ix->ctx.kname = kmalloc(sizeof(*ix->ctx.kname), GFP_KERNEL); 65 if (!ix->ctx.kname) 66 return -ENOMEM; 67 68 ret = strncpy_from_user(ix->ctx.kname->name, name, 69 sizeof(ix->ctx.kname->name)); 70 if (!ret || ret == sizeof(ix->ctx.kname->name)) 71 ret = -ERANGE; 72 if (ret < 0) { 73 kfree(ix->ctx.kname); 74 return ret; 75 } 76 77 req->flags |= REQ_F_NEED_CLEANUP; 78 req->flags |= REQ_F_FORCE_ASYNC; 79 return 0; 80 } 81 82 int io_fgetxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 83 { 84 return __io_getxattr_prep(req, sqe); 85 } 86 87 int io_getxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 88 { 89 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 90 const char __user *path; 91 int ret; 92 93 ret = __io_getxattr_prep(req, sqe); 94 if (ret) 95 return ret; 96 97 path = u64_to_user_ptr(READ_ONCE(sqe->addr3)); 98 99 ix->filename = getname_flags(path, LOOKUP_FOLLOW); 100 if (IS_ERR(ix->filename)) { 101 ret = PTR_ERR(ix->filename); 102 ix->filename = NULL; 103 } 104 105 return ret; 106 } 107 108 int io_fgetxattr(struct io_kiocb *req, unsigned int issue_flags) 109 { 110 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 111 int ret; 112 113 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 114 115 ret = do_getxattr(file_mnt_idmap(req->file), 116 req->file->f_path.dentry, 117 &ix->ctx); 118 119 io_xattr_finish(req, ret); 120 return IOU_OK; 121 } 122 123 int io_getxattr(struct io_kiocb *req, unsigned int issue_flags) 124 { 125 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 126 unsigned int lookup_flags = LOOKUP_FOLLOW; 127 struct path path; 128 int ret; 129 130 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 131 132 retry: 133 ret = filename_lookup(AT_FDCWD, ix->filename, lookup_flags, &path, NULL); 134 if (!ret) { 135 ret = do_getxattr(mnt_idmap(path.mnt), path.dentry, &ix->ctx); 136 137 path_put(&path); 138 if (retry_estale(ret, lookup_flags)) { 139 lookup_flags |= LOOKUP_REVAL; 140 goto retry; 141 } 142 } 143 144 io_xattr_finish(req, ret); 145 return IOU_OK; 146 } 147 148 static int __io_setxattr_prep(struct io_kiocb *req, 149 const struct io_uring_sqe *sqe) 150 { 151 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 152 const char __user *name; 153 int ret; 154 155 if (unlikely(req->flags & REQ_F_FIXED_FILE)) 156 return -EBADF; 157 158 ix->filename = NULL; 159 name = u64_to_user_ptr(READ_ONCE(sqe->addr)); 160 ix->ctx.cvalue = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 161 ix->ctx.kvalue = NULL; 162 ix->ctx.size = READ_ONCE(sqe->len); 163 ix->ctx.flags = READ_ONCE(sqe->xattr_flags); 164 165 ix->ctx.kname = kmalloc(sizeof(*ix->ctx.kname), GFP_KERNEL); 166 if (!ix->ctx.kname) 167 return -ENOMEM; 168 169 ret = setxattr_copy(name, &ix->ctx); 170 if (ret) { 171 kfree(ix->ctx.kname); 172 return ret; 173 } 174 175 req->flags |= REQ_F_NEED_CLEANUP; 176 req->flags |= REQ_F_FORCE_ASYNC; 177 return 0; 178 } 179 180 int io_setxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 181 { 182 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 183 const char __user *path; 184 int ret; 185 186 ret = __io_setxattr_prep(req, sqe); 187 if (ret) 188 return ret; 189 190 path = u64_to_user_ptr(READ_ONCE(sqe->addr3)); 191 192 ix->filename = getname_flags(path, LOOKUP_FOLLOW); 193 if (IS_ERR(ix->filename)) { 194 ret = PTR_ERR(ix->filename); 195 ix->filename = NULL; 196 } 197 198 return ret; 199 } 200 201 int io_fsetxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 202 { 203 return __io_setxattr_prep(req, sqe); 204 } 205 206 static int __io_setxattr(struct io_kiocb *req, unsigned int issue_flags, 207 const struct path *path) 208 { 209 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 210 int ret; 211 212 ret = mnt_want_write(path->mnt); 213 if (!ret) { 214 ret = do_setxattr(mnt_idmap(path->mnt), path->dentry, &ix->ctx); 215 mnt_drop_write(path->mnt); 216 } 217 218 return ret; 219 } 220 221 int io_fsetxattr(struct io_kiocb *req, unsigned int issue_flags) 222 { 223 int ret; 224 225 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 226 227 ret = __io_setxattr(req, issue_flags, &req->file->f_path); 228 io_xattr_finish(req, ret); 229 return IOU_OK; 230 } 231 232 int io_setxattr(struct io_kiocb *req, unsigned int issue_flags) 233 { 234 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr); 235 unsigned int lookup_flags = LOOKUP_FOLLOW; 236 struct path path; 237 int ret; 238 239 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK); 240 241 retry: 242 ret = filename_lookup(AT_FDCWD, ix->filename, lookup_flags, &path, NULL); 243 if (!ret) { 244 ret = __io_setxattr(req, issue_flags, &path); 245 path_put(&path); 246 if (retry_estale(ret, lookup_flags)) { 247 lookup_flags |= LOOKUP_REVAL; 248 goto retry; 249 } 250 } 251 252 io_xattr_finish(req, ret); 253 return IOU_OK; 254 } 255