[sylar]C++高性能服务器框架——hook模块

找人找不到北
1,215 阅读11分钟

hook模块概述

hook模块封装了一些C标准库提供的API，socket IO相关的API。能够使同步API实现异步的性能。

hook将API封装成一个与原始系统调用同名的接口，在调用这个接口时，先实现一些别的操作，然后在调用原始的系统API。这样对开发者来说很方便，不用重新学习新的接口，用着同步的接口实现异步的操作。

如果不使用IOManager，那么hook将没有作用，在IOManager::run()中使用set_hook_enable()将当前线程hook。

例如，当IOManager设置为一个线程执行时，通过scheduler添加了3个任务，sleep(3)，write，read。每个任务是在协程上按顺序执行的

  • 如果没有hook

    • 要先等睡3秒，然后再发送，等发送完再接收数据，一旦有个任务导致协程阻塞，整个线程就阻塞掉了。

  • 如果hook了

    • 那么在执行sleep时就先添加个3秒的定时器，回调函数为继续调度本协程，然后让协程让出执行权。
    • 可以紧接着执行write操作，不用再等待3秒钟了，当调度器执行write会先注册一个写事件，回调函数是让当前协程唤醒继续执行，然后让协程让出执行权。
    • 执行完write可以紧接着执行read，在调度器上注册一个读事件，回调函数是当让当前协程唤醒继续执行，让后让协程让出执行权。
    • 等3秒后，执行定时器的回调函数，让协程继续调用sleep。
    • 在等待3秒的过程中，一旦可写，那么就继续执行写的协程。
    • 一旦可读，那么就继续执行读的协程。

只对socket文件进行hook操作，其他的文件执行原本的API，为了更好的管理socket文件，使用fdmanager管理每个socket fd，并且为每个socket文件隐式的设置为O_NONBLOCK非阻塞，为了统一每一个API的统一性，所以也hook了fcntl_f等函数。

hook实现基础

hook的实现机制非常简单，就是通过动态库的全局符号介入功能，用自定义的接口来替换掉同名的系统调用接口。由于系统调用接口基本上是由C标准函数库libc提供的，所以这里要做的事情就是用自定义的动态库来覆盖掉libc中的同名符号。

由于动态库的全局符号介入问题，全局符号表只会记录第一次识别到的符号，后续的同名符号都被忽略，但这并不表示同名符号所在的动态库完全不会加载，因为有可能其他的符号会用到。以libc库举例，如果用户在链接libc库之前链接了一个指定的库，并且在这个库里实现了read/write接口，那么在程序运行时，程序调用的read/write接口就是指定库里的，而不是libc库里的。libc库仍然会被加载，因为libc库是程序的运行时库，程序不可能不依赖libc里的其他接口。因为libc库也被加载了，所以，通过一定的手段，仍然可以从libc中拿到属于libc的read/write接口，这就为hook创建了条件。程序可以定义自己的read/write接口，在接口内部先实现一些相关的操作，然后再调用libc里的read/write接口。

而将libc库中的接口重新找回来的方法就是使用dlsym()

#include <dlfcn.h>
​
/*
 * 第一个参数固定为 RTLD_NEXT，第二个参数为符号的名称
 */
void *dlsym(void *handle, const char *symbol);

详解

文件管理

FdCtx存储每一个fd相关的信息，并由FdManager管理每一个FdCtx，FdManager为单例类

class FdCtx

mumber（成员变量）

// 是否初始化
bool m_isInit: 1;
// 是否socket
bool m_isSocket: 1;
// 是否hook非阻塞
bool m_sysNonblock: 1;
// 是否用户主动设置非阻塞
bool m_userNonblock: 1;
// 是否关闭
bool m_isClosed: 1;
// 文件句柄
int m_fd;
// 读超时时间毫秒
uint64_t m_recvTimeout;
// 写超时时间毫秒
uint64_t m_sendTimeout;

FdCtx（构造函数）

FdCtx::FdCtx(int fd)
    : m_isInit(false)
    , m_isSocket(false)
    , m_sysNonblock(false)
    , m_usrNonblock(false)
    , m_isClosed(false)
    , m_fd(fd)
    , m_recvTimeout(-1)
    , m_sendTimeout(-1){
    // 初始化
    init();
}

init（初始化）

