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

2024-02-29 18:44

本文主要是介绍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可以实现异步的性能。

hookAPI封装成一个与原始系统调用同名的接口,在调用这个接口时,先实现一些别的操作,然后在调用原始的系统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) << "start()_HY";sylar::IOManager iom(1);iom.schedule([](){sleep(2);SYLAR_LOG_INFO(g_logger) << "sleep 2";});iom.schedule([](){sleep(3);SYLAR_LOG_INFO(g_logger) << "sleep 3";});SYLAR_LOG_INFO(g_logger) << "test_sleep";
}int main(int argc, char** argv) {test_sleep();return 0;
}

上面测试用例通过IOManager进行两次调度,第一个任务睡眠2s,第二个任务睡眠3s

不开启hook

在不开启hook的情况下,两个任务必须按着顺序执行,也就是一共需要5s时间

image-20240226193319313

开启hook

在执行hook情况下,第一个任务在执行sleep时就添加一个2s的定时器,利用回调函数去调度本协程,然后让协程让出执行权去处理第二个任务,这样完成两个任务一共只需要3s,通过hook让只能同步的sleep实现了异步的效果

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;}

image-20240226193645237

P44-P48:Hook02-06

以下记录参考博客链接

一、hook实现基础

​ 通过动态库的全局符号介入,使用自定义的接口替换掉同名的系统调用接口。

​ 系统调用接口基本上是由C标准函数库libc提供,所以这里要做的事情就是用自定义的动态库来覆盖掉libc中的同名符号。

​ 由于动态库的全局符号介入问题,全局符号表只会记录第一次识别到的符号,后续的同名符号都被忽略,但这并不表示同名符号所在的动态库完全不会加载,因为有可能其他的符号会用到。

​ 以libc库举例,如果用户在链接libc库之前链接了一个指定的库,并且在这个库里实现了read/write接口,那么在程序运行时,程序调用的read/write接口就是指定库里的,而不是libc库里的。libc库仍然会被加载,因为libc库是程序的运行时库,程序不可能不依赖libc里的其他接口。因为libc库也被加载了,所以,通过一定的手段,仍然可以从libc中拿到属于libcread/write接口,这就为hook创建了条件。程序可以定义自己的read/write接口,在接口内部先实现一些相关的操作,然后再调用libc里的read/write接口。(写得真清楚!)

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

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

二、class FdCtx

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

成员变量
// 是否初始化
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;
sylar::IOManager* m_iomanager;
构造函数
// 构造函数
FdCtx::FdCtx(int fd): m_isInit(false), m_isSocket(false), m_sysNonblock(false), m_userNonblock(false), m_isClosed(false), m_fd(fd), m_recvTimeout(-1), m_sendTimeout(-1) {init();
}
init
// 初始化
bool FdCtx::init() {// 如果已经初始化直接返回trueif(m_isInit) {return true;}// 默认发送/接收超时时间m_recvTimeout = -1;m_sendTimeout = -1;// 定义一个stat结构体struct stat fd_stat;// 通过文件描述符取得文件的状态,返回-1失败if(-1 == fstat(m_fd, &fd_stat)) {// 初始化失败并且不是Socketm_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) {// 获取文件的flagsint 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;
}

strcut stat

struct stat    
{    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 - */    
};    

fstat

通过文件描述符取得文件的状态

