Sylar C++高性能服务器学习记录16 【HOOK模块-代码分析篇】

早在19年5月就在某站上看到sylar的视频了，一直认为这是一个非常不错的视频。
由于本人一直是自学编程，基础不扎实，也没有任何人的督促，没能坚持下去。
每每想起倍感惋惜，遂提笔再续前缘。

为了能更好的看懂sylar，本套笔记会分两步走，每个系统都会分为两篇博客。
分别是【知识储备篇】和【代码分析篇】
(ps:纯粹做笔记的形式给自己记录下，欢迎大家评论，不足之处请多多赐教)
QQ交流群：957100923
B站视频：https://b23.tv/YusP39I

---

HOOK模块-代码分析篇

一、HOOK模块的必要性

首先我们已经完成了之前的一系列功能：
线程模块->协程模块->协程调度模块->IO协程调度模块->定时器模块
这些模块逐层递进，有这些模块的支撑后我们已经完全可以用同步的方式写出异步的功能了。
并且由于多线程和多协程的支持配合epoll，我们的CPU利用率已经很高了。

其实我们就算没有HOOK模块也能完成所有的功能了。
但是有些系统函数我们使用率比较高，但是本身不支持异步操作，比如sleep等函数，sleep函数的使用会霸占整个线程导致阻塞。

虽然我们可以用之前的定时器模块来替代他，但是使用方式(语法)上我们更倾向于使用sleep这样的系统函数。
因为使用的习惯，并且作为服务器开发的基础知识，这一部分的函数大部分程序员都比较熟悉。

如果我们使用定时器模块，那么这会有一定的学习成本。

所以我们可以用HOOK的方式来对系统函数进行封装，
使其可以用原有的函数原型来实现 【用同步的写法实现异步的功能】。

---

二、需要被HOOK的系统函数

我们知道，系统函数有很多，难道我们要全部HOOK一遍吗？那是不现实也是不必要的！以下是Sylar总结的几个系统函数，我们列一下：

//====sleep相关====//

//sleep函数用于让进程休眠指定的秒数，适用于需要较长时间的休眠场景；
sleep(unsigned int seconds);

//usleep函数用于让进程休眠指定的微秒数，适用于需要较短时间的休眠场景，不精确；
usleep_fun(useconds_t usec);

//nanosleep函数用于让进程休眠指定的纳秒数，适用于需要纳秒级的休眠场景，不精确（因为这种级别会因为系统调度和其他因素而有所不同）；
nanosleep_fun(const struct timespec *req, struct timespec *rem);


//====socket相关====//

//该函数用来创建一个套接字，并返回一个描述符，该描述符可以用来访问该套接字
socket(int domain, int type, int protocol);

//该系统调用用来让客户程序通过在一个未命名套接字和服务器监听套接字之间建立连接的方法来连接到服务器
connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

//该系统调用用来等待客户建立对该套接字的连接。
//accept系统调用只有当客户程序试图连接到由socket参数指定的套接字上时才返回，
//也就是说，如果套接字队列中没有未处理的连接，accept将阻塞直到有客户建立连接为止。
//accept函数将创建一个新套接字来与该客户进行通信，并且返回新套接字的描述符，
//新套接字的类型和服务器监听套接字类型是一样的。
accept(int s, struct sockaddr *addr, socklen_t *addrlen);


//====read相关====/

//从文件描述符（包括TCP Socket）中读取数据，并将读取的数据存储到指定的缓冲区中。
ssize_t read(int fd, void *buf, size_t count);

//主要用于文件I/O操作，从文件描述符读取数据到多个缓冲区中
ssize_t readv(int fd, const struct iovec *iov, int iovcnt);


//====recv相关====//

//用于从套接字接收数据，并提供了额外的Flags参数来控制特殊行为
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

//用于接收来自套接字（socket）的数据，并且适用于面向无连接的协议，如 UDP（用户数据报协议）。
//recvfrom 允许程序接收数据同时获取数据发送方的地址信息。
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);

