Line data Source code
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/nospec.h>
9 : #include <linux/hugetlb.h>
10 : #include <linux/compat.h>
11 : #include <linux/io_uring.h>
12 :
13 : #include <uapi/linux/io_uring.h>
14 :
15 : #include "io_uring.h"
16 : #include "openclose.h"
17 : #include "rsrc.h"
18 :
19 : struct io_rsrc_update {
20 : struct file *file;
21 : u64 arg;
22 : u32 nr_args;
23 : u32 offset;
24 : };
25 :
26 : static int io_sqe_buffer_register(struct io_ring_ctx *ctx, struct iovec *iov,
27 : struct io_mapped_ubuf **pimu,
28 : struct page **last_hpage);
29 :
30 : #define IO_RSRC_REF_BATCH 100
31 :
32 : /* only define max */
33 : #define IORING_MAX_FIXED_FILES (1U << 20)
34 : #define IORING_MAX_REG_BUFFERS (1U << 14)
35 :
36 0 : void io_rsrc_refs_drop(struct io_ring_ctx *ctx)
37 : __must_hold(&ctx->uring_lock)
38 : {
39 0 : if (ctx->rsrc_cached_refs) {
40 0 : io_rsrc_put_node(ctx->rsrc_node, ctx->rsrc_cached_refs);
41 0 : ctx->rsrc_cached_refs = 0;
42 : }
43 0 : }
44 :
45 0 : int __io_account_mem(struct user_struct *user, unsigned long nr_pages)
46 : {
47 : unsigned long page_limit, cur_pages, new_pages;
48 :
49 0 : if (!nr_pages)
50 : return 0;
51 :
52 : /* Don't allow more pages than we can safely lock */
53 0 : page_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
54 :
55 0 : cur_pages = atomic_long_read(&user->locked_vm);
56 : do {
57 0 : new_pages = cur_pages + nr_pages;
58 0 : if (new_pages > page_limit)
59 : return -ENOMEM;
60 0 : } while (!atomic_long_try_cmpxchg(&user->locked_vm,
61 0 : &cur_pages, new_pages));
62 : return 0;
63 : }
64 :
65 : static void io_unaccount_mem(struct io_ring_ctx *ctx, unsigned long nr_pages)
66 : {
67 0 : if (ctx->user)
68 0 : __io_unaccount_mem(ctx->user, nr_pages);
69 :
70 0 : if (ctx->mm_account)
71 0 : atomic64_sub(nr_pages, &ctx->mm_account->pinned_vm);
72 : }
73 :
74 0 : static int io_account_mem(struct io_ring_ctx *ctx, unsigned long nr_pages)
75 : {
76 : int ret;
77 :
78 0 : if (ctx->user) {
79 0 : ret = __io_account_mem(ctx->user, nr_pages);
80 0 : if (ret)
81 : return ret;
82 : }
83 :
84 0 : if (ctx->mm_account)
85 0 : atomic64_add(nr_pages, &ctx->mm_account->pinned_vm);
86 :
87 : return 0;
88 : }
89 :
90 0 : static int io_copy_iov(struct io_ring_ctx *ctx, struct iovec *dst,
91 : void __user *arg, unsigned index)
92 : {
93 : struct iovec __user *src;
94 :
95 : #ifdef CONFIG_COMPAT
96 : if (ctx->compat) {
97 : struct compat_iovec __user *ciovs;
98 : struct compat_iovec ciov;
99 :
100 : ciovs = (struct compat_iovec __user *) arg;
101 : if (copy_from_user(&ciov, &ciovs[index], sizeof(ciov)))
102 : return -EFAULT;
103 :
104 : dst->iov_base = u64_to_user_ptr((u64)ciov.iov_base);
105 : dst->iov_len = ciov.iov_len;
106 : return 0;
107 : }
108 : #endif
109 0 : src = (struct iovec __user *) arg;
110 0 : if (copy_from_user(dst, &src[index], sizeof(*dst)))
111 : return -EFAULT;
112 : return 0;
113 : }
114 :
115 : static int io_buffer_validate(struct iovec *iov)
116 : {
117 0 : unsigned long tmp, acct_len = iov->iov_len + (PAGE_SIZE - 1);
118 :
119 : /*
120 : * Don't impose further limits on the size and buffer
121 : * constraints here, we'll -EINVAL later when IO is
122 : * submitted if they are wrong.
123 : */
124 0 : if (!iov->iov_base)
125 0 : return iov->iov_len ? -EFAULT : 0;
126 0 : if (!iov->iov_len)
127 : return -EFAULT;
128 :
129 : /* arbitrary limit, but we need something */
130 0 : if (iov->iov_len > SZ_1G)
131 : return -EFAULT;
132 :
133 0 : if (check_add_overflow((unsigned long)iov->iov_base, acct_len, &tmp))
134 : return -EOVERFLOW;
135 :
136 : return 0;
137 : }
138 :
139 0 : static void io_buffer_unmap(struct io_ring_ctx *ctx, struct io_mapped_ubuf **slot)
140 : {
141 0 : struct io_mapped_ubuf *imu = *slot;
142 : unsigned int i;
143 :
144 0 : if (imu != ctx->dummy_ubuf) {
145 0 : for (i = 0; i < imu->nr_bvecs; i++)
146 0 : unpin_user_page(imu->bvec[i].bv_page);
147 0 : if (imu->acct_pages)
148 0 : io_unaccount_mem(ctx, imu->acct_pages);
149 0 : kvfree(imu);
150 : }
151 0 : *slot = NULL;
152 0 : }
153 :
154 0 : void io_rsrc_refs_refill(struct io_ring_ctx *ctx)
155 : __must_hold(&ctx->uring_lock)
156 : {
157 0 : ctx->rsrc_cached_refs += IO_RSRC_REF_BATCH;
158 0 : percpu_ref_get_many(&ctx->rsrc_node->refs, IO_RSRC_REF_BATCH);
159 0 : }
160 :
161 0 : static void __io_rsrc_put_work(struct io_rsrc_node *ref_node)
162 : {
163 0 : struct io_rsrc_data *rsrc_data = ref_node->rsrc_data;
164 0 : struct io_ring_ctx *ctx = rsrc_data->ctx;
165 : struct io_rsrc_put *prsrc, *tmp;
166 :
167 0 : list_for_each_entry_safe(prsrc, tmp, &ref_node->rsrc_list, list) {
168 0 : list_del(&prsrc->list);
169 :
170 0 : if (prsrc->tag) {
171 0 : if (ctx->flags & IORING_SETUP_IOPOLL) {
172 0 : mutex_lock(&ctx->uring_lock);
173 0 : io_post_aux_cqe(ctx, prsrc->tag, 0, 0);
174 0 : mutex_unlock(&ctx->uring_lock);
175 : } else {
176 0 : io_post_aux_cqe(ctx, prsrc->tag, 0, 0);
177 : }
178 : }
179 :
180 0 : rsrc_data->do_put(ctx, prsrc);
181 0 : kfree(prsrc);
182 : }
183 :
184 0 : io_rsrc_node_destroy(ref_node);
185 0 : if (atomic_dec_and_test(&rsrc_data->refs))
186 0 : complete(&rsrc_data->done);
187 0 : }
188 :
189 0 : void io_rsrc_put_work(struct work_struct *work)
190 : {
191 : struct io_ring_ctx *ctx;
192 : struct llist_node *node;
193 :
194 0 : ctx = container_of(work, struct io_ring_ctx, rsrc_put_work.work);
195 0 : node = llist_del_all(&ctx->rsrc_put_llist);
196 :
197 0 : while (node) {
198 : struct io_rsrc_node *ref_node;
199 0 : struct llist_node *next = node->next;
200 :
201 0 : ref_node = llist_entry(node, struct io_rsrc_node, llist);
202 0 : __io_rsrc_put_work(ref_node);
203 0 : node = next;
204 : }
205 0 : }
206 :
207 0 : void io_rsrc_put_tw(struct callback_head *cb)
208 : {
209 0 : struct io_ring_ctx *ctx = container_of(cb, struct io_ring_ctx,
210 : rsrc_put_tw);
211 :
212 0 : io_rsrc_put_work(&ctx->rsrc_put_work.work);
213 0 : }
214 :
215 0 : void io_wait_rsrc_data(struct io_rsrc_data *data)
216 : {
217 0 : if (data && !atomic_dec_and_test(&data->refs))
218 0 : wait_for_completion(&data->done);
219 0 : }
220 :
221 0 : void io_rsrc_node_destroy(struct io_rsrc_node *ref_node)
222 : {
223 0 : percpu_ref_exit(&ref_node->refs);
224 0 : kfree(ref_node);
225 0 : }
226 :
227 0 : static __cold void io_rsrc_node_ref_zero(struct percpu_ref *ref)
228 : {
229 0 : struct io_rsrc_node *node = container_of(ref, struct io_rsrc_node, refs);
230 0 : struct io_ring_ctx *ctx = node->rsrc_data->ctx;
231 : unsigned long flags;
232 0 : bool first_add = false;
233 0 : unsigned long delay = HZ;
234 :
235 0 : spin_lock_irqsave(&ctx->rsrc_ref_lock, flags);
236 0 : node->done = true;
237 :
238 : /* if we are mid-quiesce then do not delay */
239 0 : if (node->rsrc_data->quiesce)
240 0 : delay = 0;
241 :
242 0 : while (!list_empty(&ctx->rsrc_ref_list)) {
243 0 : node = list_first_entry(&ctx->rsrc_ref_list,
244 : struct io_rsrc_node, node);
245 : /* recycle ref nodes in order */
246 0 : if (!node->done)
247 : break;
248 0 : list_del(&node->node);
249 0 : first_add |= llist_add(&node->llist, &ctx->rsrc_put_llist);
250 : }
251 0 : spin_unlock_irqrestore(&ctx->rsrc_ref_lock, flags);
252 :
253 0 : if (!first_add)
254 : return;
255 :
256 0 : if (ctx->submitter_task) {
257 0 : if (!task_work_add(ctx->submitter_task, &ctx->rsrc_put_tw,
258 : ctx->notify_method))
259 : return;
260 : }
261 0 : mod_delayed_work(system_wq, &ctx->rsrc_put_work, delay);
262 : }
263 :
264 0 : static struct io_rsrc_node *io_rsrc_node_alloc(void)
265 : {
266 : struct io_rsrc_node *ref_node;
267 :
268 0 : ref_node = kzalloc(sizeof(*ref_node), GFP_KERNEL);
269 0 : if (!ref_node)
270 : return NULL;
271 :
272 0 : if (percpu_ref_init(&ref_node->refs, io_rsrc_node_ref_zero,
273 : 0, GFP_KERNEL)) {
274 0 : kfree(ref_node);
275 0 : return NULL;
276 : }
277 0 : INIT_LIST_HEAD(&ref_node->node);
278 0 : INIT_LIST_HEAD(&ref_node->rsrc_list);
279 0 : ref_node->done = false;
280 0 : return ref_node;
281 : }
282 :
283 0 : void io_rsrc_node_switch(struct io_ring_ctx *ctx,
284 : struct io_rsrc_data *data_to_kill)
285 : __must_hold(&ctx->uring_lock)
286 : {
287 0 : WARN_ON_ONCE(!ctx->rsrc_backup_node);
288 0 : WARN_ON_ONCE(data_to_kill && !ctx->rsrc_node);
289 :
290 0 : io_rsrc_refs_drop(ctx);
291 :
292 0 : if (data_to_kill) {
293 0 : struct io_rsrc_node *rsrc_node = ctx->rsrc_node;
294 :
295 0 : rsrc_node->rsrc_data = data_to_kill;
296 0 : spin_lock_irq(&ctx->rsrc_ref_lock);
297 0 : list_add_tail(&rsrc_node->node, &ctx->rsrc_ref_list);
298 0 : spin_unlock_irq(&ctx->rsrc_ref_lock);
299 :
300 0 : atomic_inc(&data_to_kill->refs);
301 0 : percpu_ref_kill(&rsrc_node->refs);
302 0 : ctx->rsrc_node = NULL;
303 : }
304 :
305 0 : if (!ctx->rsrc_node) {
306 0 : ctx->rsrc_node = ctx->rsrc_backup_node;
307 0 : ctx->rsrc_backup_node = NULL;
308 : }
309 0 : }
310 :
311 0 : int io_rsrc_node_switch_start(struct io_ring_ctx *ctx)
312 : {
313 0 : if (ctx->rsrc_backup_node)
314 : return 0;
315 0 : ctx->rsrc_backup_node = io_rsrc_node_alloc();
316 0 : return ctx->rsrc_backup_node ? 0 : -ENOMEM;
317 : }
318 :
319 0 : __cold static int io_rsrc_ref_quiesce(struct io_rsrc_data *data,
320 : struct io_ring_ctx *ctx)
321 : {
322 : int ret;
323 :
324 : /* As we may drop ->uring_lock, other task may have started quiesce */
325 0 : if (data->quiesce)
326 : return -ENXIO;
327 0 : ret = io_rsrc_node_switch_start(ctx);
328 0 : if (ret)
329 : return ret;
330 0 : io_rsrc_node_switch(ctx, data);
331 :
332 : /* kill initial ref, already quiesced if zero */
333 0 : if (atomic_dec_and_test(&data->refs))
334 : return 0;
335 :
336 0 : data->quiesce = true;
337 0 : mutex_unlock(&ctx->uring_lock);
338 : do {
339 0 : ret = io_run_task_work_sig(ctx);
340 0 : if (ret < 0) {
341 0 : atomic_inc(&data->refs);
342 : /* wait for all works potentially completing data->done */
343 0 : flush_delayed_work(&ctx->rsrc_put_work);
344 0 : reinit_completion(&data->done);
345 0 : mutex_lock(&ctx->uring_lock);
346 0 : break;
347 : }
348 :
349 0 : flush_delayed_work(&ctx->rsrc_put_work);
350 0 : ret = wait_for_completion_interruptible(&data->done);
351 0 : if (!ret) {
352 0 : mutex_lock(&ctx->uring_lock);
353 0 : if (atomic_read(&data->refs) <= 0)
354 : break;
355 : /*
356 : * it has been revived by another thread while
357 : * we were unlocked
358 : */
359 0 : mutex_unlock(&ctx->uring_lock);
360 : }
361 : } while (1);
362 0 : data->quiesce = false;
363 :
364 0 : return ret;
365 : }
366 :
367 0 : static void io_free_page_table(void **table, size_t size)
368 : {
369 0 : unsigned i, nr_tables = DIV_ROUND_UP(size, PAGE_SIZE);
370 :
371 0 : for (i = 0; i < nr_tables; i++)
372 0 : kfree(table[i]);
373 0 : kfree(table);
374 0 : }
375 :
376 0 : static void io_rsrc_data_free(struct io_rsrc_data *data)
377 : {
378 0 : size_t size = data->nr * sizeof(data->tags[0][0]);
379 :
380 0 : if (data->tags)
381 0 : io_free_page_table((void **)data->tags, size);
382 0 : kfree(data);
383 0 : }
384 :
385 0 : static __cold void **io_alloc_page_table(size_t size)
386 : {
387 0 : unsigned i, nr_tables = DIV_ROUND_UP(size, PAGE_SIZE);
388 0 : size_t init_size = size;
389 : void **table;
390 :
391 0 : table = kcalloc(nr_tables, sizeof(*table), GFP_KERNEL_ACCOUNT);
392 0 : if (!table)
393 : return NULL;
394 :
395 0 : for (i = 0; i < nr_tables; i++) {
396 0 : unsigned int this_size = min_t(size_t, size, PAGE_SIZE);
397 :
398 0 : table[i] = kzalloc(this_size, GFP_KERNEL_ACCOUNT);
399 0 : if (!table[i]) {
400 0 : io_free_page_table(table, init_size);
401 0 : return NULL;
402 : }
403 0 : size -= this_size;
404 : }
405 : return table;
406 : }
407 :
408 0 : __cold static int io_rsrc_data_alloc(struct io_ring_ctx *ctx,
409 : rsrc_put_fn *do_put, u64 __user *utags,
410 : unsigned nr, struct io_rsrc_data **pdata)
411 : {
412 : struct io_rsrc_data *data;
413 0 : int ret = -ENOMEM;
414 : unsigned i;
415 :
416 0 : data = kzalloc(sizeof(*data), GFP_KERNEL);
417 0 : if (!data)
418 : return -ENOMEM;
419 0 : data->tags = (u64 **)io_alloc_page_table(nr * sizeof(data->tags[0][0]));
420 0 : if (!data->tags) {
421 0 : kfree(data);
422 0 : return -ENOMEM;
423 : }
424 :
425 0 : data->nr = nr;
426 0 : data->ctx = ctx;
427 0 : data->do_put = do_put;
428 0 : if (utags) {
429 : ret = -EFAULT;
430 0 : for (i = 0; i < nr; i++) {
431 0 : u64 *tag_slot = io_get_tag_slot(data, i);
432 :
433 0 : if (copy_from_user(tag_slot, &utags[i],
434 : sizeof(*tag_slot)))
435 : goto fail;
436 : }
437 : }
438 :
439 0 : atomic_set(&data->refs, 1);
440 0 : init_completion(&data->done);
441 0 : *pdata = data;
442 0 : return 0;
443 : fail:
444 0 : io_rsrc_data_free(data);
445 0 : return ret;
446 : }
447 :
448 0 : static int __io_sqe_files_update(struct io_ring_ctx *ctx,
449 : struct io_uring_rsrc_update2 *up,
450 : unsigned nr_args)
451 : {
452 0 : u64 __user *tags = u64_to_user_ptr(up->tags);
453 0 : __s32 __user *fds = u64_to_user_ptr(up->data);
454 0 : struct io_rsrc_data *data = ctx->file_data;
455 : struct io_fixed_file *file_slot;
456 : struct file *file;
457 0 : int fd, i, err = 0;
458 : unsigned int done;
459 0 : bool needs_switch = false;
460 :
461 0 : if (!ctx->file_data)
462 : return -ENXIO;
463 0 : if (up->offset + nr_args > ctx->nr_user_files)
464 : return -EINVAL;
465 :
466 0 : for (done = 0; done < nr_args; done++) {
467 0 : u64 tag = 0;
468 :
469 0 : if ((tags && copy_from_user(&tag, &tags[done], sizeof(tag))) ||
470 0 : copy_from_user(&fd, &fds[done], sizeof(fd))) {
471 : err = -EFAULT;
472 0 : break;
473 : }
474 0 : if ((fd == IORING_REGISTER_FILES_SKIP || fd == -1) && tag) {
475 : err = -EINVAL;
476 : break;
477 : }
478 0 : if (fd == IORING_REGISTER_FILES_SKIP)
479 0 : continue;
480 :
481 0 : i = array_index_nospec(up->offset + done, ctx->nr_user_files);
482 0 : file_slot = io_fixed_file_slot(&ctx->file_table, i);
483 :
484 0 : if (file_slot->file_ptr) {
485 0 : file = (struct file *)(file_slot->file_ptr & FFS_MASK);
486 0 : err = io_queue_rsrc_removal(data, i, ctx->rsrc_node, file);
487 0 : if (err)
488 : break;
489 0 : file_slot->file_ptr = 0;
490 0 : io_file_bitmap_clear(&ctx->file_table, i);
491 0 : needs_switch = true;
492 : }
493 0 : if (fd != -1) {
494 0 : file = fget(fd);
495 0 : if (!file) {
496 : err = -EBADF;
497 : break;
498 : }
499 : /*
500 : * Don't allow io_uring instances to be registered. If
501 : * UNIX isn't enabled, then this causes a reference
502 : * cycle and this instance can never get freed. If UNIX
503 : * is enabled we'll handle it just fine, but there's
504 : * still no point in allowing a ring fd as it doesn't
505 : * support regular read/write anyway.
506 : */
507 0 : if (io_is_uring_fops(file)) {
508 0 : fput(file);
509 0 : err = -EBADF;
510 0 : break;
511 : }
512 0 : err = io_scm_file_account(ctx, file);
513 : if (err) {
514 : fput(file);
515 : break;
516 : }
517 0 : *io_get_tag_slot(data, i) = tag;
518 0 : io_fixed_file_set(file_slot, file);
519 0 : io_file_bitmap_set(&ctx->file_table, i);
520 : }
521 : }
522 :
523 0 : if (needs_switch)
524 0 : io_rsrc_node_switch(ctx, data);
525 0 : return done ? done : err;
526 : }
527 :
528 0 : static int __io_sqe_buffers_update(struct io_ring_ctx *ctx,
529 : struct io_uring_rsrc_update2 *up,
530 : unsigned int nr_args)
531 : {
532 0 : u64 __user *tags = u64_to_user_ptr(up->tags);
533 0 : struct iovec iov, __user *iovs = u64_to_user_ptr(up->data);
534 0 : struct page *last_hpage = NULL;
535 0 : bool needs_switch = false;
536 : __u32 done;
537 : int i, err;
538 :
539 0 : if (!ctx->buf_data)
540 : return -ENXIO;
541 0 : if (up->offset + nr_args > ctx->nr_user_bufs)
542 : return -EINVAL;
543 :
544 0 : for (done = 0; done < nr_args; done++) {
545 : struct io_mapped_ubuf *imu;
546 0 : int offset = up->offset + done;
547 0 : u64 tag = 0;
548 :
549 0 : err = io_copy_iov(ctx, &iov, iovs, done);
550 0 : if (err)
551 : break;
552 0 : if (tags && copy_from_user(&tag, &tags[done], sizeof(tag))) {
553 : err = -EFAULT;
554 : break;
555 : }
556 0 : err = io_buffer_validate(&iov);
557 0 : if (err)
558 : break;
559 0 : if (!iov.iov_base && tag) {
560 : err = -EINVAL;
561 : break;
562 : }
563 0 : err = io_sqe_buffer_register(ctx, &iov, &imu, &last_hpage);
564 0 : if (err)
565 : break;
566 :
567 0 : i = array_index_nospec(offset, ctx->nr_user_bufs);
568 0 : if (ctx->user_bufs[i] != ctx->dummy_ubuf) {
569 0 : err = io_queue_rsrc_removal(ctx->buf_data, i,
570 : ctx->rsrc_node, ctx->user_bufs[i]);
571 0 : if (unlikely(err)) {
572 0 : io_buffer_unmap(ctx, &imu);
573 0 : break;
574 : }
575 0 : ctx->user_bufs[i] = ctx->dummy_ubuf;
576 0 : needs_switch = true;
577 : }
578 :
579 0 : ctx->user_bufs[i] = imu;
580 0 : *io_get_tag_slot(ctx->buf_data, offset) = tag;
581 : }
582 :
583 0 : if (needs_switch)
584 0 : io_rsrc_node_switch(ctx, ctx->buf_data);
585 0 : return done ? done : err;
586 : }
587 :
588 0 : static int __io_register_rsrc_update(struct io_ring_ctx *ctx, unsigned type,
589 : struct io_uring_rsrc_update2 *up,
590 : unsigned nr_args)
591 : {
592 : __u32 tmp;
593 : int err;
594 :
595 0 : if (check_add_overflow(up->offset, nr_args, &tmp))
596 : return -EOVERFLOW;
597 0 : err = io_rsrc_node_switch_start(ctx);
598 0 : if (err)
599 : return err;
600 :
601 0 : switch (type) {
602 : case IORING_RSRC_FILE:
603 0 : return __io_sqe_files_update(ctx, up, nr_args);
604 : case IORING_RSRC_BUFFER:
605 0 : return __io_sqe_buffers_update(ctx, up, nr_args);
606 : }
607 : return -EINVAL;
608 : }
609 :
610 0 : int io_register_files_update(struct io_ring_ctx *ctx, void __user *arg,
611 : unsigned nr_args)
612 : {
613 : struct io_uring_rsrc_update2 up;
614 :
615 0 : if (!nr_args)
616 : return -EINVAL;
617 0 : memset(&up, 0, sizeof(up));
618 0 : if (copy_from_user(&up, arg, sizeof(struct io_uring_rsrc_update)))
619 : return -EFAULT;
620 0 : if (up.resv || up.resv2)
621 : return -EINVAL;
622 0 : return __io_register_rsrc_update(ctx, IORING_RSRC_FILE, &up, nr_args);
623 : }
624 :
625 0 : int io_register_rsrc_update(struct io_ring_ctx *ctx, void __user *arg,
626 : unsigned size, unsigned type)
627 : {
628 : struct io_uring_rsrc_update2 up;
629 :
630 0 : if (size != sizeof(up))
631 : return -EINVAL;
632 0 : if (copy_from_user(&up, arg, sizeof(up)))
633 : return -EFAULT;
634 0 : if (!up.nr || up.resv || up.resv2)
635 : return -EINVAL;
636 0 : return __io_register_rsrc_update(ctx, type, &up, up.nr);
637 : }
638 :
639 0 : __cold int io_register_rsrc(struct io_ring_ctx *ctx, void __user *arg,
640 : unsigned int size, unsigned int type)
641 : {
642 : struct io_uring_rsrc_register rr;
643 :
644 : /* keep it extendible */
645 0 : if (size != sizeof(rr))
646 : return -EINVAL;
647 :
648 0 : memset(&rr, 0, sizeof(rr));
649 0 : if (copy_from_user(&rr, arg, size))
650 : return -EFAULT;
651 0 : if (!rr.nr || rr.resv2)
652 : return -EINVAL;
653 0 : if (rr.flags & ~IORING_RSRC_REGISTER_SPARSE)
654 : return -EINVAL;
655 :
656 0 : switch (type) {
657 : case IORING_RSRC_FILE:
658 0 : if (rr.flags & IORING_RSRC_REGISTER_SPARSE && rr.data)
659 : break;
660 0 : return io_sqe_files_register(ctx, u64_to_user_ptr(rr.data),
661 0 : rr.nr, u64_to_user_ptr(rr.tags));
662 : case IORING_RSRC_BUFFER:
663 0 : if (rr.flags & IORING_RSRC_REGISTER_SPARSE && rr.data)
664 : break;
665 0 : return io_sqe_buffers_register(ctx, u64_to_user_ptr(rr.data),
666 0 : rr.nr, u64_to_user_ptr(rr.tags));
667 : }
668 : return -EINVAL;
669 : }
670 :
671 0 : int io_files_update_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
672 : {
673 0 : struct io_rsrc_update *up = io_kiocb_to_cmd(req, struct io_rsrc_update);
674 :
675 0 : if (unlikely(req->flags & (REQ_F_FIXED_FILE | REQ_F_BUFFER_SELECT)))
676 : return -EINVAL;
677 0 : if (sqe->rw_flags || sqe->splice_fd_in)
678 : return -EINVAL;
679 :
680 0 : up->offset = READ_ONCE(sqe->off);
681 0 : up->nr_args = READ_ONCE(sqe->len);
682 0 : if (!up->nr_args)
683 : return -EINVAL;
684 0 : up->arg = READ_ONCE(sqe->addr);
685 0 : return 0;
686 : }
687 :
688 0 : static int io_files_update_with_index_alloc(struct io_kiocb *req,
689 : unsigned int issue_flags)
690 : {
691 0 : struct io_rsrc_update *up = io_kiocb_to_cmd(req, struct io_rsrc_update);
692 0 : __s32 __user *fds = u64_to_user_ptr(up->arg);
693 : unsigned int done;
694 : struct file *file;
695 : int ret, fd;
696 :
697 0 : if (!req->ctx->file_data)
698 : return -ENXIO;
699 :
700 0 : for (done = 0; done < up->nr_args; done++) {
701 0 : if (copy_from_user(&fd, &fds[done], sizeof(fd))) {
702 0 : ret = -EFAULT;
703 0 : break;
704 : }
705 :
706 0 : file = fget(fd);
707 0 : if (!file) {
708 0 : ret = -EBADF;
709 0 : break;
710 : }
711 0 : ret = io_fixed_fd_install(req, issue_flags, file,
712 : IORING_FILE_INDEX_ALLOC);
713 0 : if (ret < 0)
714 : break;
715 0 : if (copy_to_user(&fds[done], &ret, sizeof(ret))) {
716 0 : __io_close_fixed(req->ctx, issue_flags, ret);
717 0 : ret = -EFAULT;
718 0 : break;
719 : }
720 : }
721 :
722 0 : if (done)
723 0 : return done;
724 0 : return ret;
725 : }
726 :
727 0 : int io_files_update(struct io_kiocb *req, unsigned int issue_flags)
728 : {
729 0 : struct io_rsrc_update *up = io_kiocb_to_cmd(req, struct io_rsrc_update);
730 0 : struct io_ring_ctx *ctx = req->ctx;
731 : struct io_uring_rsrc_update2 up2;
732 : int ret;
733 :
734 0 : up2.offset = up->offset;
735 0 : up2.data = up->arg;
736 0 : up2.nr = 0;
737 0 : up2.tags = 0;
738 0 : up2.resv = 0;
739 0 : up2.resv2 = 0;
740 :
741 0 : if (up->offset == IORING_FILE_INDEX_ALLOC) {
742 0 : ret = io_files_update_with_index_alloc(req, issue_flags);
743 : } else {
744 0 : io_ring_submit_lock(ctx, issue_flags);
745 0 : ret = __io_register_rsrc_update(ctx, IORING_RSRC_FILE,
746 : &up2, up->nr_args);
747 : io_ring_submit_unlock(ctx, issue_flags);
748 : }
749 :
750 0 : if (ret < 0)
751 0 : req_set_fail(req);
752 0 : io_req_set_res(req, ret, 0);
753 0 : return IOU_OK;
754 : }
755 :
756 0 : int io_queue_rsrc_removal(struct io_rsrc_data *data, unsigned idx,
757 : struct io_rsrc_node *node, void *rsrc)
758 : {
759 0 : u64 *tag_slot = io_get_tag_slot(data, idx);
760 : struct io_rsrc_put *prsrc;
761 :
762 0 : prsrc = kzalloc(sizeof(*prsrc), GFP_KERNEL);
763 0 : if (!prsrc)
764 : return -ENOMEM;
765 :
766 0 : prsrc->tag = *tag_slot;
767 0 : *tag_slot = 0;
768 0 : prsrc->rsrc = rsrc;
769 0 : list_add(&prsrc->list, &node->rsrc_list);
770 0 : return 0;
771 : }
772 :
773 0 : void __io_sqe_files_unregister(struct io_ring_ctx *ctx)
774 : {
775 : int i;
776 :
777 0 : for (i = 0; i < ctx->nr_user_files; i++) {
778 0 : struct file *file = io_file_from_index(&ctx->file_table, i);
779 :
780 : /* skip scm accounted files, they'll be freed by ->ring_sock */
781 0 : if (!file || io_file_need_scm(file))
782 0 : continue;
783 0 : io_file_bitmap_clear(&ctx->file_table, i);
784 0 : fput(file);
785 : }
786 :
787 : #if defined(CONFIG_UNIX)
788 : if (ctx->ring_sock) {
789 : struct sock *sock = ctx->ring_sock->sk;
790 : struct sk_buff *skb;
791 :
792 : while ((skb = skb_dequeue(&sock->sk_receive_queue)) != NULL)
793 : kfree_skb(skb);
794 : }
795 : #endif
796 0 : io_free_file_tables(&ctx->file_table);
797 0 : io_rsrc_data_free(ctx->file_data);
798 0 : ctx->file_data = NULL;
799 0 : ctx->nr_user_files = 0;
800 0 : }
801 :
802 0 : int io_sqe_files_unregister(struct io_ring_ctx *ctx)
803 : {
804 0 : unsigned nr = ctx->nr_user_files;
805 : int ret;
806 :
807 0 : if (!ctx->file_data)
808 : return -ENXIO;
809 :
810 : /*
811 : * Quiesce may unlock ->uring_lock, and while it's not held
812 : * prevent new requests using the table.
813 : */
814 0 : ctx->nr_user_files = 0;
815 0 : ret = io_rsrc_ref_quiesce(ctx->file_data, ctx);
816 0 : ctx->nr_user_files = nr;
817 0 : if (!ret)
818 0 : __io_sqe_files_unregister(ctx);
819 : return ret;
820 : }
821 :
822 : /*
823 : * Ensure the UNIX gc is aware of our file set, so we are certain that
824 : * the io_uring can be safely unregistered on process exit, even if we have
825 : * loops in the file referencing. We account only files that can hold other
826 : * files because otherwise they can't form a loop and so are not interesting
827 : * for GC.
828 : */
829 0 : int __io_scm_file_account(struct io_ring_ctx *ctx, struct file *file)
830 : {
831 : #if defined(CONFIG_UNIX)
832 : struct sock *sk = ctx->ring_sock->sk;
833 : struct sk_buff_head *head = &sk->sk_receive_queue;
834 : struct scm_fp_list *fpl;
835 : struct sk_buff *skb;
836 :
837 : if (likely(!io_file_need_scm(file)))
838 : return 0;
839 :
840 : /*
841 : * See if we can merge this file into an existing skb SCM_RIGHTS
842 : * file set. If there's no room, fall back to allocating a new skb
843 : * and filling it in.
844 : */
845 : spin_lock_irq(&head->lock);
846 : skb = skb_peek(head);
847 : if (skb && UNIXCB(skb).fp->count < SCM_MAX_FD)
848 : __skb_unlink(skb, head);
849 : else
850 : skb = NULL;
851 : spin_unlock_irq(&head->lock);
852 :
853 : if (!skb) {
854 : fpl = kzalloc(sizeof(*fpl), GFP_KERNEL);
855 : if (!fpl)
856 : return -ENOMEM;
857 :
858 : skb = alloc_skb(0, GFP_KERNEL);
859 : if (!skb) {
860 : kfree(fpl);
861 : return -ENOMEM;
862 : }
863 :
864 : fpl->user = get_uid(current_user());
865 : fpl->max = SCM_MAX_FD;
866 : fpl->count = 0;
867 :
868 : UNIXCB(skb).fp = fpl;
869 : skb->sk = sk;
870 : skb->scm_io_uring = 1;
871 : skb->destructor = unix_destruct_scm;
872 : refcount_add(skb->truesize, &sk->sk_wmem_alloc);
873 : }
874 :
875 : fpl = UNIXCB(skb).fp;
876 : fpl->fp[fpl->count++] = get_file(file);
877 : unix_inflight(fpl->user, file);
878 : skb_queue_head(head, skb);
879 : fput(file);
880 : #endif
881 0 : return 0;
882 : }
883 :
884 0 : static void io_rsrc_file_put(struct io_ring_ctx *ctx, struct io_rsrc_put *prsrc)
885 : {
886 0 : struct file *file = prsrc->file;
887 : #if defined(CONFIG_UNIX)
888 : struct sock *sock = ctx->ring_sock->sk;
889 : struct sk_buff_head list, *head = &sock->sk_receive_queue;
890 : struct sk_buff *skb;
891 : int i;
892 :
893 : if (!io_file_need_scm(file)) {
894 : fput(file);
895 : return;
896 : }
897 :
898 : __skb_queue_head_init(&list);
899 :
900 : /*
901 : * Find the skb that holds this file in its SCM_RIGHTS. When found,
902 : * remove this entry and rearrange the file array.
903 : */
904 : skb = skb_dequeue(head);
905 : while (skb) {
906 : struct scm_fp_list *fp;
907 :
908 : fp = UNIXCB(skb).fp;
909 : for (i = 0; i < fp->count; i++) {
910 : int left;
911 :
912 : if (fp->fp[i] != file)
913 : continue;
914 :
915 : unix_notinflight(fp->user, fp->fp[i]);
916 : left = fp->count - 1 - i;
917 : if (left) {
918 : memmove(&fp->fp[i], &fp->fp[i + 1],
919 : left * sizeof(struct file *));
920 : }
921 : fp->count--;
922 : if (!fp->count) {
923 : kfree_skb(skb);
924 : skb = NULL;
925 : } else {
926 : __skb_queue_tail(&list, skb);
927 : }
928 : fput(file);
929 : file = NULL;
930 : break;
931 : }
932 :
933 : if (!file)
934 : break;
935 :
936 : __skb_queue_tail(&list, skb);
937 :
938 : skb = skb_dequeue(head);
939 : }
940 :
941 : if (skb_peek(&list)) {
942 : spin_lock_irq(&head->lock);
943 : while ((skb = __skb_dequeue(&list)) != NULL)
944 : __skb_queue_tail(head, skb);
945 : spin_unlock_irq(&head->lock);
946 : }
947 : #else
948 0 : fput(file);
949 : #endif
950 0 : }
951 :
952 0 : int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
953 : unsigned nr_args, u64 __user *tags)
954 : {
955 0 : __s32 __user *fds = (__s32 __user *) arg;
956 : struct file *file;
957 : int fd, ret;
958 : unsigned i;
959 :
960 0 : if (ctx->file_data)
961 : return -EBUSY;
962 0 : if (!nr_args)
963 : return -EINVAL;
964 0 : if (nr_args > IORING_MAX_FIXED_FILES)
965 : return -EMFILE;
966 0 : if (nr_args > rlimit(RLIMIT_NOFILE))
967 : return -EMFILE;
968 0 : ret = io_rsrc_node_switch_start(ctx);
969 0 : if (ret)
970 : return ret;
971 0 : ret = io_rsrc_data_alloc(ctx, io_rsrc_file_put, tags, nr_args,
972 : &ctx->file_data);
973 0 : if (ret)
974 : return ret;
975 :
976 0 : if (!io_alloc_file_tables(&ctx->file_table, nr_args)) {
977 0 : io_rsrc_data_free(ctx->file_data);
978 0 : ctx->file_data = NULL;
979 0 : return -ENOMEM;
980 : }
981 :
982 0 : for (i = 0; i < nr_args; i++, ctx->nr_user_files++) {
983 : struct io_fixed_file *file_slot;
984 :
985 0 : if (fds && copy_from_user(&fd, &fds[i], sizeof(fd))) {
986 : ret = -EFAULT;
987 : goto fail;
988 : }
989 : /* allow sparse sets */
990 0 : if (!fds || fd == -1) {
991 0 : ret = -EINVAL;
992 0 : if (unlikely(*io_get_tag_slot(ctx->file_data, i)))
993 : goto fail;
994 0 : continue;
995 : }
996 :
997 0 : file = fget(fd);
998 0 : ret = -EBADF;
999 0 : if (unlikely(!file))
1000 : goto fail;
1001 :
1002 : /*
1003 : * Don't allow io_uring instances to be registered. If UNIX
1004 : * isn't enabled, then this causes a reference cycle and this
1005 : * instance can never get freed. If UNIX is enabled we'll
1006 : * handle it just fine, but there's still no point in allowing
1007 : * a ring fd as it doesn't support regular read/write anyway.
1008 : */
1009 0 : if (io_is_uring_fops(file)) {
1010 0 : fput(file);
1011 0 : goto fail;
1012 : }
1013 0 : ret = io_scm_file_account(ctx, file);
1014 : if (ret) {
1015 : fput(file);
1016 : goto fail;
1017 : }
1018 0 : file_slot = io_fixed_file_slot(&ctx->file_table, i);
1019 0 : io_fixed_file_set(file_slot, file);
1020 0 : io_file_bitmap_set(&ctx->file_table, i);
1021 : }
1022 :
1023 : /* default it to the whole table */
1024 0 : io_file_table_set_alloc_range(ctx, 0, ctx->nr_user_files);
1025 0 : io_rsrc_node_switch(ctx, NULL);
1026 0 : return 0;
1027 : fail:
1028 0 : __io_sqe_files_unregister(ctx);
1029 0 : return ret;
1030 : }
1031 :
1032 0 : static void io_rsrc_buf_put(struct io_ring_ctx *ctx, struct io_rsrc_put *prsrc)
1033 : {
1034 0 : io_buffer_unmap(ctx, &prsrc->buf);
1035 0 : prsrc->buf = NULL;
1036 0 : }
1037 :
1038 0 : void __io_sqe_buffers_unregister(struct io_ring_ctx *ctx)
1039 : {
1040 : unsigned int i;
1041 :
1042 0 : for (i = 0; i < ctx->nr_user_bufs; i++)
1043 0 : io_buffer_unmap(ctx, &ctx->user_bufs[i]);
1044 0 : kfree(ctx->user_bufs);
1045 0 : io_rsrc_data_free(ctx->buf_data);
1046 0 : ctx->user_bufs = NULL;
1047 0 : ctx->buf_data = NULL;
1048 0 : ctx->nr_user_bufs = 0;
1049 0 : }
1050 :
1051 0 : int io_sqe_buffers_unregister(struct io_ring_ctx *ctx)
1052 : {
1053 0 : unsigned nr = ctx->nr_user_bufs;
1054 : int ret;
1055 :
1056 0 : if (!ctx->buf_data)
1057 : return -ENXIO;
1058 :
1059 : /*
1060 : * Quiesce may unlock ->uring_lock, and while it's not held
1061 : * prevent new requests using the table.
1062 : */
1063 0 : ctx->nr_user_bufs = 0;
1064 0 : ret = io_rsrc_ref_quiesce(ctx->buf_data, ctx);
1065 0 : ctx->nr_user_bufs = nr;
1066 0 : if (!ret)
1067 0 : __io_sqe_buffers_unregister(ctx);
1068 : return ret;
1069 : }
1070 :
1071 : /*
1072 : * Not super efficient, but this is just a registration time. And we do cache
1073 : * the last compound head, so generally we'll only do a full search if we don't
1074 : * match that one.
1075 : *
1076 : * We check if the given compound head page has already been accounted, to
1077 : * avoid double accounting it. This allows us to account the full size of the
1078 : * page, not just the constituent pages of a huge page.
1079 : */
1080 0 : static bool headpage_already_acct(struct io_ring_ctx *ctx, struct page **pages,
1081 : int nr_pages, struct page *hpage)
1082 : {
1083 : int i, j;
1084 :
1085 : /* check current page array */
1086 0 : for (i = 0; i < nr_pages; i++) {
1087 0 : if (!PageCompound(pages[i]))
1088 0 : continue;
1089 0 : if (compound_head(pages[i]) == hpage)
1090 : return true;
1091 : }
1092 :
1093 : /* check previously registered pages */
1094 0 : for (i = 0; i < ctx->nr_user_bufs; i++) {
1095 0 : struct io_mapped_ubuf *imu = ctx->user_bufs[i];
1096 :
1097 0 : for (j = 0; j < imu->nr_bvecs; j++) {
1098 0 : if (!PageCompound(imu->bvec[j].bv_page))
1099 0 : continue;
1100 0 : if (compound_head(imu->bvec[j].bv_page) == hpage)
1101 : return true;
1102 : }
1103 : }
1104 :
1105 : return false;
1106 : }
1107 :
1108 0 : static int io_buffer_account_pin(struct io_ring_ctx *ctx, struct page **pages,
1109 : int nr_pages, struct io_mapped_ubuf *imu,
1110 : struct page **last_hpage)
1111 : {
1112 : int i, ret;
1113 :
1114 0 : imu->acct_pages = 0;
1115 0 : for (i = 0; i < nr_pages; i++) {
1116 0 : if (!PageCompound(pages[i])) {
1117 0 : imu->acct_pages++;
1118 : } else {
1119 : struct page *hpage;
1120 :
1121 0 : hpage = compound_head(pages[i]);
1122 0 : if (hpage == *last_hpage)
1123 0 : continue;
1124 0 : *last_hpage = hpage;
1125 0 : if (headpage_already_acct(ctx, pages, i, hpage))
1126 0 : continue;
1127 0 : imu->acct_pages += page_size(hpage) >> PAGE_SHIFT;
1128 : }
1129 : }
1130 :
1131 0 : if (!imu->acct_pages)
1132 : return 0;
1133 :
1134 0 : ret = io_account_mem(ctx, imu->acct_pages);
1135 0 : if (ret)
1136 0 : imu->acct_pages = 0;
1137 : return ret;
1138 : }
1139 :
1140 0 : struct page **io_pin_pages(unsigned long ubuf, unsigned long len, int *npages)
1141 : {
1142 : unsigned long start, end, nr_pages;
1143 0 : struct vm_area_struct **vmas = NULL;
1144 0 : struct page **pages = NULL;
1145 0 : int i, pret, ret = -ENOMEM;
1146 :
1147 0 : end = (ubuf + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1148 0 : start = ubuf >> PAGE_SHIFT;
1149 0 : nr_pages = end - start;
1150 :
1151 0 : pages = kvmalloc_array(nr_pages, sizeof(struct page *), GFP_KERNEL);
1152 0 : if (!pages)
1153 : goto done;
1154 :
1155 0 : vmas = kvmalloc_array(nr_pages, sizeof(struct vm_area_struct *),
1156 : GFP_KERNEL);
1157 0 : if (!vmas)
1158 : goto done;
1159 :
1160 0 : ret = 0;
1161 0 : mmap_read_lock(current->mm);
1162 0 : pret = pin_user_pages(ubuf, nr_pages, FOLL_WRITE | FOLL_LONGTERM,
1163 : pages, vmas);
1164 0 : if (pret == nr_pages) {
1165 0 : struct file *file = vmas[0]->vm_file;
1166 :
1167 : /* don't support file backed memory */
1168 0 : for (i = 0; i < nr_pages; i++) {
1169 0 : if (vmas[i]->vm_file != file) {
1170 : ret = -EINVAL;
1171 : break;
1172 : }
1173 0 : if (!file)
1174 0 : continue;
1175 0 : if (!vma_is_shmem(vmas[i]) && !is_file_hugepages(file)) {
1176 : ret = -EOPNOTSUPP;
1177 : break;
1178 : }
1179 : }
1180 0 : *npages = nr_pages;
1181 : } else {
1182 0 : ret = pret < 0 ? pret : -EFAULT;
1183 : }
1184 0 : mmap_read_unlock(current->mm);
1185 0 : if (ret) {
1186 : /*
1187 : * if we did partial map, or found file backed vmas,
1188 : * release any pages we did get
1189 : */
1190 0 : if (pret > 0)
1191 0 : unpin_user_pages(pages, pret);
1192 : goto done;
1193 : }
1194 : ret = 0;
1195 : done:
1196 0 : kvfree(vmas);
1197 0 : if (ret < 0) {
1198 0 : kvfree(pages);
1199 0 : pages = ERR_PTR(ret);
1200 : }
1201 0 : return pages;
1202 : }
1203 :
1204 0 : static int io_sqe_buffer_register(struct io_ring_ctx *ctx, struct iovec *iov,
1205 : struct io_mapped_ubuf **pimu,
1206 : struct page **last_hpage)
1207 : {
1208 0 : struct io_mapped_ubuf *imu = NULL;
1209 0 : struct page **pages = NULL;
1210 : unsigned long off;
1211 : size_t size;
1212 : int ret, nr_pages, i;
1213 0 : struct folio *folio = NULL;
1214 :
1215 0 : *pimu = ctx->dummy_ubuf;
1216 0 : if (!iov->iov_base)
1217 : return 0;
1218 :
1219 0 : ret = -ENOMEM;
1220 0 : pages = io_pin_pages((unsigned long) iov->iov_base, iov->iov_len,
1221 : &nr_pages);
1222 0 : if (IS_ERR(pages)) {
1223 0 : ret = PTR_ERR(pages);
1224 0 : pages = NULL;
1225 0 : goto done;
1226 : }
1227 :
1228 : /* If it's a huge page, try to coalesce them into a single bvec entry */
1229 0 : if (nr_pages > 1) {
1230 0 : folio = page_folio(pages[0]);
1231 0 : for (i = 1; i < nr_pages; i++) {
1232 0 : if (page_folio(pages[i]) != folio) {
1233 : folio = NULL;
1234 : break;
1235 : }
1236 : }
1237 0 : if (folio) {
1238 0 : folio_put_refs(folio, nr_pages - 1);
1239 0 : nr_pages = 1;
1240 : }
1241 : }
1242 :
1243 0 : imu = kvmalloc(struct_size(imu, bvec, nr_pages), GFP_KERNEL);
1244 0 : if (!imu)
1245 : goto done;
1246 :
1247 0 : ret = io_buffer_account_pin(ctx, pages, nr_pages, imu, last_hpage);
1248 0 : if (ret) {
1249 0 : unpin_user_pages(pages, nr_pages);
1250 0 : goto done;
1251 : }
1252 :
1253 0 : off = (unsigned long) iov->iov_base & ~PAGE_MASK;
1254 0 : size = iov->iov_len;
1255 : /* store original address for later verification */
1256 0 : imu->ubuf = (unsigned long) iov->iov_base;
1257 0 : imu->ubuf_end = imu->ubuf + iov->iov_len;
1258 0 : imu->nr_bvecs = nr_pages;
1259 0 : *pimu = imu;
1260 0 : ret = 0;
1261 :
1262 0 : if (folio) {
1263 0 : bvec_set_page(&imu->bvec[0], pages[0], size, off);
1264 : goto done;
1265 : }
1266 0 : for (i = 0; i < nr_pages; i++) {
1267 : size_t vec_len;
1268 :
1269 0 : vec_len = min_t(size_t, size, PAGE_SIZE - off);
1270 0 : bvec_set_page(&imu->bvec[i], pages[i], vec_len, off);
1271 0 : off = 0;
1272 0 : size -= vec_len;
1273 : }
1274 : done:
1275 0 : if (ret)
1276 0 : kvfree(imu);
1277 0 : kvfree(pages);
1278 0 : return ret;
1279 : }
1280 :
1281 : static int io_buffers_map_alloc(struct io_ring_ctx *ctx, unsigned int nr_args)
1282 : {
1283 0 : ctx->user_bufs = kcalloc(nr_args, sizeof(*ctx->user_bufs), GFP_KERNEL);
1284 0 : return ctx->user_bufs ? 0 : -ENOMEM;
1285 : }
1286 :
1287 0 : int io_sqe_buffers_register(struct io_ring_ctx *ctx, void __user *arg,
1288 : unsigned int nr_args, u64 __user *tags)
1289 : {
1290 0 : struct page *last_hpage = NULL;
1291 : struct io_rsrc_data *data;
1292 : int i, ret;
1293 : struct iovec iov;
1294 :
1295 : BUILD_BUG_ON(IORING_MAX_REG_BUFFERS >= (1u << 16));
1296 :
1297 0 : if (ctx->user_bufs)
1298 : return -EBUSY;
1299 0 : if (!nr_args || nr_args > IORING_MAX_REG_BUFFERS)
1300 : return -EINVAL;
1301 0 : ret = io_rsrc_node_switch_start(ctx);
1302 0 : if (ret)
1303 : return ret;
1304 0 : ret = io_rsrc_data_alloc(ctx, io_rsrc_buf_put, tags, nr_args, &data);
1305 0 : if (ret)
1306 : return ret;
1307 0 : ret = io_buffers_map_alloc(ctx, nr_args);
1308 0 : if (ret) {
1309 0 : io_rsrc_data_free(data);
1310 0 : return ret;
1311 : }
1312 :
1313 0 : for (i = 0; i < nr_args; i++, ctx->nr_user_bufs++) {
1314 0 : if (arg) {
1315 0 : ret = io_copy_iov(ctx, &iov, arg, i);
1316 0 : if (ret)
1317 : break;
1318 0 : ret = io_buffer_validate(&iov);
1319 0 : if (ret)
1320 : break;
1321 : } else {
1322 0 : memset(&iov, 0, sizeof(iov));
1323 : }
1324 :
1325 0 : if (!iov.iov_base && *io_get_tag_slot(data, i)) {
1326 : ret = -EINVAL;
1327 : break;
1328 : }
1329 :
1330 0 : ret = io_sqe_buffer_register(ctx, &iov, &ctx->user_bufs[i],
1331 : &last_hpage);
1332 0 : if (ret)
1333 : break;
1334 : }
1335 :
1336 0 : WARN_ON_ONCE(ctx->buf_data);
1337 :
1338 0 : ctx->buf_data = data;
1339 0 : if (ret)
1340 0 : __io_sqe_buffers_unregister(ctx);
1341 : else
1342 0 : io_rsrc_node_switch(ctx, NULL);
1343 : return ret;
1344 : }
1345 :
1346 0 : int io_import_fixed(int ddir, struct iov_iter *iter,
1347 : struct io_mapped_ubuf *imu,
1348 : u64 buf_addr, size_t len)
1349 : {
1350 : u64 buf_end;
1351 : size_t offset;
1352 :
1353 0 : if (WARN_ON_ONCE(!imu))
1354 : return -EFAULT;
1355 0 : if (unlikely(check_add_overflow(buf_addr, (u64)len, &buf_end)))
1356 : return -EFAULT;
1357 : /* not inside the mapped region */
1358 0 : if (unlikely(buf_addr < imu->ubuf || buf_end > imu->ubuf_end))
1359 : return -EFAULT;
1360 :
1361 : /*
1362 : * Might not be a start of buffer, set size appropriately
1363 : * and advance us to the beginning.
1364 : */
1365 0 : offset = buf_addr - imu->ubuf;
1366 0 : iov_iter_bvec(iter, ddir, imu->bvec, imu->nr_bvecs, offset + len);
1367 :
1368 0 : if (offset) {
1369 : /*
1370 : * Don't use iov_iter_advance() here, as it's really slow for
1371 : * using the latter parts of a big fixed buffer - it iterates
1372 : * over each segment manually. We can cheat a bit here, because
1373 : * we know that:
1374 : *
1375 : * 1) it's a BVEC iter, we set it up
1376 : * 2) all bvecs are PAGE_SIZE in size, except potentially the
1377 : * first and last bvec
1378 : *
1379 : * So just find our index, and adjust the iterator afterwards.
1380 : * If the offset is within the first bvec (or the whole first
1381 : * bvec, just use iov_iter_advance(). This makes it easier
1382 : * since we can just skip the first segment, which may not
1383 : * be PAGE_SIZE aligned.
1384 : */
1385 0 : const struct bio_vec *bvec = imu->bvec;
1386 :
1387 0 : if (offset <= bvec->bv_len) {
1388 : /*
1389 : * Note, huge pages buffers consists of one large
1390 : * bvec entry and should always go this way. The other
1391 : * branch doesn't expect non PAGE_SIZE'd chunks.
1392 : */
1393 0 : iter->bvec = bvec;
1394 0 : iter->nr_segs = bvec->bv_len;
1395 0 : iter->count -= offset;
1396 0 : iter->iov_offset = offset;
1397 : } else {
1398 : unsigned long seg_skip;
1399 :
1400 : /* skip first vec */
1401 0 : offset -= bvec->bv_len;
1402 0 : seg_skip = 1 + (offset >> PAGE_SHIFT);
1403 :
1404 0 : iter->bvec = bvec + seg_skip;
1405 0 : iter->nr_segs -= seg_skip;
1406 0 : iter->count -= bvec->bv_len + offset;
1407 0 : iter->iov_offset = offset & ~PAGE_MASK;
1408 : }
1409 : }
1410 :
1411 : return 0;
1412 : }
|
