Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
19struct io_xattr {
20 struct file *file;
21 struct kernel_xattr_ctx ctx;
22 struct filename *filename;
23};
24
25void 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
36static 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
44static 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 ix->filename = NULL;
52 ix->ctx.kvalue = NULL;
53 name = u64_to_user_ptr(READ_ONCE(sqe->addr));
54 ix->ctx.value = u64_to_user_ptr(READ_ONCE(sqe->addr2));
55 ix->ctx.size = READ_ONCE(sqe->len);
56 ix->ctx.flags = READ_ONCE(sqe->xattr_flags);
57
58 if (ix->ctx.flags)
59 return -EINVAL;
60
61 ix->ctx.kname = kmalloc(sizeof(*ix->ctx.kname), GFP_KERNEL);
62 if (!ix->ctx.kname)
63 return -ENOMEM;
64
65 ret = import_xattr_name(ix->ctx.kname, name);
66 if (ret) {
67 kfree(ix->ctx.kname);
68 return ret;
69 }
70
71 req->flags |= REQ_F_NEED_CLEANUP;
72 req->flags |= REQ_F_FORCE_ASYNC;
73 return 0;
74}
75
76int io_fgetxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
77{
78 return __io_getxattr_prep(req, sqe);
79}
80
81int io_getxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
82{
83 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr);
84 const char __user *path;
85 int ret;
86
87 if (unlikely(req->flags & REQ_F_FIXED_FILE))
88 return -EBADF;
89
90 ret = __io_getxattr_prep(req, sqe);
91 if (ret)
92 return ret;
93
94 path = u64_to_user_ptr(READ_ONCE(sqe->addr3));
95
96 ix->filename = getname(path);
97 if (IS_ERR(ix->filename))
98 return PTR_ERR(ix->filename);
99
100 return 0;
101}
102
103int io_fgetxattr(struct io_kiocb *req, unsigned int issue_flags)
104{
105 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr);
106 int ret;
107
108 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
109
110 ret = file_getxattr(req->file, &ix->ctx);
111 io_xattr_finish(req, ret);
112 return IOU_OK;
113}
114
115int io_getxattr(struct io_kiocb *req, unsigned int issue_flags)
116{
117 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr);
118 int ret;
119
120 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
121
122 ret = filename_getxattr(AT_FDCWD, ix->filename, LOOKUP_FOLLOW, &ix->ctx);
123 ix->filename = NULL;
124 io_xattr_finish(req, ret);
125 return IOU_OK;
126}
127
128static int __io_setxattr_prep(struct io_kiocb *req,
129 const struct io_uring_sqe *sqe)
130{
131 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr);
132 const char __user *name;
133 int ret;
134
135 ix->filename = NULL;
136 name = u64_to_user_ptr(READ_ONCE(sqe->addr));
137 ix->ctx.cvalue = u64_to_user_ptr(READ_ONCE(sqe->addr2));
138 ix->ctx.kvalue = NULL;
139 ix->ctx.size = READ_ONCE(sqe->len);
140 ix->ctx.flags = READ_ONCE(sqe->xattr_flags);
141
142 ix->ctx.kname = kmalloc(sizeof(*ix->ctx.kname), GFP_KERNEL);
143 if (!ix->ctx.kname)
144 return -ENOMEM;
145
146 ret = setxattr_copy(name, &ix->ctx);
147 if (ret) {
148 kfree(ix->ctx.kname);
149 return ret;
150 }
151
152 req->flags |= REQ_F_NEED_CLEANUP;
153 req->flags |= REQ_F_FORCE_ASYNC;
154 return 0;
155}
156
157int io_setxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
158{
159 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr);
160 const char __user *path;
161 int ret;
162
163 if (unlikely(req->flags & REQ_F_FIXED_FILE))
164 return -EBADF;
165
166 ret = __io_setxattr_prep(req, sqe);
167 if (ret)
168 return ret;
169
170 path = u64_to_user_ptr(READ_ONCE(sqe->addr3));
171
172 ix->filename = getname(path);
173 if (IS_ERR(ix->filename))
174 return PTR_ERR(ix->filename);
175
176 return 0;
177}
178
179int io_fsetxattr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
180{
181 return __io_setxattr_prep(req, sqe);
182}
183
184int io_fsetxattr(struct io_kiocb *req, unsigned int issue_flags)
185{
186 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr);
187 int ret;
188
189 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
190
191 ret = file_setxattr(req->file, &ix->ctx);
192 io_xattr_finish(req, ret);
193 return IOU_OK;
194}
195
196int io_setxattr(struct io_kiocb *req, unsigned int issue_flags)
197{
198 struct io_xattr *ix = io_kiocb_to_cmd(req, struct io_xattr);
199 int ret;
200
201 WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
202
203 ret = filename_setxattr(AT_FDCWD, ix->filename, LOOKUP_FOLLOW, &ix->ctx);
204 ix->filename = NULL;
205 io_xattr_finish(req, ret);
206 return IOU_OK;
207}