//提供了更为复杂和灵活的功能，支持分散/聚集I/O和更多的控制选项。
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);


//====write相关====//

//用于向任意文件描述符中写入(读取)数据，用作socket发送数据时，只能向已经建立连接的文件描述符中写入(读取)数据
ssize_t write(int fd, const void *buf, size_t count);

//向任意文件描述符中写入多个缓冲区的数据，readv用于从任意描述符中向多个缓冲区读取数据，
//用作socket发送数据时，只能向已经建立连接的文件描述符中写入(读取)数据
ssize_t writev(int fd, const struct iovec *iov, int iovcnt);


//====send相关====//

//用于向socket中写入(读取)数据，只能用于已经建立连接的socket上，udp也可以调用connect建立连接
ssize_t send(int s, const void *msg, size_t len, int flags);

//用于向socket中写入(读取)数据，如果用在已经建立连接的socket上，需要忽略其地址和地址长度参数，
//即地址指针设置为NULL，地址长度设置为0；如udp，如果不调用connec建立连接，则需要指定地址参数，
//如果调用connect建立了连接，则省略地址参数
ssize_t sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);

//用于向socket文件描述符中写入多个缓冲区的数据，
//用于向多个缓冲区读取socket文件描述符中的数据，发送(接收)前需要构造msghdr消息头
ssize_t sendmsg(int s, const struct msghdr *msg, int flags);


//====close相关====//

//一个套接字的默认行为是把套接字标记为已关闭，然后立即返回到调用进程，该套接字描述符不能再由调用进程使用，
//也就是说它不能再作为read或write的第一个参数，然而TCP将尝试发送已排队等待发送到对端，
//发送完毕后发生的是正常的TCP连接终止序列
close(int fd);


//====ctl相关====//

//可以用于对已打开的文件描述符进行各种控制操作，包括复制、设置标志、非阻塞操作等
//主要用于对文件描述符进行操作和控制
//复制文件描述符：使用F_DUPFD或F_DUPFD_CLOEXEC参数。
//设置文件状态标志：使用F_SETFL参数，如设置非阻塞模式O_NONBLOCK。
//获取/设置记录锁：使用F_GETLK、F_SETLK或F_SETLKW参数。
//获取/设置异步I/O所有权：使用F_GETOWN、F_SETOWN参数。
int fcntl(int fd, int cmd, ... /* arg */ );

//它可用于对设备驱动程序进行各种控制操作，具体行为由命令码指定。每个设备都有自己特定的ioctl命令
//主要用于对设备进行操作和控制。
//设置设备参数和配置信息：比如串口通信波特率、终端窗口大小等。
//控制设备行为和状态：比如打开/关闭终端回显、启动/停止输入输出等。
//传输数据到底层硬件：比如发送控制指令、读取传感器数据等。
int ioctl(int d, unsigned long int request, ...);


//====sockopt相关====//

//用于任意类型、任意状态套接口的设置选项值.
//sockfd：标识一个套接口的描述字;
//level：选项定义的层次；支持SOL_SOCKET、IPPROTO_TCP;
//optname：需获取的套接口选项;
//optval：指针，指向存放所获得选项值的缓冲区;
//optlen：指针，指向optval缓冲区的长度值;
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);

//用于获取任意类型、任意状态套接口的选项当前值，并把结果存入optval
//sockfd：一个标识套接口的描述字。
//level：选项定义的级别。例如，支持的级别有SOL_SOCKET、IPPROTO_TCP等。
//optname：需获取的套接口选项。
//optval：指针，指向存放所获得选项值的缓冲区。
//optlen：指针，指向optval缓冲区的长度值。
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

//====自定义相关====//

//链接超时设置
int connect_with_timeout(int fd, const struct sockaddr* addr, socklen_t addrlen, uint64_t timeout_ms);

---

三、fd socket上下文句柄相关代码

fd上下文 FdCtx

