Re: [PATCH v8 5/5] selftests/io_uring: add a bpf io_uring selftest

[Alexei Starovoitov <alexei.starovoitov@gmail.com>]

On Tue, Feb 17, 2026 at 3:33 AM Pavel Begunkov <asml.silence@gmail.com> wrote:
>
> +
> +struct {
> +       __uint(type, BPF_MAP_TYPE_ARRAY);
> +       __uint(max_entries, 3);
> +       __type(key, u32);
> +       __type(value, s64);
> +} res_map SEC(".maps");
> +
> +#define t_min(a, b) ((a) < (b) ? (a) : (b))
> +
> +static inline void set_cq_wait(struct iou_loop_params *lp,
> +                              struct io_uring *cq_hdr, unsigned to_wait)
> +{
> +       lp->cq_wait_idx = cq_hdr->head + to_wait;
> +}
> +
> +static inline void write_result(int res)
> +{
> +       u32 key = SLOT_RES;
> +       u64 *val;
> +
> +       val = bpf_map_lookup_elem(&res_map, &key);
> +       if (val)
> +               *val = res;
> +}
> +
> +static inline void write_stats(int idx, unsigned int v)
> +{
> +       u32 key = idx;
> +       u64 *val;
> +
> +       val = bpf_map_lookup_elem(&res_map, &key);
> +       if (val)
> +               *val += v;
> +}

Since these examples will be copied around, let's use
good coding practices. Use properly named global variables
for stats and counters, and drop this opaque array.

Also bpf_map_lookup_elem() doesn't need if (val) check
when key is a constant and lookup is from array map.

> +
> +SEC("struct_ops.s/nops_loop_step")
> +int BPF_PROG(nops_loop_step, struct io_ring_ctx *ring, struct iou_loop_params *ls)
> +{
> +       struct io_uring *sq_hdr, *cq_hdr;
> +       struct io_uring_sqe *sqes;
> +       struct io_uring_cqe *cqes;
> +       void *rings;
> +       int ret;
> +
> +       sqes = (void *)bpf_io_uring_get_region(ring, IOU_REGION_SQ,
> +                               SQ_ENTRIES * sizeof(struct io_uring_sqe));
> +       rings = (void *)bpf_io_uring_get_region(ring, IOU_REGION_CQ,
> +                               cqes_offset + CQ_ENTRIES * sizeof(struct io_uring_cqe));
> +       if (!rings || !sqes) {
> +               write_result(-1);
> +               return IOU_LOOP_STOP;
> +       }
> +
> +       sq_hdr = rings + (sq_hdr_offset & 63);
> +       cq_hdr = rings + (cq_hdr_offset & 63);
> +       cqes = rings + cqes_offset;
> +
> +       unsigned to_wait = cq_hdr->tail - cq_hdr->head;
> +       to_wait = t_min(to_wait, CQ_ENTRIES);
> +       for (int i = 0; i < to_wait; i++) {
> +               struct io_uring_cqe *cqe = &cqes[cq_hdr->head & (CQ_ENTRIES - 1)];
> +
> +               if (cqe->user_data != REQ_TOKEN) {
> +                       write_result(-3);
> +                       return IOU_LOOP_STOP;
> +               }
> +               cq_hdr->head++;
> +       }

CQ_ENTRIES is just 8.
Is it enough for real progs?
Does the above approach scale ?
I mean the above works as a bounded loop because loop
count is small, but for 100+ you want open coded iterators.

In general all progs seem to be toy progs.
Would be good to have something more realistic.