bool FdCtx::init() {
    // 初始化过了
    if (m_isInit) {
        return true;
    }
    m_recvTimeout = -1;
    m_sendTimeout = -1;
    
    struct stat fd_stat;
    // return 0 : 成功取出
    // return -1 : 取出失败，关闭了
    if (-1 == fstat(m_fd, &fd_stat)) {
        m_isInit = false;
        m_isSocket = false;
    } else {
        m_isInit = true;
        // 判断文件是否为socket
        m_isSocket = S_ISSOCK(fd_stat.st_mode);
    }
    
    // 是socket则设置为非阻塞模式
    if (m_isSocket) {
        int flag = fcntl_f(m_fd, F_GETFL, 0);
        if (!(flag & O_NONBLOCK)) {
            fcntl_f(m_fd, F_SETFL, flag | O_NONBLOCK);
        }
        m_sysNonblock = true;
    } else {
        m_sysNonblock = false;
    }
​
    m_usrNonblock = false;
    m_isClosed = false;
​
    return m_isInit;
}

setTimeout（设置超时事件）

void FdCtx::setTimeout(int type, uint64_t v) {
    if (type == SO_RCVTIMEO) {
        m_recvTimeout = v;
    } else {
        m_sendTimeout = v;
    }
}

getTimeout（获得超时事件）

uint64_t FdCtx::getTimeout(int type) {
    if (type == SO_RCVTIMEO) {
        return m_recvTimeout;
    } else {
        return m_sendTimeout;
    }
}

class FdManager

mumber（成员变量）

// 读写锁
RWMutexType m_mutex;
// 文件句柄集合
std::vector<FdCtx::ptr> m_datas;

FdManager（构造函数）

FdManager::FdManager() {
    m_datas.resize(64);
}

get（获取/创建文件句柄类FdCtx）

auto_create：是否自动创建FdCtx

FdCtx::ptr FdManager::get(int fd, bool auto_create) {
    if (fd == -1) {
        return nullptr;
    }
    // 集合中没有，并且不自动创建，返回nullptr
    RWMUtexType::ReadLock lock(m_mutex);
    if ((int)m_datas.size() <= fd) {
        if (auto_create == false) {
            return nullptr;
        }
    } else {
        // 找到了直接返回
        if (m_datas[fd] || !auto_create) {
            return m_datas[fd];
        }
    }
    lock.unlock();
	
    RWMUtexType::WriteLock locK2(m_mutex);
    // 创建新的FdCtx
    FdCtx::ptr ctx(new FdCtx(fd));
    // fd比集合下标大，扩充
    if (fd >= (int)m_datas.size()) {
        m_datas.resize(fd * 1.5);
    }
    // 放入集合中
    m_datas[fd] = ctx;
    return ctx;
}

del（删除文件句柄类）

void FdManager::del(int fd) {
    RWMUtexType::WriteLock lock(m_mutex);
    if ((int)m_datas.size() <= fd) {
        return;
    }
    m_datas[fd].reset();
}

HOOK模块

将函数接口都存放到extern "C"作用域下，指定函数按照C语言的方式进行编译和链接。它的作用是为了解决C++中函数名重载的问题，使得C++代码可以和C语言代码进行互操作。

定义接口函数指针

/* 重新定义同签名的接口 只列举了几个*/

// sleep_fun 为函数指针
typedef unsigned int (*sleep_fun)(unsigned int seconds);
// 它是一个sleep_fun类型的函数指针变量，表示该变量在其他文件中已经定义，我们只是在当前文件中引用它。
extern sleep_fun sleep_f;

typedef int (*socket_fun)(int domain, int type, int protocol);
extern socket_fun socket_f;

typedef ssize_t(*read_fun)(int fd, void* buf, size_t count);
extern read_fun read_f;

typedef ssize_t (*write_fun)(int fd, const void *buf, size_t count);
extern write_fun write_f;

获取接口原始地址

使用宏来封装对每个原始接口地址的获取。

将hook_init()封装到一个结构体的构造函数中，并创建静态对象，能够在main函数运行之前就能将地址保存到函数指针变量当中。

#define HOOK_FUN(XX) \
    XX(sleep) \
    XX(usleep) \
    XX(nanosleep) \
    XX(socket) \
    XX(connect) \
    XX(accept) \
    XX(read) \
    XX(readv) \
    XX(recv) \
    XX(recvfrom) \
    XX(recvmsg) \
    XX(write) \
    XX(writev) \
    XX(send) \
    XX(sendto) \
    XX(sendmsg) \
    XX(close) \
    XX(fcntl) \
    XX(ioctl) \
    XX(getsockopt) \
    XX(setsockopt) 

