mirror of
https://github.com/torvalds/linux.git
synced 2026-11-20 13:03:48 +00:00
One problem that was brought up is that the file table size is often a limiting factor when working with dma-bufs, which is quite an old problem. With a single io_uring people can work it around by closing the dma-buf fd after registration, but for more complex cases we need a way to dynamically register it into another ring. We also need to deduplicate internal registrations as each creates a new attachment and related structures, which could involve large allocations and iommu mappings. Solve it by enabling io_uring buffer cloning. I made dma-bufs registered for io_uring not cloneable between rings because the implementation could modify parts of struct io_buf_dma without any locking and sharing it would've created races. That was an optimisation that got dropped at some point for simplicity, so we can safely enable cloning back as long as IORING_SETUP_IOPOLL rejection is honoured. Kill the uncloneable flag as unused as well. Reported-by: William Power <[email protected]> Reported-by: Tushar Gohad <[email protected]> Signed-off-by: Pavel Begunkov <[email protected]> Link: https://patch.msgid.link/b76cf21ee0e2362489c864e43781b20d95fd75f7.1792142588.git.asml.silence@gmail.com Signed-off-by: Jens Axboe <[email protected]>
178 lines
5.0 KiB
C
178 lines
5.0 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#ifndef IOU_RSRC_H
|
|
#define IOU_RSRC_H
|
|
|
|
#include <linux/bvec.h>
|
|
#include <linux/io_uring_types.h>
|
|
#include <linux/lockdep.h>
|
|
#include <linux/uio.h>
|
|
|
|
#define IO_VEC_CACHE_SOFT_CAP 256
|
|
|
|
enum {
|
|
IORING_RSRC_FILE = 0,
|
|
IORING_RSRC_BUFFER = 1,
|
|
};
|
|
|
|
struct io_rsrc_node {
|
|
unsigned char type;
|
|
int refs;
|
|
|
|
u64 tag;
|
|
union {
|
|
unsigned long file_ptr;
|
|
struct io_mapped_ubuf *buf;
|
|
};
|
|
};
|
|
|
|
enum {
|
|
IO_REGBUF_F_KBUF = 1 << 0,
|
|
IO_REGBUF_F_DMABUF = 1 << 1,
|
|
};
|
|
|
|
enum {
|
|
IO_REGBUF_IMPORT_ALLOW_DMABUF = 1 << 1,
|
|
};
|
|
|
|
struct io_mapped_ubuf {
|
|
u64 ubuf;
|
|
size_t len;
|
|
unsigned int nr_bvecs;
|
|
unsigned int folio_shift;
|
|
refcount_t refs;
|
|
u8 flags;
|
|
u8 dir;
|
|
void (*release)(void *);
|
|
void *priv;
|
|
struct bio_vec bvec[] __counted_by(nr_bvecs);
|
|
};
|
|
|
|
struct io_imu_folio_data {
|
|
/* Head folio can be partially included in the fixed buf */
|
|
unsigned int nr_pages_head;
|
|
/* For non-head/tail folios, has to be fully included */
|
|
unsigned int nr_pages_mid;
|
|
unsigned int folio_shift;
|
|
unsigned int nr_folios;
|
|
unsigned long first_folio_page_idx;
|
|
};
|
|
|
|
bool io_rsrc_cache_init(struct io_ring_ctx *ctx);
|
|
void io_rsrc_cache_free(struct io_ring_ctx *ctx);
|
|
struct io_rsrc_node *io_rsrc_node_alloc(struct io_ring_ctx *ctx, int type);
|
|
void io_free_rsrc_node(struct io_ring_ctx *ctx, struct io_rsrc_node *node);
|
|
void io_rsrc_data_free(struct io_ring_ctx *ctx, struct io_rsrc_data *data);
|
|
int io_rsrc_data_alloc(struct io_rsrc_data *data, unsigned nr);
|
|
|
|
struct io_rsrc_node *io_find_buf_node(struct io_kiocb *req,
|
|
unsigned issue_flags);
|
|
int __io_import_reg_buf(struct io_kiocb *req, struct iov_iter *iter,
|
|
u64 buf_addr, size_t len, int ddir,
|
|
unsigned issue_flags, unsigned import_flags);
|
|
int __io_import_reg_vec(int ddir, struct iov_iter *iter,
|
|
struct io_kiocb *req, struct iou_vec *vec,
|
|
unsigned nr_iovs, unsigned issue_flags,
|
|
unsigned import_flags);
|
|
|
|
static inline int io_import_reg_buf(struct io_kiocb *req, struct iov_iter *iter,
|
|
u64 buf_addr, size_t len, int ddir,
|
|
unsigned issue_flags)
|
|
{
|
|
return __io_import_reg_buf(req, iter, buf_addr, len, ddir, issue_flags, 0);
|
|
}
|
|
|
|
static inline int io_import_reg_vec(int ddir, struct iov_iter *iter,
|
|
struct io_kiocb *req, struct iou_vec *vec,
|
|
unsigned nr_iovs, unsigned issue_flags)
|
|
{
|
|
return __io_import_reg_vec(ddir, iter, req, vec, nr_iovs, issue_flags, 0);
|
|
}
|
|
|
|
int io_prep_reg_iovec(struct io_kiocb *req, struct iou_vec *iv,
|
|
const struct iovec __user *uvec, size_t uvec_segs);
|
|
|
|
int io_register_clone_buffers(struct io_ring_ctx *ctx, void __user *arg);
|
|
int io_sqe_buffers_unregister(struct io_ring_ctx *ctx);
|
|
int io_sqe_buffers_register(struct io_ring_ctx *ctx, void __user *arg,
|
|
unsigned int nr_args, u64 __user *tags);
|
|
int io_sqe_files_unregister(struct io_ring_ctx *ctx);
|
|
int io_sqe_files_register(struct io_ring_ctx *ctx, void __user *arg,
|
|
unsigned nr_args, u64 __user *tags);
|
|
|
|
int io_register_files_update(struct io_ring_ctx *ctx, void __user *arg,
|
|
unsigned nr_args);
|
|
int io_register_rsrc_update(struct io_ring_ctx *ctx, void __user *arg,
|
|
unsigned size, unsigned type);
|
|
int io_register_rsrc(struct io_ring_ctx *ctx, void __user *arg,
|
|
unsigned int size, unsigned int type);
|
|
int io_validate_user_buf_range(u64 uaddr, u64 ulen);
|
|
|
|
bool io_check_coalesce_buffer(struct page **page_array, int nr_pages,
|
|
struct io_imu_folio_data *data);
|
|
|
|
static inline struct io_rsrc_node *io_rsrc_node_lookup(struct io_rsrc_data *data,
|
|
unsigned int index)
|
|
{
|
|
if (index < data->nr)
|
|
return data->nodes[array_index_nospec(index, data->nr)];
|
|
return NULL;
|
|
}
|
|
|
|
static inline void io_put_rsrc_node(struct io_ring_ctx *ctx, struct io_rsrc_node *node)
|
|
{
|
|
lockdep_assert_held(&ctx->uring_lock);
|
|
if (!--node->refs)
|
|
io_free_rsrc_node(ctx, node);
|
|
}
|
|
|
|
static inline bool io_reset_rsrc_node(struct io_ring_ctx *ctx,
|
|
struct io_rsrc_data *data,
|
|
unsigned int index)
|
|
{
|
|
struct io_rsrc_node *node;
|
|
|
|
if (index >= data->nr)
|
|
return false;
|
|
index = array_index_nospec(index, data->nr);
|
|
node = data->nodes[index];
|
|
if (!node)
|
|
return false;
|
|
io_put_rsrc_node(ctx, node);
|
|
data->nodes[index] = NULL;
|
|
return true;
|
|
}
|
|
|
|
int io_files_update(struct io_kiocb *req, unsigned int issue_flags);
|
|
int io_files_update_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe);
|
|
|
|
int __io_account_mem(struct user_struct *user, unsigned long nr_pages);
|
|
int io_account_mem(struct user_struct *user, struct mm_struct *mm_account,
|
|
unsigned long nr_pages);
|
|
void io_unaccount_mem(struct user_struct *user, struct mm_struct *mm_account,
|
|
unsigned long nr_pages);
|
|
|
|
static inline void __io_unaccount_mem(struct user_struct *user,
|
|
unsigned long nr_pages)
|
|
{
|
|
atomic_long_sub(nr_pages, &user->locked_vm);
|
|
}
|
|
|
|
void io_vec_free(struct iou_vec *iv);
|
|
int io_vec_realloc(struct iou_vec *iv, unsigned nr_entries);
|
|
|
|
static inline void io_vec_reset_iovec(struct iou_vec *iv,
|
|
struct iovec *iovec, unsigned nr)
|
|
{
|
|
io_vec_free(iv);
|
|
iv->iovec = iovec;
|
|
iv->nr = nr;
|
|
}
|
|
|
|
static inline void io_alloc_cache_vec_kasan(struct iou_vec *iv)
|
|
{
|
|
if (IS_ENABLED(CONFIG_KASAN))
|
|
io_vec_free(iv);
|
|
}
|
|
|
|
#endif
|