How to tell uring to give us buffers to be filled with data before sending?

[natko-a]

Assume that boilerplate code with setting up uring (io_uring_queue_init_params(), io_uring_setup_buf_ring(), io_uring_buf_ring_add()+io_uring_buf_ring_advance(), etc...) and networking is done.

In a scenario where we receive data, we prepare a multi-shot receive request, add IOSQE_BUFFER_SELECT flag and submit it. The completed CQE will give us a buffer ID that holds received data. Once we consume it, we mark buffers as "ready to be reused" with io_uring_buf_ring_add()+io_uring_buf_ring_advance().

How to achieve the same functionality when sending data?
I guess the required steps are:

1. Fill the buffers (how to get them?)
2. call io_uring_prep_send_bundle()+io_uring_submit (anything else?)
3. wait for CQE and put buffers back to ring with io_uring_buf_ring_add()+io_uring_buf_ring_advance(), so we can reuse them

One more thing; from the documentation for io_uring_prep_send(), the quote below says "with the result being how many bytes were sent, on success". Does that mean that successful sending can result in less bytes sent than it was provided for sending?

A single CQE is posted for the send, with the result being how many bytes were sent, on success. When used with provided buffers, send or send bundle will contain the starting buffer group ID in the CQE flags field. The number of bytes sent starts from there, and will be in
contiguous buffer IDs after that.

[natko-a]

To answer my own question... I can probably do it before the first io_uring_buf_ring_add().

[redbaron]

Does that mean that successful sending can result in less bytes sent than it was provided for sending?

Think of io_uring as a more efficient way to make sys calls. Semantic of each operation is pretty much the same as of a syscall. Partial sends and writes are norm and app should cater for it.

[natko-a]

I'm not surprised with that. It just makes things more complicated when you submit a bunch of buffers for sending. Need to figure out how to send until everything is sent.
I also wonder if there are any significant performance benefits in a scenario with a few clients, but with big data rates compared against the old send().

[axboe]

Not sure what the question is here - you are the one allocating and filling those buffers before adding them to the buffer group for io_uring to consume.

[natko-a]

Yes, figured that out once I posted the question...