void hook_init() {
    static bool is_inited = false;
    if (is_inited) {
        return;
    }
// dlsym - 从一个动态链接库或者可执行文件中获取到符号地址。成功返回跟name关联的地址
// RTLD_NEXT 返回第一个匹配到的 "name" 的函数地址
// 取出原函数，赋值给新函数
#define XX(name) name ## _f = (name ## _fun)dlsym(RTLD_NEXT, #name);
    HOOK_FUN(XX)
#undef XX
}

extern "C" {
// 声明变量
#define XX(name) name ## _fun name ## _f = nullptr;
    HOOK_FUN(XX)
#undef XX
}

宏展开如下

extern "C" {
	sleep_fun sleep_f = nullptr;
    usleep_fun usleep_f = nullptr;
	.....
	setsocketopt_fun setsocket_f = nullptr;
}

void hook_init() {
    static bool is_inited = false;
    if (is_inited) {
        return;
    }
    
	sleep_f = (sleep_fun)dlsym(RTLD_NEXT, "sleep");
    usleep_f = (usleep_fun)dlsym(RTLD_NEXT, "usleep");
    ...
    setsocketopt_f = (setsocketopt_fun)dlsym(RTLD_NEXT, "setsocketopt");
}

set_hook_enable（设置是否hook）

定义线程局部变量，来控制是否开启hook

static thread_local bool t_hook_enable = false;

void set_hook_enable(bool flag) {
    t_hook_enable = flag;
}

is_hook_enable（获取是否hook）

bool is_hook_enable() {
    return t_hook_enable;
}

do_io（socket操作真正执行体）

需要注意的是，这段代码使用了模板和可变参数，可以适用于不同类型的IO操作，能够以写同步的方式实现异步的效果。

该函数的主要思想如下：

  1. 先进行一系列判断，是否按原函数执行。
  2. 执行原始函数进行操作，若errno = EINTR，则为系统中断，应该不断重新尝试操作。
  3. 若errno = EAGIN，系统已经隐式的将socket设置为非阻塞模式，此时资源咱不可用。
  4. 若设置了超时时间，则设置一个执行周期为超时时间的条件定时器，它保证若在超时之前数据就已经来了，然后操作完do_io执行完毕，智能指针tinfo已经销毁了，但是定时器还在，此时弱指针拿到的就是个空指针，将不会执行定时器的回调函数。
  5. 在条件定时器的回调函数中设置错误为ETIMEDOUT超时，并且使用cancelEvent强制执行该任务，继续回到该协程执行。
  6. 通过addEvent添加事件，若添加事件失败，则将条件定时器删除并返回错误。成功则让出协程执行权。
  7. 只有两种情况协程会被拉起： a. 超时了，通过定时器回调函数 cancelEvent ---> triggerEvent会唤醒回来 b. addEvent数据回来了会唤醒回来
  8. 将定时器取消，若为超时则返回-1并设置errno = ETIMEDOUT，并返回-1。
  9. 若为数据来了则retry，重新操作。
// 定时器超时条件
struct timer_info{
    int cancelled = 0;
};

/*
 * 	fd 			 	文件描述符
 * 	fun				原始函数
 *	hook_fun_name	hook的函数名称
 *	event			事件
 *	timeout_so		超时时间类型
 *	args			可变参数
 * 
 * 	例如：return do_io(fd, read_f, "read", sylar::IOManager::READ, SO_RCVTIMEO, buf, count);
 */
