Diff coverage report for

//

//

// Copyright (c) 2026 Steve Gerbino

// Copyright (c) 2026 Steve Gerbino

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/cppalliance/corosio

// Official repository: https://github.com/cppalliance/corosio

//

//

#ifndef BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_SOCKET_SERVICE_HPP

#ifndef BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_SOCKET_SERVICE_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_SOCKET_SERVICE_HPP

#define BOOST_COROSIO_NATIVE_DETAIL_EPOLL_EPOLL_SOCKET_SERVICE_HPP

#include <boost/corosio/detail/platform.hpp>

#include <boost/corosio/detail/platform.hpp>

#if BOOST_COROSIO_HAS_EPOLL

#if BOOST_COROSIO_HAS_EPOLL

#include <boost/corosio/detail/config.hpp>

#include <boost/corosio/detail/config.hpp>

#include <boost/capy/ex/execution_context.hpp>

#include <boost/capy/ex/execution_context.hpp>

#include <boost/corosio/detail/socket_service.hpp>

#include <boost/corosio/detail/socket_service.hpp>

#include <boost/corosio/native/detail/epoll/epoll_socket.hpp>

#include <boost/corosio/native/detail/epoll/epoll_socket.hpp>

#include <boost/corosio/native/detail/epoll/epoll_scheduler.hpp>

#include <boost/corosio/native/detail/epoll/epoll_scheduler.hpp>

#include <boost/corosio/detail/endpoint_convert.hpp>

#include <boost/corosio/detail/endpoint_convert.hpp>

#include <boost/corosio/detail/make_err.hpp>

#include <boost/corosio/detail/make_err.hpp>

#include <boost/corosio/detail/dispatch_coro.hpp>

#include <boost/corosio/detail/dispatch_coro.hpp>

#include <boost/corosio/detail/except.hpp>

#include <boost/corosio/detail/except.hpp>

#include <boost/capy/buffers.hpp>

#include <boost/capy/buffers.hpp>

#include <coroutine>

#include <coroutine>

#include <mutex>

#include <mutex>

#include <unordered_map>

#include <unordered_map>

#include <utility>

#include <utility>

#include <errno.h>

#include <errno.h>

#include <netinet/in.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <netinet/tcp.h>

#include <sys/epoll.h>

#include <sys/epoll.h>

#include <sys/socket.h>

#include <sys/socket.h>

#include <unistd.h>

#include <unistd.h>

