Scatter Read Bypass of Concurrent Read Limit in Async IO

Summary

The Async IO layer enforces concurrent_read_io_limit_ only for the single-buffer read path. Scatter reads submitted through the iovec-based path increment a separate in-flight counter and are sent directly to io_uring without passing through the same gate.

That mismatch allows scatter reads to bypass the configured read throttle.

Affected Area

• monad/category/async/io.cpp
• monad/category/async/io.hpp

Details

The implementation tracks:

• records_.inflight_rd for single-buffer reads
• records_.inflight_rd_scatter for scatter reads

Only the single-buffer path checks concurrent_read_io_limit_ before submission. The scatter path immediately increments records_.inflight_rd_scatter and submits the request. The restart logic in poll_uring_() also checks only records_.inflight_rd, so the queueing policy is inconsistent in both directions.

1
size_t submit_read_request(
2
    std::span<std::byte> buffer, chunk_offset_t offset,
3
    erased_connected_operation *uring_data)
4
{
5
    if (concurrent_read_io_limit_ > 0) {
6
        if (records_.inflight_rd >= concurrent_read_io_limit_) {
7
            // queue single-buffer reads
8
            return size_t(-1);
9
        }
10
    }
11
    submit_request_(buffer, offset, uring_data, uring_data->io_priority());
12
    if (++records_.inflight_rd > records_.max_inflight_rd) {
13
        records_.max_inflight_rd = records_.inflight_rd;
14
    }
15
}
16

17
size_t submit_read_request(
18
    std::span<const struct iovec> buffers, chunk_offset_t offset,
19
    erased_connected_operation *uring_data)
20
{
21
    submit_request_(buffers, offset, uring_data, uring_data->io_priority());
22
    if (++records_.inflight_rd_scatter > records_.max_inflight_rd_scatter) {
23
        records_.max_inflight_rd_scatter = records_.inflight_rd_scatter;
24
    }
25
}

Impact

A workload that routes reads through the scatter/iovec path can exceed the intended cap on concurrent physical reads. In practice, that increases pressure on:

• ring entries
• memory and internal queues
• descriptor and buffer resources

The net effect is avoidable resource exhaustion and degraded node availability.

Recommendation

Gate all read submissions against the combined in-flight read count. If the combined number of single-buffer and scatter reads is already at the configured limit, queue the scatter request instead of submitting it immediately.