/**文件句柄上下文类*/
class FdCtx : public std::enable_shared_from_this<FdCtx> {
public:
    typedef std::shared_ptr<FdCtx> ptr;
    /**通过文件句柄构造FdCtx*/
    FdCtx(int fd);
    /**析构函数*/
    ~FdCtx();
    ....
private:
    // 是否初始化
    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;
};

fd管理类

/**文件句柄管理类*/
class FdManager {
public:
    typedef RWMutex RWMutexType;
    /**无参构造函数*/
    FdManager();
 
    /**
     * 获取/创建文件句柄类FdCtx
     * @param[in] fd 文件句柄
     * @param[in] auto_create 是否自动创建
     * @return 返回对应文件句柄类FdCtx::ptr
     */
    FdCtx::ptr get(int fd, bool auto_create = false);
 
    /***删除文件句柄*/
    void del(int fd);
private:
    // 读写锁
    RWMutexType m_mutex;
    // 文件句柄集合
    std::vector<FdCtx::ptr> m_datas;
};
 
// 文件句柄单例
typedef Singleton<FdManager> FdMgr;

---

四、Sylar中的HOOK实现（这里有搬运其他博客内容）

关于dlsym大家可以查看 【HOOK模块-知识储备篇】

众所周知Sylar-in十分擅长写宏来简化代码，以下内容截取自zhongluqiang大佬的博客，我认为写的很好。这里套用一下。

接下来是hook的整体实现。首先定义线程局部变量t_hook_enable，用于表示当前线程是否启用hook，使用线程局部变量表示hook模块是线程粒度的，各个线程可单独启用或关闭hook。然后是获取各个被hook的接口的原始地址， 这里要借助dlsym来获取。sylar使用了一套宏来简化编码，这套宏的实现如下：

#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)
 
extern "C" {
#define XX(name) name ## _fun name ## _f = nullptr;
    HOOK_FUN(XX);
#undef XX
}
 
void hook_init() {
    static bool is_inited = false;
    if(is_inited) {
        return;
    }
#define XX(name) name ## _f = (name ## _fun)dlsym(RTLD_NEXT, #name);
    HOOK_FUN(XX);
#undef XX
}

上面的宏展开之后的效果如下：

extern "C" {
    sleep_fun sleep_f = nullptr; \
    usleep_fun usleep_f = nullptr; \
    ....
    setsocketopt_fun setsocket_f = nullptr;
};
 
hook_init() {
    ...
     
    sleep_f = (sleep_fun)dlsym(RTLD_NEXT, "sleep"); \
    usleep_f = (usleep_fun)dlsym(RTLD_NEXT, "usleep"); \
    ...
    setsocketopt_f = (setsocketopt_fun)dlsym(RTLD_NEXT, "setsocketopt");
}

hook_init() 放在一个静态对象的构造函数中调用，这表示在main函数运行之前就会获取各个符号的地址并保存在全局变量中。

最后是各个接口的hook实现，这部分和上面的全局变量定义要放在extern "C"中，以防止C++编译器对符号名称添加修饰。由于被hook的接口要完全模拟原接口的行为，所以这里要小心处理好各种边界情况以及返回值和errno问题。

首先是sleep/usleep/nanosleep的hook实现，它们的实现思路完全一样，即先添加定时器再yield，比如sleep函数的hook代码如下：

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();
    iom->addTimer(seconds * 1000, std::bind((void(sylar::Scheduler::*)
            (sylar::Fiber::ptr, int thread))&sylar::IOManager::schedule
            ,iom, fiber, -1));
    sylar::Fiber::GetThis()->yield();
    return 0;
}

接下来是socket接口的hook实现，socket用于创建套接字，需要在拿到fd后将其添加到FdManager中，代码实现如下：

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;
    }
    sylar::FdMgr::GetInstance()->get(fd, true);
    return fd;
}