template<typename OriginFun, typename ... Args>
static ssize_t do_io(int fd, OriginFun fun, const char* hook_fun_name,
    uint32_t event, int timeout_so, Args&&... args) {
    // 如果不hook，直接返回原接口
    if (!sylar::is_hook_enable()) {
        /* 可以将传入的可变参数args以原始类型的方式传递给函数fun。
         * 这样做的好处是可以避免不必要的类型转换和拷贝，提高代码的效率和性能。*/
        return fun(fd, std::forward<Args>(args)...);
    }
	
    // 获取fd对应的FdCtx
    sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
    // 没有文件 
    if (!ctx) {
        return fun(fd, std::forward<Args>(args)...);
    }
	
    // 看看句柄是否关闭
    if (ctx->isClosed()) {
        // 坏文件描述符
        errno = EBADF;
        return -1;
    }
	
    // 不是socket 或 用户设置了非阻塞
    if (!ctx->isSocket() || ctx->getUserNonblock()) {
        return fun(fd, std::forward<Args>(args)...);
    }

    // ------ hook要做了 ------异步IO
    // 获得超时时间
    uint64_t to = ctx->getTimeout(timeout_so);
    // 设置超时条件
    std::shared_ptr<timer_info> tinfo(new timer_info);
retry:
    // 先执行fun 读数据或写数据 若函数返回值有效就直接返回
    ssize_t n = fun(fd, std::forward<Args>(args)...);
    SYLAR_LOG_DEBUG(sylar::g_logger) << "do_io <" << hook_fun_name << ">" << " n = " << n;
    // 若中断则重试
    while (n == -1 && errno == EINTR) {
        n = fun(fd, std::forward<Args>(args)...);
    }
    // 若为阻塞状态
    if (n == -1 && errno == EAGAIN) {
        // 重置EAGIN(errno = 11)，此处已处理，不在向上返回该错误
        errno = 0; 
        
        // 获得当前IO调度器
        sylar::IOManager* iom = sylar::IOManager::GetThis();
        // 定时器
        sylar::Timer::ptr timer;
        // tinfo的弱指针，可以判断tinfo是否已经销毁
        std::weak_ptr<timer_info> winfo(tinfo);

        // 说明设置了超时时间
        if (to != (uint64_t)-1) {
            /*	添加条件定时器
             *	to时间消息还没来就触发callback */ 
            timer = iom->addConditionTimer(to, [winfo, fd, iom, event]() {
                auto t = winfo.lock();
                /* tinfo失效 || 设了错误
                 * 定时器失效了 */
                if (!t || t->cancelled) {
                    return;
                }
                // 没错误的话设置为超时而失败
                t->cancelled = ETIMEDOUT;
                // 取消事件强制唤醒
                iom->cancelEvent(fd, (sylar::IOManager::Event)(event));
            }, winfo);
        }

        /* addEvent error:-1 acc:0  
         * cb为空， 任务为执行当前协程 */
        int rt = iom->addEvent(fd, (sylar::IOManager::Event)(event));
        // addEvent失败， 取消上面加的定时器
        if (rt == -1) {
            SYLAR_LOG_ERROR(sylar::g_logger) << hook_fun_name << " addEvent("
                << fd << ", " << event << ")";
            if (timer) {
                timer->cancel();
            }
            return -1;
        } else {
            /*	addEvent成功，把执行时间让出来
             *	只有两种情况会从这回来：
             * 	1) 超时了， timer cancelEvent triggerEvent会唤醒回来
             * 	2) addEvent数据回来了会唤醒回来 */
            sylar::Fiber::YieldToHold();
			// 回来了还有定时器就取消掉
            if (timer) {
                timer->cancel();
            }

            // 从定时任务唤醒，超时失败
            if (tinfo->cancelled) {
                // errno = ETIMEDOUT
                errno = tinfo->cancelled;
                return -1;
            }
            // 数据来了就直接重新去操作
            goto retry;
        }
    }
    return n;
}

sleep（睡眠系列）

设置一个定时器然后让出执行权，超时后继续执行该协程。

回调函数使用std::bind函数将sylar::IOManager::schedule函数绑定到iom对象上，并传入fiber和-1两个参数。由于schedule是个模板类，如果直接与函数绑定，就无法确定函数的类型，从而无法使用std::bind函数。因此，需要先声明函数指针，将函数的类型确定下来，然后再将函数指针与std::bind函数进行绑定。

