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(name: ix->filename); |
31 | |
32 | kfree(objp: ix->ctx.kname); |
33 | kvfree(addr: 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, res: ret, cflags: 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(size: sizeof(*ix->ctx.kname), GFP_KERNEL); |
65 | if (!ix->ctx.kname) |
66 | return -ENOMEM; |
67 | |
68 | ret = strncpy_from_user(dst: ix->ctx.kname->name, src: name, |
69 | count: sizeof(ix->ctx.kname->name)); |
70 | if (!ret || ret == sizeof(ix->ctx.kname->name)) |
71 | ret = -ERANGE; |
72 | if (ret < 0) { |
73 | kfree(objp: 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, NULL); |
100 | if (IS_ERR(ptr: ix->filename)) { |
101 | ret = PTR_ERR(ptr: 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(idmap: mnt_idmap(mnt: req->file->f_path.mnt), |
116 | d: req->file->f_path.dentry, |
117 | ctx: &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, name: ix->filename, flags: lookup_flags, path: &path, NULL); |
134 | if (!ret) { |
135 | ret = do_getxattr(idmap: mnt_idmap(mnt: path.mnt), d: path.dentry, ctx: &ix->ctx); |
136 | |
137 | path_put(&path); |
138 | if (retry_estale(error: ret, flags: 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(size: sizeof(*ix->ctx.kname), GFP_KERNEL); |
166 | if (!ix->ctx.kname) |
167 | return -ENOMEM; |
168 | |
169 | ret = setxattr_copy(name, ctx: &ix->ctx); |
170 | if (ret) { |
171 | kfree(objp: 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, NULL); |
193 | if (IS_ERR(ptr: ix->filename)) { |
194 | ret = PTR_ERR(ptr: 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(mnt: path->mnt); |
213 | if (!ret) { |
214 | ret = do_setxattr(idmap: mnt_idmap(mnt: path->mnt), dentry: path->dentry, ctx: &ix->ctx); |
215 | mnt_drop_write(mnt: 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, path: &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, name: ix->filename, flags: lookup_flags, path: &path, NULL); |
243 | if (!ret) { |
244 | ret = __io_setxattr(req, issue_flags, path: &path); |
245 | path_put(&path); |
246 | if (retry_estale(error: ret, flags: 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 | |