接下来是connect和connect_with_timeout的实现，由于connect有默认的超时，所以这里只需要实现connect_with_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->isClose()) {
        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;
    } 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, [winfo, fd, iom]() {
                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) {
        sylar::Fiber::GetThis()->yield();
        if(timer) {
            timer->cancel();
        }
        if(tinfo->cancelled) {
            errno = tinfo->cancelled;
            return -1;
        }
    } else {
        if(timer) {
            timer->cancel();
        }
        SYLAR_LOG_ERROR(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;
    }
}

上面的实现重点如下：

1. 判断传入的fd是否为套接字，如果不为套接字，则调用系统的connect函数并返回。
2. 判断fd是否被显式设置为了非阻塞模式，如果是则调用系统的connect函数并返回。
3. 调用系统的connect函数，由于套接字是非阻塞的，这里会直接返回EINPROGRESS错误。
4. 如果超时参数有效，则添加一个条件定时器，在定时时间到后通过t->cancelled设置超时标志并触发一次WRITE事件。
   5, 添加WRITE事件并yield，等待WRITE事件触发再往下执行。
5. 等待超时或套接字可写，如果先超时，则条件变量winfo仍然有效，通过winfo来设置超时标志并触发WRITE事件，协程从yield点返回，返回之后通过超时标志设置errno并返回-1；如果在未超时之前套接字就可写了，那么直接取消定时器并返回成功。取消定时器会导致定时器回调被强制执行一次，但这并不会导致问题，因为只有当前协程结束后，定时器回调才会在接下来被调度，由于定时器回调被执行时connect_with_timeout协程已经执行完了，所以理所当然地条件变量也被释放了，所以实际上定时器回调函数什么也没做。这里是sylar条件定时器的巧妙应用，自行体会，感觉说得不是很清楚。

接下来是accept和read/write/recv/send等IO接口的hook实现，这里sylar又一次充分发挥了懒得写代码的本事，用一个do_io模板函数将全部情况都囊括了进来。do_io模板函数的实现与上面的connect_with_timout实现基本一致，都借助了条件定时器和READ/WRITE事件，这里我也懒得写了，自行看代码。

最后是一些边边角角的情况，有以下几个要注意：

1. close，这里除了要删除fd的上下文，还要取消掉fd上的全部事件，这会让fd的读写事件回调都执行一次。
2. fcntl，这里的O_NONBLOCK标志要特殊处理，因为所有参与协程调度的fd都会被设置成非阻塞模式，所以要在应用层维护好用户设置的非阻塞标志。
3. ioctl，同样要特殊处理FIONBIO命令，这个命令用于设置非阻塞，处理方式和上面的fcntl一样。
   setsocketopt，这里要特殊处理SO_RECVTIMEO和SO_SNDTIMEO，在应用层记录套接字的读写超时，方便协程调度器获取。

注意事项
由于定时器模块只支持毫秒级定时，所以被hook后的nanosleep()实际精度只能达到毫秒级，而不是纳秒级。
按照 man 2 socket 的描述，自2.6.27版本的内核开始socket函数支持直接在type中位或SOCK_NONBLOCK标志位以创建非阻塞套接字，sylar的hook模块未处理这种情况。
按sylar hook模块的实现，非调度线程不支持启用hook。

哈哈，请叫我 【大自然的搬运工】
这里在附上 大佬的博客地址，如有侵权请联系本人删除相关内容

---

五、这里提一句

本人在阅读源码的时候看到 fd_manager 的时候有卡住一段时间。
后来换了一种方式来思考，就是千万别拘泥于细节，知道fd_manager是用来维护socket句柄的，相当于一个socket句柄池的管理类即可。
然后 fd_manager 部分源码都不用去细看，抛开那些不必要的干扰项。

本人属于不太聪明的那一类人，如果你也跟我一样，那么我建议你按以下四步来学习
第一遍：迷迷糊糊的把整个项目大致流程全部看完。
第二遍：再来看具体实现细节。
第三遍：带着自己的理解看第三遍。
第四遍：就是自己重写的时候。

本章有点水了，原因是自己也是第一遍，所以想要先迷迷糊糊继续往下。

---

【最后求关注、点赞、转发】
QQ交流群：957100923