unsigned int sleep(unsigned int seconds) {
    if (!sylar::t_hook_enable) {
        return sleep_f(seconds);
    }
    sylar::Fiber::ptr fiber = sylar::Fiber::GetThis();
    sylar::IOManager* iom = sylar::IOManager::GetThis();

    /**
     * 	@details
     *
     *	(void(sylar::Scheduler::*)(sylar::Fiber::ptr, int thread)) 是一个函数指针类型，
     *	它定义了一个指向 sylar::Scheduler 类中一个参数为 sylar::Fiber::ptr 和 int 类型的成员函数的指针类型。
     *	具体来说，它的含义如下：
     *	void 表示该成员函数的返回值类型，这里是 void 类型。
     *	(sylar::Scheduler::*) 表示这是一个 sylar::Scheduler 类的成员函数指针类型。
     *	(sylar::Fiber::ptr, int thread) 表示该成员函数的参数列表
     *       ，其中第一个参数为 sylar::Fiber::ptr 类型，第二个参数为 int 类型。
     *	
     *	使用 std::bind 绑定了 sylar::IOManager::schedule 函数，
     * 	并将 iom 实例作为第一个参数传递给了 std::bind 函数，将sylar::IOManager::schedule函数绑定到iom对象上。
     * 	在这里，第二个参数使用了函数指针类型 (void(sylar::Scheduler::*)(sylar::Fiber::ptr, int thread))
     * 	，表示要绑定的函数类型是 sylar::Scheduler 类中一个参数为 sylar::Fiber::ptr 和 int 类型的成员函数
     * 	，这样 std::bind 就可以根据这个函数类型来实例化出一个特定的函数对象，并将 fiber 和 -1 作为参数传递给它。
     */
    iom->addTimer(seconds * 1000, std::bind((void (sylar::Scheduler::*) 
        (sylar::Fiber::ptr, int thread)) &sylar::IOManager::schedule, iom, fiber, -1));

    sylar::Fiber::YieldToHold();
    
    return 0;
}

socket（创建socket）

int socket(int domain, int type, int protocol) {
    if (!sylar::t_hook_enable) {
        return socket_f(domain, type, protocol);
    }
	
    int fd = socket_f(domain, type, protocol);
    if (fd == -1) {
        return fd;
    }
	
    // 将fd放入到文件管理中
    sylar::FdMgr::GetInstance()->get(fd, true);
    return fd;
}

connect（socket连接）

和do_io思路差不多

int connect(int sockfd, const struct sockaddr* addr, socklen_t addrlen) {
    return connect_with_timeout(sockfd, addr, addrlen, sylar::s_connect_timeout);
}

int connect_with_timeout(int fd, const struct sockaddr* addr, socklen_t addrlen, uint64_t timeout_ms) {
    if (!sylar::t_hook_enable) {
        return connect_f(fd, addr, addrlen);
    }

    sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
    if (!ctx || ctx->isClosed()) {
        errno = EBADF;
        return -1;
    }
	
    if (!ctx->isSocket()) {
        return connect_f(fd, addr, addrlen);
    }
	
    if (ctx->getUserNonblock()) {
        return connect_f(fd, addr, addrlen);
    }
	
    // ----- 异步开始 -----
    // 先尝试连接
    int n = connect_f(fd, addr, addrlen);
    // 连接成功
    if (n == 0) {
        return 0;
    // 其他错误，EINPROGRESS表示连接操作正在进行中
    } else if (n != -1 || errno != EINPROGRESS) {
        return n;
    }
	
    sylar::IOManager* iom = sylar::IOManager::GetThis();
    sylar::Timer::ptr timer;
    std::shared_ptr<timer_info> tinfo(new timer_info);
    std::weak_ptr<timer_info> winfo(tinfo);

    // 设置了超时时间
    if (timeout_ms != (uint64_t)-1) {
        // 加条件定时器
        timer = iom->addConditionTimer(timeout_ms, [iom, fd, winfo]() {
            auto t = winfo.lock();
            if (!t || t->cancelled) {
                return;
            }
            t->cancelled = ETIMEDOUT;
            iom->cancelEvent(fd, sylar::IOManager::WRITE);
            }, winfo);
    }
    
    // 添加一个写事件
    int rt = iom->addEvent(fd, sylar::IOManager::WRITE);
    if (rt == 0) {
        /* 	只有两种情况唤醒：
         * 	1. 超时，从定时器唤醒
         *	2. 连接成功，从epoll_wait拿到事件 */
        sylar::Fiber::YieldToHold();
        if (timer) {
            timer->cancel();
        }
        // 从定时器唤醒，超时失败
        if (tinfo->cancelled) {
            errno = tinfo->cancelled;
            return -1;
        }
      // 添加事件失败
    } else {
        if (timer) {
            timer->cancel();
        }
        SYLAR_LOG_ERROR(sylar::g_logger) << "connect addEvent(" << fd << ", WRITE) error";
    }
	
    int error = 0;
    socklen_t len = sizeof(int);
    // 获取套接字的错误状态
    if (-1 == getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len)) {
        return -1;
    }
    // 没有错误，连接成功
    if (!error) {
        return 0;
    // 有错误，连接失败
    } else {
        errno = error;
        return -1;
    }
}