/*

/*

    epoll Socket Implementation

    epoll Socket Implementation

    ===========================

    ===========================

    Each I/O operation follows the same pattern:

    Each I/O operation follows the same pattern:

      1. Try the syscall immediately (non-blocking socket)

      1. Try the syscall immediately (non-blocking socket)

      2. If it succeeds or fails with a real error, post to completion queue

      2. If it succeeds or fails with a real error, post to completion queue

      3. If EAGAIN/EWOULDBLOCK, register with epoll and wait

      3. If EAGAIN/EWOULDBLOCK, register with epoll and wait

    This "try first" approach avoids unnecessary epoll round-trips for

    This "try first" approach avoids unnecessary epoll round-trips for

    operations that can complete immediately (common for small reads/writes

    operations that can complete immediately (common for small reads/writes

    on fast local connections).

    on fast local connections).

    One-Shot Registration

    One-Shot Registration

    ---------------------

    ---------------------

    We use one-shot epoll registration: each operation registers, waits for

    We use one-shot epoll registration: each operation registers, waits for

    one event, then unregisters. This simplifies the state machine since we

    one event, then unregisters. This simplifies the state machine since we

    don't need to track whether an fd is currently registered or handle

    don't need to track whether an fd is currently registered or handle

    re-arming. The tradeoff is slightly more epoll_ctl calls, but the

    re-arming. The tradeoff is slightly more epoll_ctl calls, but the

    simplicity is worth it.

    simplicity is worth it.

    Cancellation

    Cancellation

    ------------

    ------------

    See op.hpp for the completion/cancellation race handling via the

    See op.hpp for the completion/cancellation race handling via the

    `registered` atomic. cancel() must complete pending operations (post

    `registered` atomic. cancel() must complete pending operations (post

    them with cancelled flag) so coroutines waiting on them can resume.

    them with cancelled flag) so coroutines waiting on them can resume.

    close_socket() calls cancel() first to ensure this.

    close_socket() calls cancel() first to ensure this.

    Impl Lifetime with shared_ptr

    Impl Lifetime with shared_ptr

    -----------------------------

    -----------------------------

    Socket impls use enable_shared_from_this. The service owns impls via

    Socket impls use enable_shared_from_this. The service owns impls via

    shared_ptr maps (socket_ptrs_) keyed by raw pointer for O(1) lookup and

    shared_ptr maps (socket_ptrs_) keyed by raw pointer for O(1) lookup and

    removal. When a user calls close(), we call cancel() which posts pending

    removal. When a user calls close(), we call cancel() which posts pending

    ops to the scheduler.

    ops to the scheduler.

    CRITICAL: The posted ops must keep the impl alive until they complete.

    CRITICAL: The posted ops must keep the impl alive until they complete.

    Otherwise the scheduler would process a freed op (use-after-free). The

    Otherwise the scheduler would process a freed op (use-after-free). The

    cancel() method captures shared_from_this() into op.impl_ptr before

    cancel() method captures shared_from_this() into op.impl_ptr before

    posting. When the op completes, impl_ptr is cleared, allowing the impl

    posting. When the op completes, impl_ptr is cleared, allowing the impl

    to be destroyed if no other references exist.

    to be destroyed if no other references exist.

    Service Ownership

    Service Ownership

    -----------------

    -----------------

    epoll_socket_service owns all socket impls. destroy_impl() removes the

    epoll_socket_service owns all socket impls. destroy_impl() removes the

    shared_ptr from the map, but the impl may survive if ops still hold

    shared_ptr from the map, but the impl may survive if ops still hold

    impl_ptr refs. shutdown() closes all sockets and clears the map; any

    impl_ptr refs. shutdown() closes all sockets and clears the map; any

    in-flight ops will complete and release their refs.

    in-flight ops will complete and release their refs.

*/

*/

namespace boost::corosio::detail {

namespace boost::corosio::detail {

/** State for epoll socket service. */

/** State for epoll socket service. */

class epoll_socket_state

class epoll_socket_state

{

{

public:

public:

    {

    {

    epoll_scheduler& sched_;

    epoll_scheduler& sched_;

    std::mutex mutex_;

    std::mutex mutex_;

    intrusive_list<epoll_socket> socket_list_;

    intrusive_list<epoll_socket> socket_list_;

    std::unordered_map<epoll_socket*, std::shared_ptr<epoll_socket>>

    std::unordered_map<epoll_socket*, std::shared_ptr<epoll_socket>>

        socket_ptrs_;

        socket_ptrs_;

};

};

/** epoll socket service implementation.

/** epoll socket service implementation.

    Inherits from socket_service to enable runtime polymorphism.

    Inherits from socket_service to enable runtime polymorphism.

    Uses key_type = socket_service for service lookup.

    Uses key_type = socket_service for service lookup.

*/

*/

class BOOST_COROSIO_DECL epoll_socket_service final : public socket_service

class BOOST_COROSIO_DECL epoll_socket_service final : public socket_service

{

{

public:

public:

    explicit epoll_socket_service(capy::execution_context& ctx);

    explicit epoll_socket_service(capy::execution_context& ctx);

    ~epoll_socket_service() override;

    ~epoll_socket_service() override;

    epoll_socket_service(epoll_socket_service const&)            = delete;

    epoll_socket_service(epoll_socket_service const&)            = delete;

    epoll_socket_service& operator=(epoll_socket_service const&) = delete;

    epoll_socket_service& operator=(epoll_socket_service const&) = delete;

    void shutdown() override;

    void shutdown() override;

    io_object::implementation* construct() override;

    io_object::implementation* construct() override;

    void destroy(io_object::implementation*) override;

    void destroy(io_object::implementation*) override;

    void close(io_object::handle&) override;

    void close(io_object::handle&) override;

    std::error_code open_socket(tcp_socket::implementation& impl) override;

    std::error_code

    open_socket(tcp_socket::implementation& impl,

                int family, int type, int protocol) override;

    {

    {

    }

    }

    void post(epoll_op* op);

    void post(epoll_op* op);

    void work_started() noexcept;

    void work_started() noexcept;

    void work_finished() noexcept;

    void work_finished() noexcept;

private:

private:

    std::unique_ptr<epoll_socket_state> state_;

    std::unique_ptr<epoll_socket_state> state_;

};

};

//--------------------------------------------------------------------------

//--------------------------------------------------------------------------

//

//

// Implementation

// Implementation

//

//

//--------------------------------------------------------------------------

//--------------------------------------------------------------------------

// Register an op with the reactor, handling cached edge events.

// Register an op with the reactor, handling cached edge events.

// Called under the EAGAIN/EINPROGRESS path when speculative I/O failed.

// Called under the EAGAIN/EINPROGRESS path when speculative I/O failed.

inline void

inline void

    epoll_op& op,

    epoll_op& op,

    epoll_op*& desc_slot,

    epoll_op*& desc_slot,

    bool& ready_flag,

    bool& ready_flag,

    bool& cancel_flag) noexcept

