libevent源码学习（三）信号evsignal

本是古典何须时尚 2022-06-16 13:38 446阅读 0赞

# libevent的信号处理 #

libevent如何做signal的集成其实很简单，使用strace工具就可以很容易知道：

比如，用`alarm`产生一个定时器信号，然后使用`libevent`的`sigal`的接口对其进行捕获，最终进入回调函数

#include <stdio.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <assert.h>
    #include <unistd.h>
    #include <signal.h>
    
    #include <event2/event.h>
    #include <event2/bufferevent.h>
    
    void sig_cb(evutil_socket_t fd,short event,void *arg)
    {
        printf("In signal event callback\r\n");
        struct event_base * base = (struct event_base *)arg;
        event_base_loopbreak(base);
    
    }
    
    int main(int argc,char **argv)
    {
        struct event_base* base=event_base_new();
        assert(base!=NULL);
        struct event* ev=evsignal_new(base,
            (evutil_socket_t)SIGALRM,
            sig_cb,
            base);
        evsignal_add(ev,NULL);//在event_add函数中，通过ev->base获取event_base对象
        alarm(5);
        event_base_dispatch(base);
        printf("exit...\r\n");
        return 0;
    }

`strace ./alarm` 发现会创建socketpair：

socketpair(PF_LOCAL, SOCK_STREAM, 0, [4, 5]) = 0

当信号发生时，会sendto一个消息，从而使得fd可读，epoll返回：

sendto(4, "\16", 1, 0, NULL, 0)         = 1
    rt_sigreturn()                          = -1 EINTR (Interrupted system call)
    epoll_wait(3, {
       {EPOLLIN, {u32=5, u64=5}}}, 32, -1) = 1
    recvfrom(5, "\16", 1024, 0, NULL, NULL) = 1

## 相关接口 ##

信号本质上来说，是`libevent`事件中的子集，因此是兼容event的api的，不过为了清晰，内部还是进行了简单的封装，其实就是宏：

#define evsignal_add(ev, tv)        event_add((ev), (tv))
    
    #define evsignal_assign(ev, b, x, cb, arg)          \
        event_assign((ev), (b), (x), EV_SIGNAL|EV_PERSIST, cb, (arg))
    
    #define evsignal_new(b, x, cb, arg)             \
        event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
    
    #define evsignal_del(ev)        event_del(ev)
    
    #define evsignal_pending(ev, tv)    event_pending((ev), EV_SIGNAL, (tv))
    
    #define evsignal_initialized(ev)    event_initialized(ev)

## socketpair ##

跟匿名管道pipe类似，不过socketpair能做到全双工。例如在父子进程之间进行全双共的通信，需要两次pipe，而只需要一次socketpair

#include <stdio.h>
    #include <errno.h>
    #include <string.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    
    int main()
    {
        int sv[2]={
       0,0};
        int sock=socketpair(AF_LOCAL,SOCK_STREAM,0,sv);
    
        if(sock<0)
        {
        perror("socketpair");
        exit(0);
        }
    
        pid_t id=fork();
        char buf[1024];
        if(id<0)
        {
        perror("fork");
        exit(0);
        }
        else if(id==0)
        {
        close(sv[0]);  //子进程关闭读端
        while(1)
        {
            memset(buf,'\0',sizeof(buf));
            strcpy(buf,"i am your child");
            write(sv[1],buf,strlen(buf));//子进程写入
            memset(buf,'\0',sizeof(buf));
            ssize_t _s=read(sv[1],buf,sizeof(buf)-1);//子进程读取父进程的内容
            buf[_s]='\0';
            printf("father-->child:%s\n",buf);
            sleep(1);
        }
        close(sv[1]);//子进程关闭读端
        }
        else
        {
       //父进程
        close(sv[1]);
        while(1)
        {
            memset(buf,'\0',sizeof(buf));
            ssize_t _s=read(sv[0],buf,sizeof(buf)-1);                                                                                                               
            buf[_s]='\0';
            printf("child-->father:%s\n",buf);
            memset(buf,'\0',sizeof(buf));
            strcpy(buf,"i am your father");
            write(sv[0],buf,strlen(buf));
            sleep(1);
        }
        close(sv[0]);
        }
        return 0;
    }

## libevent的集成策略 ##

### **1.创建socketpair** ###

刚提到，使用socketpair来做，libevent中也对socketpair的调用做了一些封装，比如说：

int
    evutil_socketpair(int family, int type, int protocol, evutil_socket_t fd[2])
    {
        return socketpair(family, type, protocol, fd);
    }

### **2.通知event\_base** ###

