mirror of
https://github.com/torvalds/linux
synced 2024-07-21 10:41:44 +00:00
eb42cebb2c
Add internal part of send zerocopy notifications. There are two main structures, the first one is struct io_notif, which carries inside struct ubuf_info and maps 1:1 to it. io_uring will be binding a number of zerocopy send requests to it and ask to complete (aka flush) it. When flushed and all attached requests and skbs complete, it'll generate one and only one CQE. There are intended to be passed into the network layer as struct msghdr::msg_ubuf. The second concept is notification slots. The userspace will be able to register an array of slots and subsequently addressing them by the index in the array. Slots are independent of each other. Each slot can have only one notifier at a time (called active notifier) but many notifiers during the lifetime. When active, a notifier not going to post any completion but the userspace can attach requests to it by specifying the corresponding slot while issueing send zc requests. Eventually, the userspace will want to "flush" the notifier losing any way to attach new requests to it, however it can use the next atomatically added notifier of this slot or of any other slot. When the network layer is done with all enqueued skbs attached to a notifier and doesn't need the specified in them user data, the flushed notifier will post a CQE. Signed-off-by: Pavel Begunkov <asml.silence@gmail.com> Link: https://lore.kernel.org/r/3ecf54c31a85762bf679b0a432c9f43ecf7e61cc.1657643355.git.asml.silence@gmail.com Signed-off-by: Jens Axboe <axboe@kernel.dk>
65 lines
1.5 KiB
C
65 lines
1.5 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#include <linux/net.h>
|
|
#include <linux/uio.h>
|
|
#include <net/sock.h>
|
|
#include <linux/nospec.h>
|
|
|
|
struct io_notif {
|
|
struct ubuf_info uarg;
|
|
struct io_ring_ctx *ctx;
|
|
|
|
/* cqe->user_data, io_notif_slot::tag if not overridden */
|
|
u64 tag;
|
|
/* see struct io_notif_slot::seq */
|
|
u32 seq;
|
|
|
|
union {
|
|
struct callback_head task_work;
|
|
struct work_struct commit_work;
|
|
};
|
|
};
|
|
|
|
struct io_notif_slot {
|
|
/*
|
|
* Current/active notifier. A slot holds only one active notifier at a
|
|
* time and keeps one reference to it. Flush releases the reference and
|
|
* lazily replaces it with a new notifier.
|
|
*/
|
|
struct io_notif *notif;
|
|
|
|
/*
|
|
* Default ->user_data for this slot notifiers CQEs
|
|
*/
|
|
u64 tag;
|
|
/*
|
|
* Notifiers of a slot live in generations, we create a new notifier
|
|
* only after flushing the previous one. Track the sequential number
|
|
* for all notifiers and copy it into notifiers's cqe->cflags
|
|
*/
|
|
u32 seq;
|
|
};
|
|
|
|
int io_notif_unregister(struct io_ring_ctx *ctx);
|
|
|
|
struct io_notif *io_alloc_notif(struct io_ring_ctx *ctx,
|
|
struct io_notif_slot *slot);
|
|
|
|
static inline struct io_notif *io_get_notif(struct io_ring_ctx *ctx,
|
|
struct io_notif_slot *slot)
|
|
{
|
|
if (!slot->notif)
|
|
slot->notif = io_alloc_notif(ctx, slot);
|
|
return slot->notif;
|
|
}
|
|
|
|
static inline struct io_notif_slot *io_get_notif_slot(struct io_ring_ctx *ctx,
|
|
int idx)
|
|
__must_hold(&ctx->uring_lock)
|
|
{
|
|
if (idx >= ctx->nr_notif_slots)
|
|
return NULL;
|
|
idx = array_index_nospec(idx, ctx->nr_notif_slots);
|
|
return &ctx->notif_slots[idx];
|
|
}
|