io_operation.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_IO_OPERATION_HPP
#define JOIN_CORE_IO_OPERATION_HPP
 
// libjoin.
#include <join/io_ring_buffer.hpp>
 
// C++.
#include <atomic>
 
// C.
#include <sys/socket.h>
#include <cstdint>
#include <cstddef>
 
namespace join
{
    // forward declaration.
    class CompletionHandler;
 
    struct alignas (64) IoOperation
    {
        enum class State : uint8_t
        {
            Idle,      
            Submitted, 
            Busy,      
            Suspended, 
        };
 
        enum class Opcode : uint8_t
        {
            Poll,       
            Accept,     
            Connect,    
            Read,       
            Write,      
            ReadFixed,  
            WriteFixed, 
            RecvMsg,    
            SendMsg,    
            Recv,       
            Send,       
        };
 
        IoOperation () noexcept
        {
            state.store (State::Idle, std::memory_order_release);
        }
 
        IoOperation (const IoOperation& other) noexcept;
 
        IoOperation& operator= (const IoOperation& other) noexcept;
 
        struct PollData
        {
            int fd;
 
            uint32_t events;
        };
 
        static IoOperation makePoll (int fd, uint32_t events, CompletionHandler* handler) noexcept;
 
        static IoOperation makePollMulti (int fd, uint32_t events, CompletionHandler* handler) noexcept;
 
        struct AcceptData
        {
            int fd;
 
            sockaddr* addr;
 
            socklen_t* addrlen;
 
            int flags;
        };
 
        static IoOperation makeAccept (int fd, sockaddr* addr, socklen_t* addrlen, int flags,
                                       CompletionHandler* handler) noexcept;
 
        static IoOperation makeAcceptMulti (int fd, int flags, CompletionHandler* handler) noexcept;
 
        struct ConnectData
        {
            int fd;
 
            const sockaddr* addr;
 
            socklen_t addrlen;
        };
 
        static IoOperation makeConnect (int fd, const sockaddr* addr, socklen_t addrlen,
                                        CompletionHandler* handler) noexcept;
 
        struct RwData
        {
            int fd;
 
            void* buf;
 
            unsigned long len;
 
            uint16_t index;
 
            bool fixed;
        };
 
        static IoOperation makeRead (int fd, void* buf, uint32_t len, CompletionHandler* handler,
                                     bool linked = false) noexcept;
 
        static IoOperation makeWrite (int fd, const void* buf, uint32_t len, CompletionHandler* handler,
                                      bool linked = false) noexcept;
 
        static IoOperation makeReadFixed (int fd, void* buf, uint32_t len, uint16_t index, CompletionHandler* handler,
                                          bool linked = false) noexcept;
 
        static IoOperation makeWriteFixed (int fd, const void* buf, uint32_t len, uint16_t index,
                                           CompletionHandler* handler, bool linked = false) noexcept;
 
        struct MsgData
        {
            int fd;
 
            msghdr* msg;
 
            int flags;
 
            uint32_t namelen;
 
            uint32_t controllen;
        };
 
        static IoOperation makeRecvmsg (int fd, msghdr* msg, int flags, CompletionHandler* handler,
                                        bool linked = false) noexcept;
 
        static IoOperation makeRecvmsgMulti (int fd, uint16_t group, msghdr* msg, int flags,
                                             CompletionHandler* handler) noexcept;
 
        static IoOperation makeSendmsg (int fd, const msghdr* msg, int flags, CompletionHandler* handler,
                                        bool linked = false) noexcept;
 
        struct StreamData
        {
            int fd;
 
            void* buf;
 
            unsigned long len;
 
            int flags;
        };
 
        static IoOperation makeRecv (int fd, void* buf, uint32_t len, int flags, CompletionHandler* handler,
                                     bool linked = false) noexcept;
 
        static IoOperation makeRecvMulti (int fd, uint16_t group, int flags, CompletionHandler* handler) noexcept;
 
        static IoOperation makeSend (int fd, const void* buf, uint32_t len, int flags, CompletionHandler* handler,
                                     bool linked = false) noexcept;
 
        union Data
        {
            PollData poll;
            AcceptData accept;
            ConnectData connect;
            RwData rw;
            MsgData msg;
            StreamData stream;
        };
 
        int fd () const noexcept;
 
#ifdef JOIN_HAS_IO_URING
        uint32_t index = 0;
#else
        IoOperation* next = nullptr;
#endif
 
        uint8_t code = 0;
 
        std::atomic<State> state;
 
        State resume{State::Idle};
 
        bool linked = false;
 
        bool multishot = false;
 
        bool more = false;
 
        uint16_t group = 0;
 
        CompletionHandler* handler = nullptr;
 
        Data data = {};
 
        IoRingBuffer* ring = nullptr;
    };
 
    static_assert (offsetof (IoOperation, state) >= sizeof (uint32_t),
                   "state must survive the arena free list link stored in the first bytes of a released chunk");
}
 
#endif