我们需要注册一个socket pair的读socket在libevent的event\_base实例中，这样，当向写socket写入数据时，读socket就会可读，event\_base就返回了。

假设现在我们有fd0和fd1分别表示socketpair的两个套接字描述符，那么需要做的事就是将fd1添加到event\_base中，将fd0放进信号处理函数里面，  
当异步信号到来的时候，在sigfunction中向fd0发送一个uint64的字段。

从代码中来看看：

struct event_base
    {
    
    //...
        const struct eventop *evsigsel;
        /** Data to implement the common signal handelr code. */
        struct evsig_info sig;
        //...
    }

在event\_base中有这样两个关键成员，`struct eventop`之前到过，里面封装了一系列回调函数，对应的实现在`signal.c`中（只需要实现add和del）

`struct evsig_info sig`是个复杂的结构体：

struct evsig_info {
        struct event ev_signal;//将读fd注册到event_base中需要的结构提
    
        evutil_socket_t ev_signal_pair[2]; //socketpair
    
        int ev_signal_added;//是否已经注册标志
    
        //...
    };

### **3.初始化** ###

以`epoll`为例，当我们选择epoll作为底层实现时，需要实现`init`回调（epoll\_init）,在这个回调中，我们完成对signal的初始化：

static void *epoll_init()
    {
        //...
        evsig_init()
        //...
    }

进入`evsig_init()`中就找到了`socketpair`的初始化：  
创建两个描述符fd0、fd1的同时，将fd1与`struct event`关联起来，并添加到event\_base中

evsig_init(struct event_base *base)
    {
        /*
         * Our signal handler is going to write to one end of the socket
         * pair to wake up our event loop.  The event loop then scans for
         * signals that got delivered.
         */
        if (evutil_socketpair(
                AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) {
            event_sock_err(1, -1, "%s: socketpair", __func__);
    #endif
            return -1;
        }
    
        evutil_make_socket_closeonexec(base->sig.ev_signal_pair[0]);
        evutil_make_socket_closeonexec(base->sig.ev_signal_pair[1]);
        base->sig.sh_old = NULL;
        base->sig.sh_old_max = 0;
    
        evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);
        evutil_make_socket_nonblocking(base->sig.ev_signal_pair[1]);
    
        event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[1],
            EV_READ | EV_PERSIST, evsig_cb, base);
    
        base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;
        event_priority_set(&base->sig.ev_signal, 0);
    
        base->evsigsel = &evsigops;
    
        return 0;
    }

### **4.signal handler** ###

现在，当我们添加一个signal事件时，将调用回调：

base->evsignal->add();

最后进入绑定的add回调函数`evsig_add`中，而这个函数里面有一个关键的内部函数：

int
    _evsig_set_handler(struct event_base *base,
        int evsignal, void (__cdecl *handler)(int))
    {
    
    //...
    #ifdef _EVENT_HAVE_SIGACTION
        memset(&sa, 0, sizeof(sa));
        sa.sa_handler = handler;
        sa.sa_flags |= SA_RESTART;
        sigfillset(&sa.sa_mask);
    
        if (sigaction(evsignal, &sa, sig->sh_old[evsignal]) == -1) {
            event_warn("sigaction");
            mm_free(sig->sh_old[evsignal]);
            sig->sh_old[evsignal] = NULL;
            return (-1);
        }
    #else
        if ((sh = signal(evsignal, handler)) == SIG_ERR) {
            event_warn("signal");
            mm_free(sig->sh_old[evsignal]);
            sig->sh_old[evsignal] = NULL;
            return (-1);
        }
        *sig->sh_old[evsignal] = sh;
    #endif
    
        return (0);
    }

提供了`signal`和`sigaction`两种方式，不够都指向了同一个handler，进入发现，跟我们想象的一样：

static void __cdecl
    evsig_handler(int sig)
    {
        int save_errno = errno;
    #ifdef WIN32
        int socket_errno = EVUTIL_SOCKET_ERROR();
    #endif
        ev_uint8_t msg;
    
        if (evsig_base == NULL) {
            event_warnx(
                "%s: received signal %d, but have no base configured",
                __func__, sig);
            return;
        }
    
    #ifndef _EVENT_HAVE_SIGACTION
        signal(sig, evsig_handler);//重新绑定handler
    #endif
    
        /* Wake up our notification mechanism */
        msg = sig;
        send(evsig_base_fd, (char*)&msg, 1, 0);//发送一个字节使得fd1可读
        errno = save_errno;
    #ifdef WIN32
        EVUTIL_SET_SOCKET_ERROR(socket_errno);
    #endif
    }