accept（接收请求）

int accept(int sockfd, struct sockaddr* addr, socklen_t* addrlen) {
    int fd = do_io(sockfd, accept_f, "accept", sylar::IOManager::READ, SO_RCVTIMEO, addr, addrlen);
    // 将新创建的连接放到文件管理中
    if (fd >= 0) {
        sylar::FdMgr::GetInstance()->get(fd, true);
    }
    return fd;
}

read···（一系列发送与接收）

都是通过do_io来实现的

close（关闭socket）

int close(int fd) {
    if (!sylar::t_hook_enable) {
        return close_f(fd);
    }
	
    sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
    if (ctx) {
        auto iom = sylar::IOManager::GetThis();
        // 取消所有事件
        if (iom) {
            iom->cancelAll(fd);
        }
        // 在文件管理中删除
        sylar::FdMgr::GetInstance()->del(fd);
    }

    return close_f(fd);
}

fcntl（修改文件状态）

对用户反馈是否是用户设置了非阻塞模式

int fcntl(int fd, int cmd, ... /* arg */) {
    va_list va;
    va_start(va, cmd);
    switch (cmd) {
        case F_SETFL:
        {
            int arg = va_arg(va, int);
            va_end(va);
            sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
            if (!ctx || ctx->isClosed()) {
                return fcntl_f(fd, cmd, arg);
            }
            ctx->setUserNonblock(arg & O_NONBLOCK);
            if (ctx->getSysNonblock()) {
                arg |= O_NONBLOCK;
            } else {
                arg &= ~O_NONBLOCK;
            }
            return fcntl_f(fd, cmd, arg);
        }
		.....
        case F_GETFL:
        {
            va_end(va);
            int arg = fcntl_f(fd, cmd);
            sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
            if (!ctx || ctx->isClosed() || !ctx->isSocket()) {
                return arg;
            }
            if (ctx->getUserNonblock()) {
                return arg | O_NONBLOCK;
            } else {
                return arg & ~O_NONBLOCK;
            }
        }
		.....
    }
}

ioctl（对设备进行控制操作）

/*	value为指向int类型的指针，如果该指针指向的值为0，则表示关闭非阻塞模式；如果该指针指向的值为非0，则表示打开非阻塞模式。
 *	int value = 1;
 *	ioctl(fd, FIONBIO, &value);
 * 
 */
int ioctl(int fd, unsigned long request, ...) {
    va_list va;
    va_start(va, request);
    void* arg = va_arg(va, void*);
    va_end(va);
	
    //	FIONBIO用于设置文件描述符的非阻塞模式
    if (FIONBIO == request) {
        bool user_nonblock = !!*(int*)arg;
        sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);
        if (!ctx || ctx->isClosed() || !ctx->isSocket()) {
            return ioctl_f(fd, request, arg);
        }
        ctx->setUserNonblock(user_nonblock);
    }
    return ioctl_f(fd, request, arg);
}

setsockopt（设置socket）

int setsockopt(int sockfd, int level, int optname,
    const void* optval, socklen_t optlen) {
    if (!sylar::t_hook_enable) {
        return setsockopt_f(sockfd, level, optname, optval, optlen);
    }
    // 如果设置socket通用选项
    if (level == SOL_SOCKET) {
        // 如果设置超时选项
        if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO) {
            sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(sockfd);
            if (ctx) {
                const timeval* v = (const timeval*)optval;
                // 转为毫秒保存
                ctx->setTimeout(optname, v->tv_sec * 1000 + v->tv_usec / 1000);
            }
        }
    }
    return setsockopt_f(sockfd, level, optname, optval, optlen);
}

总结

有了hook模块的加持，在使用IO协程调度器时，如果不想该操作导致整个线程的阻塞，我们可以使用scheduler将该任务加入到任务队列中，这样当任务阻塞时，只会使执行该任务的协程挂起，去执行别的任务，在消息来后或者达到超时时间继续执行该协程任务，这样就实现了异步操作。

avatar
文章
阅读
粉丝