cqe_handler.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "condy/concepts.hpp"
#include "condy/context.hpp"
#include "condy/ring.hpp"
#include <cassert>
#include <cerrno>
#include <cstdint>
#include <utility>
 
namespace condy {
 
namespace detail {
 
// Just for debugging, check if the CQE is big as expected
inline bool check_cqe32([[maybe_unused]] io_uring_cqe *cqe) {
    auto *ring = detail::Context::current().ring();
    assert(ring != nullptr);
    auto ring_flags = ring->ring()->flags;
    if (ring_flags & IORING_SETUP_CQE32) {
        return true;
    }
#if !IO_URING_CHECK_VERSION(2, 13) // >= 2.13
    if (ring_flags & IORING_SETUP_CQE_MIXED) {
        return cqe->flags & IORING_CQE_F_32;
    }
#endif
    return false;
}
 
} // namespace detail

class SimpleCQEHandler {
public:
    using ReturnType = int32_t;
 
    void handle_cqe(io_uring_cqe *cqe) noexcept { res_ = cqe->res; }
 
    ReturnType extract_result() noexcept { return res_; }
 
private:
    int32_t res_ = -ENOTRECOVERABLE; // Internal error if not set
};

template <BufferRingLike Br> class SelectBufferCQEHandler {
public:
    using ReturnType = std::pair<int, typename Br::ReturnType>;
 
    SelectBufferCQEHandler(Br *buffers) : buffers_(buffers) {}
 
    void handle_cqe(io_uring_cqe *cqe) noexcept {
        result_ = std::make_pair(cqe->res, buffers_->handle_finish(cqe));
    }
 
    ReturnType extract_result() noexcept { return std::move(result_); }
 
private:
    ReturnType result_ = {-ENOTRECOVERABLE, typename Br::ReturnType()};
    Br *buffers_;
};

struct NVMeResult {
    int status;

    uint64_t result;
};

class NVMePassthruCQEHandler {
public:
    using ReturnType = NVMeResult;
 
    void handle_cqe(io_uring_cqe *cqe) noexcept {
        assert(detail::check_cqe32(cqe) &&
               "Expected big CQE for NVMe passthrough");
        result_.status = cqe->res;
        result_.result = cqe->big_cqe[0];
    }
 
    ReturnType extract_result() noexcept { return result_; }
 
private:
    NVMeResult result_;
};
 
#if !IO_URING_CHECK_VERSION(2, 12) // >= 2.12
struct TxTimestampResult {
    int tskey; // cqe->res

    int tstype; // cqe->flags >> IORING_TIMESTAMP_TYPE_SHIFT

    io_timespec ts; // *(io_timespec *)(cqe + 1)

    bool hwts; // cqe->flags & IORING_CQE_F_TSTAMP_HW
};

class TxTimestampCQEHandler {
public:
    using ReturnType = TxTimestampResult;
 
    void handle_cqe(io_uring_cqe *cqe) noexcept {
        assert(detail::check_cqe32(cqe) &&
               "Expected big CQE for TX timestamp operations");
        result_.tskey = cqe->res;
        result_.tstype =
            static_cast<int>(cqe->flags >> IORING_TIMESTAMP_TYPE_SHIFT);
        result_.ts = *reinterpret_cast<io_timespec *>(cqe + 1);
        result_.hwts = cqe->flags & IORING_CQE_F_TSTAMP_HW;
    }
 
    ReturnType extract_result() noexcept { return result_; }
 
private:
    TxTimestampResult result_;
};
#endif
 
} // namespace condy