int fstat (int __fd, struct stat *__buf)
setTimeout
// 设置超时时间
void FdCtx::setTimeout(int type, uint64_t v) {// 套接字为设置Socket接收数据的超时时间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

成员变量
// 读写锁
RWMutexType m_mutex;
// 文件句柄集合
std::vector<FdCtx::ptr> m_datas;
构造函数
// 构造函数
FdManager::FdManager() {m_datas.resize(64);
}
get(获取/创建文件句柄类)
// 获取/创建文件句柄类
FdCtx::ptr FdManager::get(int fd, bool auto_create) {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::ptr ctx(new FdCtx(fd));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();
}

四、class hook

这里补充一些函数方法

do_io(socket操作真正执行体)

流程

  • 先进行一系列判断,是否按原函数执行。

  • 执行原始函数进行操作,若errno = EINTR,则为系统中断,应该不断重新尝试操作。

  • errno = EAGIN,系统已经隐式的将socket设置为非阻塞模式,此时资源咱不可用。

  • 若设置了超时时间,则设置一个执行周期为超时时间的条件定时器,它保证若在超时之前数据就已经来了,然后操作完do_io执行完毕,智能指针tinfo已经销毁了,但是定时器还在,此时弱指针拿到的就是个空指针,将不会执行定时器的回调函数。

  • 在条件定时器的回调函数中设置错误为ETIMEDOUT超时,并且使用cancelEvent强制执行该任务,继续回到该协程执行。

  • 通过addEvent添加事件,若添加事件失败,则将条件定时器删除并返回错误。成功则让出协程执行权。

  • 只有两种情况协程会被拉起: a. 超时了,通过定时器回调函数 cancelEvent ---> triggerEvent会唤醒回来 b. addEvent数据回来了会唤醒回来

  • 将定时器取消,若为超时则返回-1并设置errno = ETIMEDOUT,并返回-1。

  • 若为数据来了则retry,重新操作。

定时器
// 定时器超时条件
struct timer_info {int cancelled = 0;
};
do_io

/*

* 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::t_hook_enable) {/* 可以将传入的可变参数args以原始类型的方式传递给函数fun。* 这样做的好处是可以避免不必要的类型转换和拷贝,提高代码的效率和性能。*/return fun(fd, std::forward<Args>(args)...);}// 通过文件句柄获得对应的FdCtxsylar::FdCtx::ptr ctx = sylar::FdMgr::GetInstance()->get(fd);// 没有文件调原接口if(!ctx) {return fun(fd, std::forward<Args>(args)...);}// 如果句柄已经关闭if(ctx->isClose()) {// #define	EBADF		 9	/* Bad file number */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 读数据或写数据 若函数返回值有效就直接返回// std::forward 是一个 C++11 中的模板函数,其主要作用是在模板函数或模板类中,// 将一个参数以“原样”(forward)的方式转发给另一个函数ssize_t n = fun(fd, std::forward<Args>(args)...);// 若中断则重试// #define	EINTR		 4	/* Interrupted system call */while(n == -1 && errno == EINTR) {n = fun(fd, std::forward<Args>(args)...);}// 重试// #define	EAGAIN		11	/* Try again */if(n == -1 && errno == EAGAIN) {// 获得当前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时间到了消息还没来就触发callbacktimer = iom->addConditionTimer(to, [winfo, fd, iom, event]() {auto t = winfo.lock();// 定时器失效if(!t || t->cancelled) {return;}// 没错误的话设置为超时而失败// #define	ETIMEDOUT	110	/* 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) << hook_fun_name << " addEvent("<< fd << ", " << event << ")";if(timer) {timer->cancel();}return -1;} else {/*	addEvent成功,把执行时间让出来*	只有两种情况会从这回来:* 	1) 超时了, timer cancelEvent triggerEvent会唤醒回来* 	2) addEvent数据回来了会唤醒回来 */SYLAR_LOG_DEBUG(g_logger) << "do_io <" << hook_fun_name << ">";sylar::Fiber::YieldToHold();SYLAR_LOG_DEBUG(g_logger) << "do_io <" << hook_fun_name << ">";if(timer) {timer->cancel();}// 从定时任务唤醒,超时失败if(tinfo->cancelled) {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系列
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系列
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;// 失败 #define	EINPROGRESS	115	/* 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<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) {/* 	只有两种情况唤醒:* 	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) << "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 s, struct sockaddr *addr, socklen_t *addrlen) {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;
}
close
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->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_SZcase 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_SZcase 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) << "begin connect";int rt = connect(sock, (const sockaddr*)&addr, sizeof(addr));SYLAR_LOG_INFO(g_logger) << "connect rt = " << " errno = " << errno;if(rt) {return;}// 发送消息const char data[] = "GET / HTTP/1.0\r\n\r\n";rt = send(sock,data,sizeof(data), 0);SYLAR_LOG_INFO(g_logger) << "send rt = " << rt << " error = " << errno;if(rt <= 0) {return;}// 接收消息std::string buff;buff.resize(4096);rt = recv(sock, &buff[0], buff.size(), 0);SYLAR_LOG_INFO(g_logger) << "recv rt = " << rt << " errno = " << errno;if(rt <= 0) {return;}buff.resize(rt);SYLAR_LOG_INFO(g_logger) << buff;}