    bool& cancel_flag) noexcept

{

{

    {

    {

    }

    }

    {

    {

    }

    }

    {

    {

    }

    }

    else

    else

    {

    {

    }

    }

inline void

inline void

{

{

inline void

inline void

{

{

    else

    else

inline void

inline void

{

{

    else

    else

inline void

inline void

{

{

    else

    else

inline void

inline void

{

{

    else

    else

    // Move to stack before resuming coroutine. The coroutine might close

    // Move to stack before resuming coroutine. The coroutine might close

    // the socket, releasing the last wrapper ref. If impl_ptr were the

    // the socket, releasing the last wrapper ref. If impl_ptr were the

    // last ref and we destroyed it while still in operator(), we'd have

    // last ref and we destroyed it while still in operator(), we'd have

    // use-after-free. Moving to local ensures destruction happens at

    // use-after-free. Moving to local ensures destruction happens at

    // function exit, after all member accesses are complete.

    // function exit, after all member accesses are complete.

inline void

inline void

{

{

    // Cache endpoints on successful connect

    // Cache endpoints on successful connect

        // Query local endpoint via getsockname (may fail, but remote is always known)

    {

    {

    }

    }

    else

    else

    // Move to stack before resuming. See epoll_op::operator()() for rationale.

    // Move to stack before resuming. See epoll_op::operator()() for rationale.

{

{

inline std::coroutine_handle<>

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    capy::executor_ref ex,

    endpoint ep,

    endpoint ep,

    std::stop_token token,

    std::stop_token token,

    std::error_code* ec)

    std::error_code* ec)

{

{

    socklen_t addrlen =

    int result =

    int result =

    {

    {

    }

    }

    {

    {

        {

        {

        }

        }

    }

    }

    // EINPROGRESS — register with reactor

    // EINPROGRESS — register with reactor

}

}

inline std::coroutine_handle<>

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    capy::executor_ref ex,

    io_buffer_param param,

    io_buffer_param param,

    std::stop_token token,

    std::stop_token token,

    std::error_code* ec,

    std::error_code* ec,

    std::size_t* bytes_out)

    std::size_t* bytes_out)

{

{

    {

    {

    }

    }

    {

    {

    }

    }

    // Speculative read

    // Speculative read

    ssize_t n;

    ssize_t n;

    do

    do

    {

    {

    }

    }

    {

    {

        {

        {

            else

            else

        }

        }

    }

    }

    // EAGAIN — register with reactor

    // EAGAIN — register with reactor

}

}

inline std::coroutine_handle<>

inline std::coroutine_handle<>

    std::coroutine_handle<> h,

    std::coroutine_handle<> h,

    capy::executor_ref ex,

    capy::executor_ref ex,

    io_buffer_param param,

    io_buffer_param param,

    std::stop_token token,

    std::stop_token token,

    std::error_code* ec,

    std::error_code* ec,

    std::size_t* bytes_out)

    std::size_t* bytes_out)

{

{

    {

    {

    }

    }

    {

    {

    }

    }

    // Speculative write

    // Speculative write

    ssize_t n;

    ssize_t n;

    do

    do

    {

    {

    }

    }

    {

    {

        {

        {

        }

        }

    }

    }

    // EAGAIN — register with reactor

    // EAGAIN — register with reactor

}

}

inline std::error_code

inline std::error_code

{

{

    int how;

    int how;

    {