sylar高性能服务器-日志(P43-P48)内容记录

文章目录

• • P43：Hook01
  • • 一、HOOK
    • • 定义接口函数指针
      • 获取接口原始地址
      • 二、测试
      • P44-P48：Hook02-06
      • • 一、hook实现基础
        • 二、class FdCtx
        • • 成员变量
          • 构造函数
          • init
          • setTimeout
          • getTimeout
          • 三、class FdManager
          • • 成员变量
            • 构造函数
            • get（获取/创建文件句柄类）
            • del（删除文件句柄类）
            • 四、class hook
            • • do_io（socket操作真正执行体）
              • 定时器
              • do_io
              • sleep系列
              • Socket系列
              • connect系列
              • accept
              • close
              • ioctl（对设备进行控制操作）
              • 五、���试

                P43：Hook01

                sylar封装hook模块的目的就是让一些C标准库提供的同步API可以实现异步的性能。

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

                一、HOOK

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

                定义接口函数指针

                extern "C" {// 重新定义同名的接口// sleep_fun 为函数指针typedef unsigned int (*sleep_fun)(unsigned int seconds);// 它是一个sleep_fun类型的函数指针变量，表示该变量在其他文件中已经定义，我们只是在当前文件中引用它。extern sleep_fun sleep_f;typedef int (*usleep_fun)(useconds_t usec);extern usleep_fun usleep_f;}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::YieldToHold();    return 0;}int usleep(useconds_t usec) {    if(!sylar::t_hook_enable) {        return usleep_f(usec);    }    sylar::Fiber::ptr fiber = sylar::Fiber::GetThis();    sylar::IOManager* iom = sylar::IOManager::GetThis();    iom->addTimer(usec / 1000, std::bind((void(sylar::Scheduler::*)            (sylar::Fiber::ptr, int thread))&sylar::IOManager::schedule            ,iom, fiber, -1));    sylar::Fiber::YieldToHold();    return 0;}

                获取接口原始地址

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

                #define HOOK_FUN(XX) \    XX(sleep) \    XX(usleep)

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

                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}struct _HookIniter {    _HookIniter() {        hook_init();    }};static _HookIniter s_hook_initer;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;}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");

                二、测试

                #include"../sylar/hook.h"#include"../sylar/log.h"#include"../sylar/iomanager.h"sylar::Logger::ptr g_logger = SYLAR_LOG_ROOT();void test_sleep() {    SYLAR_LOG_INFO(g_logger)         sleep(2);        SYLAR_LOG_INFO(g_logger)         sleep(3);        SYLAR_LOG_INFO(g_logger)     test_sleep();    return 0;}    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::YieldToHold();    return 0;}    init();}    // 如果已经初始化直接返回true    if(m_isInit) {        return true;    }    // 默认发送/接收超时时间    m_recvTimeout = -1;    m_sendTimeout = -1;    // 定义一个stat结构体    struct stat fd_stat;    // 通过文件描述符取得文件的状态,返回-1失败    if(-1 == fstat(m_fd, &fd_stat)) {        // 初始化失败并且不是Socket        m_isInit = false;        m_isSocket = false;    } else {        // 初始化成功        m_isInit = true;        // S_ISSOCK (st_mode) 是否为socket         m_isSocket = S_ISSOCK(fd_stat.st_mode);    }    // 如果是socket，则给它设置为阻塞状态    if(m_isSocket) {        // 获取文件的flags        int flags = fcntl_f(m_fd, F_GETFL, 0);        // 判断是否是阻塞的        if(!(flags & O_NONBLOCK)) {            // 不是则设置为阻塞            fcntl_f(m_fd, F_SETFL, flags | O_NONBLOCK);        }        // 阻塞设置生效        m_sysNonblock = true;    } else {        // 不是Socket则不管        m_sysNonblock = false;    }    // 初始化用户没有设置为阻塞    m_userNonblock = false;    // 未关闭    m_isClosed = false;    // 反正初始化状态    return m_isInit;}        dev_t       st_dev;     /* ID of device containing file -文件所在设备的ID*/        ino_t       st_ino;     /* inode number -inode节点号*/      mode_t      st_mode;    /* 文件的类型和存取的权限*/        nlink_t     st_nlink;   /* number of hard links -链向此文件的连接数(硬连接)*/        uid_t       st_uid;     /* user ID of owner -user id*/        gid_t       st_gid;     /* group ID of owner - group id*/        dev_t       st_rdev;    /* device ID (if special file) -设备号，针对设备文件*/        off_t       st_size;    /* total size, in bytes -文件大小，字节为单位*/        blksize_t   st_blksize; /* blocksize for filesystem I/O -系统块的大小*/        blkcnt_t    st_blocks;  /* number of blocks allocated -文件所占块数*/        time_t      st_atime;   /* time of last access -最近存取时间*/        time_t      st_mtime;   /* time of last modification -最近修改时间*/        time_t      st_ctime;   /* time of last status change - */    };        // 套接字为设置Socket接收数据的超时时间    if(type == SO_RCVTIMEO) {        m_recvTimeout = v;    } else {        m_sendTimeout = v;    }}    if(type == SO_RCVTIMEO) {        return m_recvTimeout;    } else {        return m_sendTimeout;    }}    m_datas.resize(64);}    RWMutexType::ReadLock lock(m_mutex);    // 表示集合中没有，并且也不自动创建，直接返回空指针    if((int)m_datas.size()         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::ptr ctx(new FdCtx(fd));    m_datas[fd] = ctx;    return ctx;}    RWMutexType::WriteLock lock(m_mutex);    // 没找到直接返回    if((int)m_datas.size()         return;    }    // 删除    m_datas[fd].reset();}    int cancelled = 0;};    // 非hook直接返回原接口    if(!sylar::t_hook_enable) {        /* 可以将传入的可变参数args以原始类型的方式传递给函数fun。         * 这样做的好处是可以避免不必要的类型转换和拷贝，提高代码的效率和性能。*/        return fun(fd, std::forward        return fun(fd, std::forward        // #defineEBADF 9/* Bad file number */        errno = EBADF;        return -1;    }    // 如果不是Socket或者用户设置了非阻塞，仍然调原接口    if(!ctx-isSocket() || ctx-getUserNonblock()) {        return fun(fd, std::forward(args)...);    }    // ------ hook要做了 ------异步IO    // 获得超时时间    uint64_t to = ctx->getTimeout(timeout_so);    // 设置超时条件    std::shared_ptr tinfo(new timer_info);retry:    // 先执行fun 读数据或写数据 若函数返回值有效就直接返回    // std::forward 是一个 C++11 中的模板函数，其主要作用是在模板函数或模板类中，    // 将一个参数以“原样”（forward）的方式转发给另一个函数    ssize_t n = fun(fd, std::forward(args)...);    // 若中断则重试    // #defineEINTR 4/* Interrupted system call */    while(n == -1 && errno == EINTR) {        n = fun(fd, std::forward(args)...);    }    // 重试    // #defineEAGAIN11/* Try again */    if(n == -1 && errno == EAGAIN) {        // 获得当前IO调度器        sylar::IOManager* iom = sylar::IOManager::GetThis();        // 定时器        sylar::Timer::ptr timer;        // tinfo的弱指针，可以判断tinfo是否已经销毁        std::weak_ptr winfo(tinfo);        // 设置了超时时间        if(to != (uint64_t)-1) {            // 添加条件定时器            // to时间到了消息还没来就触发callback            timer = iom->addConditionTimer(to, [winfo, fd, iom, event]() {                auto t = winfo.lock();                // 定时器失效                if(!t || t->cancelled) {                    return;                }                // 没错误的话设置为超时而失败                // #defineETIMEDOUT110/* Connection timed out */                t->cancelled = ETIMEDOUT;                // 取消事件强制唤醒                iom->cancelEvent(fd, (sylar::IOManager::Event)(event));            }, winfo);        }        // 默认cb为空，任务执行当前协程        int rt = iom->addEvent(fd, (sylar::IOManager::Event)(event));        // addEvent失败， 取消上面加的定时器        if(rt) {            SYLAR_LOG_ERROR(g_logger)                 timer-cancel();            }            return -1;        } else {            /*addEvent成功，把执行时间让出来             *只有两种情况会从这回来：             * 1) 超时了， timer cancelEvent triggerEvent会唤醒回来             * 2) addEvent数据回来了会唤醒回来             */            SYLAR_LOG_DEBUG(g_logger)                 timer-cancel();            }            // 从定时任务唤醒，超时失败            if(tinfo-cancelled) {                errno = tinfo-cancelled;                return -1;            }            // 数据来了就直接重新去操作            goto retry;        }    }    return n;}    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;}    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;}    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;    // 失败 #defineEINPROGRESS115/* Operation now in progress */    } else if(n != -1 || errno != EINPROGRESS) {        return n;    }    sylar::IOManager* iom = sylar::IOManager::GetThis();    sylar::Timer::ptr timer;    std::shared_ptr tinfo(new timer_info);    std::weak_ptr 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) {        /* 只有两种情况唤醒：         * 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(g_logger)         return -1;    }    // 没有错误，连接成功    if(!error) {        return 0;    } else {        errno = error;        return -1;    }}    int fd = do_io(s, accept_f, "accept", sylar::IOManager::READ, SO_RCVTIMEO, addr, addrlen);    // 将新创建的连接放到文件管理中    if(fd = 0) {        sylar::FdMgr::GetInstance()-get(fd, true);    }    return 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->isClose() || !ctx->isSocket()) {                    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);            }            break;        case F_GETFL:            {                va_end(va);                int arg = fcntl_f(fd, cmd);                sylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);                if(!ctx || ctx->isClose() || !ctx->isSocket()) {                    return arg;                }                if(ctx->getUserNonblock()) {                    return arg | O_NONBLOCK;                } else {                    return arg & ~O_NONBLOCK;                }            }            break;        case F_DUPFD:        case F_DUPFD_CLOEXEC:        case F_SETFD:        case F_SETOWN:        case F_SETSIG:        case F_SETLEASE:        case F_NOTIFY:#ifdef F_SETPIPE_SZ        case F_SETPIPE_SZ:#endif            {                int arg = va_arg(va, int);                va_end(va);                return fcntl_f(fd, cmd, arg);             }            break;        case F_GETFD:        case F_GETOWN:        case F_GETSIG:        case F_GETLEASE:#ifdef F_GETPIPE_SZ        case F_GETPIPE_SZ:#endif            {                va_end(va);                return fcntl_f(fd, cmd);            }            break;        case F_SETLK:        case F_SETLKW:        case F_GETLK:            {                struct flock* arg = va_arg(va, struct flock*);                va_end(va);                return fcntl_f(fd, cmd, arg);            }            break;        case F_GETOWN_EX:        case F_SETOWN_EX:            {                struct f_owner_exlock* arg = va_arg(va, struct f_owner_exlock*);                va_end(va);                return fcntl_f(fd, cmd, arg);            }            break;        default:            va_end(va);            return fcntl_f(fd, cmd);    }}

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

                int ioctl(int d, unsigned long int 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(d);        if(!ctx || ctx->isClose() || !ctx->isSocket()) {            return ioctl_f(d, request, arg);        }        ctx->setUserNonblock(user_nonblock);    }    return ioctl_f(d, 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);}

                五、测试

                代码

                    int sock = socket(AF_INET, SOCK_STREAM, 0);    sockaddr_in addr;    memset(&addr, 0, sizeof(addr));    addr.sin_family = AF_INET;    addr.sin_port = htons(80);    inet_pton(AF_INET, "183.2.172.185", &addr.sin_addr.s_addr);    SYLAR_LOG_INFO(g_logger)         return;    }    // 发送消息    const char data[] = "GET / HTTP/1.0\r\n\r\n";    rt = send(sock,data,sizeof(data), 0);    SYLAR_LOG_INFO(g_logger)         return;    }    // 接收消息    std::string buff;    buff.resize(4096);    rt = recv(sock, &buff[0], buff.size(), 0);    SYLAR_LOG_INFO(g_logger)         return;    }    buff.resize(rt);    SYLAR_LOG_INFO(g_logger)