结果

image-20240228165004953

这篇关于sylar高性能服务器-日志(P43-P48)内容记录的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/759699

相关文章

Spring Boot 配置文件之类型、加载顺序与最佳实践记录

《SpringBoot配置文件之类型、加载顺序与最佳实践记录》SpringBoot的配置文件是灵活且强大的工具,通过合理的配置管理,可以让应用开发和部署更加高效,无论是简单的属性配置,还是复杂... 目录Spring Boot 配置文件详解一、Spring Boot 配置文件类型1.1 applicatio

SpringBoot日志配置SLF4J和Logback的方法实现

《SpringBoot日志配置SLF4J和Logback的方法实现》日志记录是不可或缺的一部分,本文主要介绍了SpringBoot日志配置SLF4J和Logback的方法实现,文中通过示例代码介绍的非... 目录一、前言二、案例一:初识日志三、案例二:使用Lombok输出日志四、案例三:配置Logback一

golang 日志log与logrus示例详解

《golang日志log与logrus示例详解》log是Go语言标准库中一个简单的日志库,本文给大家介绍golang日志log与logrus示例详解,感兴趣的朋友一起看看吧... 目录一、Go 标准库 log 详解1. 功能特点2. 常用函数3. 示例代码4. 优势和局限二、第三方库 logrus 详解1.

MySQL INSERT语句实现当记录不存在时插入的几种方法

《MySQLINSERT语句实现当记录不存在时插入的几种方法》MySQL的INSERT语句是用于向数据库表中插入新记录的关键命令,下面:本文主要介绍MySQLINSERT语句实现当记录不存在时... 目录使用 INSERT IGNORE使用 ON DUPLICATE KEY UPDATE使用 REPLACE

Python 中的异步与同步深度解析(实践记录)

《Python中的异步与同步深度解析(实践记录)》在Python编程世界里,异步和同步的概念是理解程序执行流程和性能优化的关键,这篇文章将带你深入了解它们的差异,以及阻塞和非阻塞的特性,同时通过实际... 目录python中的异步与同步:深度解析与实践异步与同步的定义异步同步阻塞与非阻塞的概念阻塞非阻塞同步

Python Dash框架在数据可视化仪表板中的应用与实践记录

《PythonDash框架在数据可视化仪表板中的应用与实践记录》Python的PlotlyDash库提供了一种简便且强大的方式来构建和展示互动式数据仪表板,本篇文章将深入探讨如何使用Dash设计一... 目录python Dash框架在数据可视化仪表板中的应用与实践1. 什么是Plotly Dash?1.1

使用Python实现获取网页指定内容

《使用Python实现获取网页指定内容》在当今互联网时代,网页数据抓取是一项非常重要的技能,本文将带你从零开始学习如何使用Python获取网页中的指定内容,希望对大家有所帮助... 目录引言1. 网页抓取的基本概念2. python中的网页抓取库3. 安装必要的库4. 发送HTTP请求并获取网页内容5. 解

如何自定义Nginx JSON日志格式配置

《如何自定义NginxJSON日志格式配置》Nginx作为最流行的Web服务器之一,其灵活的日志配置能力允许我们根据需求定制日志格式,本文将详细介绍如何配置Nginx以JSON格式记录访问日志,这种... 目录前言为什么选择jsON格式日志?配置步骤详解1. 安装Nginx服务2. 自定义JSON日志格式各

CentOS 7部署主域名服务器 DNS的方法

《CentOS7部署主域名服务器DNS的方法》文章详细介绍了在CentOS7上部署主域名服务器DNS的步骤,包括安装BIND服务、配置DNS服务、添加域名区域、创建区域文件、配置反向解析、检查配置... 目录1. 安装 BIND 服务和工具2.  配置 BIND 服务3 . 添加你的域名区域配置4.创建区域

Python实现常用文本内容提取

《Python实现常用文本内容提取》在日常工作和学习中,我们经常需要从PDF、Word文档中提取文本,本文将介绍如何使用Python编写一个文本内容提取工具,有需要的小伙伴可以参考下... 目录一、引言二、文本内容提取的原理三、文本内容提取的设计四、文本内容提取的实现五、完整代码示例一、引言在日常工作和学