Last Piece Hacktivist Crew

Editing: swoole_iouring.h

/*
  +----------------------------------------------------------------------+
  | Swoole                                                               |
  +----------------------------------------------------------------------+
  | This source file is subject to version 2.0 of the Apache license,    |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.apache.org/licenses/LICENSE-2.0.html                      |
  | If you did not receive a copy of the Apache2.0 license and are unable|
  | to obtain it through the world-wide-web, please send a note to       |
  | license@swoole.com so we can mail you a copy immediately.            |
  +----------------------------------------------------------------------+
  | Author: NathanFreeman  <mariasocute@163.com>                         |
  +----------------------------------------------------------------------+
*/

#pragma once

#include "swoole_coroutine.h"

#ifdef SW_USE_IOURING
#include <liburing.h>

using swoole::Coroutine;

enum swIouringFlag {
    SW_IOURING_DEFAULT = 0,
    SW_IOURING_SQPOLL = IORING_SETUP_SQPOLL,
};

namespace swoole {

struct IouringEvent;

struct IouringTimeout {
    int64_t tv_sec;
    int64_t tv_nsec;
};

class Iouring {
    uint32_t task_num = 0;
    uint32_t entries = SW_IOURING_QUEUE_SIZE;
    io_uring ring;
    std::queue<IouringEvent *> waiting_tasks;
    network::Socket *ring_socket = nullptr;
    Reactor *reactor = nullptr;

IouringEvent *ready_events[SW_IOURING_QUEUE_SIZE];
    io_uring_cqe *cqes[SW_IOURING_QUEUE_SIZE];

explicit Iouring(Reactor *reactor_);
    bool ready() const;
    void yield(IouringEvent *event);
    void resume(IouringEvent *event);
    bool cancel(IouringEvent *prev_event);
    void dispatch(IouringEvent *event);
    void submit(bool immediately);
    bool wakeup();

io_uring_sqe *alloc_sqe() {
        return io_uring_get_sqe(&ring);
    }

static Iouring *get_instance();
    static ssize_t execute(IouringEvent *event);
    static const char *get_opcode_name(enum io_uring_op opcode);

public:
    ~Iouring();

bool is_empty_waiting_tasks() const {
        return waiting_tasks.empty();
    }

uint64_t get_task_num() const {
        return task_num;
    }

uint32_t get_sq_space_left() const {
        return io_uring_sq_space_left(&ring);
    }

uint32_t get_sq_capacity() const {
        return ring.sq.ring_entries;
    }

uint32_t get_sq_used() const {
        return get_sq_capacity() - get_sq_space_left();
    }

size_t get_waiting_task_num() const {
        return waiting_tasks.size();
    }

float get_sq_usage_percent() const {
        return (float) get_sq_used() / get_sq_capacity() * 100.0f;
    }

static int socket(int domain, int type, int protocol = 0, int flags = 0);
    static int open(const char *pathname, int flags, mode_t mode);
    static int connect(int fd, const struct sockaddr *addr, socklen_t len, double timeout = -1);
    static int accept(int fd, struct sockaddr *addr, socklen_t *len, int flags = 0, double timeout = -1);
    static int bind(int fd, const struct sockaddr *addr, socklen_t len);
    static int listen(int fd, int backlog);
    static int sleep(int tv_sec, int tv_nsec, int flags = 0);
    static int sleep(double seconds);
    static ssize_t recv(int fd, void *buf, size_t len, int flags, double timeout = -1);
    static ssize_t send(int fd, const void *buf, size_t len, int flags, double timeout = -1);
    static ssize_t recvmsg(int fd, struct msghdr *message, int flags, double timeout = -1);
    static ssize_t sendmsg(int fd, const struct msghdr *message, int flags, double timeout = -1);
    static ssize_t sendto(
        int fd, const void *buf, size_t n, int flags, const struct sockaddr *addr, socklen_t len, double timeout = -1);
    static ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t size, double timeout = -1);
    static ssize_t recvfrom(int fd, void *_buf, size_t _n, sockaddr *_addr, socklen_t *_socklen, double timeout = -1);
    static ssize_t readv(int fd, const struct iovec *iovec, int count, double timeout = -1);
    static ssize_t writev(int fd, const struct iovec *iovec, int count, double timeout = -1);
    static int shutdown(int fd, int how);
    static int close(int fd);
    static ssize_t read(int fd, void *buf, size_t size, double timeout = -1);
    static ssize_t write(int fd, const void *buf, size_t size, double timeout = -1);
    static int rename(const char *oldpath, const char *newpath);
    static int mkdir(const char *pathname, mode_t mode);
    static int unlink(const char *pathname);
#ifdef HAVE_IOURING_STATX
    static int fstat(int fd, struct stat *statbuf);
    static int stat(const char *path, struct stat *statbuf);
#endif
    static int rmdir(const char *pathname);
    static int fsync(int fd);
    static int fdatasync(int fd);
    static pid_t wait(int *stat_loc, double timeout = -1);
    static pid_t waitpid(pid_t pid, int *stat_loc, int options, double timeout = -1);
    /**
     * Only supports listening to the readable and writable events of a single fd; nfds must be 1.
     */
    static int poll(struct pollfd *fds, nfds_t nfds, int timeout);
#ifdef HAVE_IOURING_FUTEX
    static int futex_wait(uint32_t *futex);
    static int futex_wakeup(uint32_t *futex);
#endif
#ifdef HAVE_IOURING_FTRUNCATE
    static int ftruncate(int fd, off_t length);
#endif

static std::unordered_map<std::string, int> list_all_opcode();
    static int callback(Reactor *reactor, Event *event);
};
};  // namespace swoole
#endif

Cancel