Multishot recv with Bundle Recv + Incremental Buffers - are they compatible?

[stonebrakert6]

[UPDATED - for better understanding of the issue]
Hi,
I have already gone through issues 1409 and 1423.
My setup(kernel version 6.17)

1. Provided buffers have incremental flag on i.e io_uring_setup_buf_ring(ring_, nr_bufs, bgid, IOU_PBUF_RING_INC, &ret);
2. sqe is configured to use bundle recv i.e sqe->ioprio |= IORING_RECVSEND_BUNDLE;
3. Assume that buffer size is 124 bytes.

My question is that can a given cqe span-across/use 2 buffers in above setting(because bundle recv is enabled)? From the assertion in test recv-inc-ooo.c. It seems that with incremental buffers a given cqe won't copy more than buffer_size len but can this still use 2 buffers?

i.e is the following sequence of cqes possible?

1. First cqe has res = 64 bytes, buffer_id = 0 and flags has IORING_CQE_F_BUF_MORE set.
2. Second cqe has res = 124 bytes, buffer_id = 0 (i.e pick 2 buffers since bundle recv is enabled)
   My guess is no, since we have this comment

/*
+		 * Limit incremental buffers to 1 segment. No point trying
+		 * to peek ahead and map more than we need, when the buffers
+		 * themselves should be large when setup with
+		 * IOU_PBUF_RING_INC.
+		 */

Questions

1. If above is possible what would be the status of IORING_CQE_F_BUF_MORE in the second cqe?
2. If it is not possible then can I say that bundle recv is incompatible/mutually-exclusive with incremental buffer consumption i.e either use big buffers for incremental consumption or enable bundle recv if using smaller buffer sizes.
3. With incremental buffers is it guaranteed that io_uring would completely use a buffer's memory fully before it uses the next buffer? If this is guaranteed then isn't the flag IORING_CQE_F_BUF_MORE redundant since the application is tracking the offset/cursor and would know that the buffer has been exhausted and so next bytes would be available in the next buffer.

[axboe]

I'm OOO for the next week, I'll take a look when I'm back.

[stonebrakert6]

Just to provide more context, it turns out that my guess(mentioned above) is wrong and when bundle recv is enabled, it is possible to get res such that the bytes are spanning across 2 buffers(and hence possibly more as well).

Is this expected behaviour? If yes, then in this case the flag IORING_CQE_F_BUF_MORE is associated with which buffer id? The buffer id present in the cqe->flags or the buffer id we get after traversing res bytes from the cqe's buffer-id?