Libev源码分析02：Libev中的IO监视器

一：代码流程

        在Libev中，启动一个IO监视器，等待该监视器上的事件触发，然后调用该监视器的回调函数。整个的流程是这样的：

        首先调用ev_default_loop初始化struct  ev_loop结构；

        然后调用ev_io_init初始化监视器中的属性，该宏主要就是调用ev_init和ev_io_set；

        然后调用ev_io_start启动该监视器，该函数主要是将监视器添加到loop->anfds结构中，将监视的描述符添加到((loop)->fdchanges)中；

 

        调用ev_run开始等待事件的触发，该函数中：

        首先会调用fd_reify函数，该函数根据((loop)->fdchanges)中记录的描述符，将该描述符上的事件添加到backend所使用的数据结构中，比如select中的fd_set中；

        然后调用time_update更新当前的时间，如果日历时间被人为调整的话，则相应的调整超时事件和周期事件；

        调用backend_poll开始等待事件的发生，如果事件在规定时间内触发的话，则会调用fd_event将触发的监视器记录到loop->pendings中；

        backend的监听函数（select，poll，epoll_wait）返回之后，首先再次调用time_update更新当前的时间，然后调用ev_invoke_pending，依次处理loop->pendings中的监视器，调用该监视器的回调函数。

 

        以上就是Libev中IO监视器的工作流程，下面详细分析各个函数：

 

1：ev_default_loop函数

#if EV_MULTIPLICITYstruct ev_loop *#elseint#endifev_default_loop (unsigned int flags){    if (!ev_default_loop_ptr)    {#if EV_MULTIPLICITY        struct ev_loop *loop = ev_default_loop_ptr = &default_loop_struct;#else        ev_default_loop_ptr = 1;#endif        loop_init (loop, flags);        if (ev_backend (loop))        {#if EV_CHILD_ENABLE            ev_signal_init (&childev, childcb, SIGCHLD);            ev_set_priority (&childev, EV_MAXPRI);            ev_signal_start (EV_A_ &childev);            ev_unref (loop); /* child watcher should not keep loop alive */#endif        }        else            ev_default_loop_ptr = 0;    }    return ev_default_loop_ptr;}

        EV_MULTIPLICITY宏用来决定是否支持多个loop。系统提供了默认的loop结构default_loop_struct，和指向其的指针ev_default_loop_ptr。

        如果支持多个loop，则default_loop_struct就是一个静态的struct ev_loop类型的结构体，其中包含了各种成员，比如ev_tstamp ev_rt_now;  int  pendingpri;等等。

        ev_default_loop_ptr就是指向struct  ev_loop 类型的指针。

 

        如果不支持多个loop，则上述的struct  ev_loop结构就不复存在，其成员都是以静态变量的形式进行定义，而ev_default_loop_ptr也只是一个int变量，用来表明”loop”是否已经初始化成功。

 

         下面的描述，均以支持多个loop为准。

         在ev_default_loop中，首先是调用loop_init初始化loop中的各种成员：

static void loop_init (struct ev_loop *loop, unsigned int flags){    if (!backend)    {        origflags = flags;#if EV_USE_REALTIME        if (!have_realtime)        {            struct timespec ts;            if (!clock_gettime (CLOCK_REALTIME, &ts))                have_realtime = 1;        }#endif#if EV_USE_MONOTONIC        if (!have_monotonic)        {            struct timespec ts;            if (!clock_gettime (CLOCK_MONOTONIC, &ts))                have_monotonic = 1;        }#endif        /* pid check not overridable via env */#ifndef _WIN32        if (flags & EVFLAG_FORKCHECK)            curpid = getpid ();#endif        if (!(flags & EVFLAG_NOENV) && !enable_secure () && getenv ("LIBEV_FLAGS"))            flags = atoi (getenv ("LIBEV_FLAGS"));          ev_rt_now          = ev_time ();          mn_now             = get_clock ();          now_floor          = mn_now;          rtmn_diff          = ev_rt_now - mn_now;#if EV_FEATURE_API        invoke_cb          = ev_invoke_pending;#endif          io_blocktime       = 0.;          timeout_blocktime  = 0.;          backend            = 0;          backend_fd         = -1;          sig_pending        = 0;#if EV_ASYNC_ENABLE        async_pending      = 0;#endif          pipe_write_skipped = 0;          pipe_write_wanted  = 0;          evpipe [0]         = -1;          evpipe [1]         = -1;#if EV_USE_INOTIFY        fs_fd              = flags & EVFLAG_NOINOTIFY ? -1 : -2;#endif#if EV_USE_SIGNALFD        sigfd              = flags & EVFLAG_SIGNALFD  ? -2 : -1;#endif        if (!(flags & EVBACKEND_MASK))            flags |= ev_recommended_backends ();#if EV_USE_IOCP        if (!backend && (flags & EVBACKEND_IOCP  )) backend = iocp_init   (EV_A_ flags);#endif#if EV_USE_PORT        if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);#endif#if EV_USE_KQUEUE        if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);#endif#if EV_USE_EPOLL        if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init  (EV_A_ flags);#endif#if EV_USE_POLL        if (!backend && (flags & EVBACKEND_POLL  )) backend = poll_init   (EV_A_ flags);#endif#if EV_USE_SELECT        if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);#endif        ev_prepare_init (&pending_w, pendingcb);#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE        ev_init (&pipe_w, pipecb);        ev_set_priority (&pipe_w, EV_MAXPRI);#endif    }}

         调用ev_time初始化ev_rt_now，得到当前的日历时间，也就是自19700101000000以来的秒数，该值通过CLOCK_REALTIME或者gettimeofday得到；

         调用get_clock初始化mn_now，该变量要么是CLOCK_MONOTONIC（系统启动时间），要么就是ev_time的值（日历时间）；

         然后就是：

    now_floor          = mn_now;    rtmn_diff          = ev_rt_now - mn_now;#if EV_FEATURE_API    invoke_cb          = ev_invoke_pending;#endif    io_blocktime       = 0.;    timeout_blocktime  = 0.;    backend            = 0;    backend_fd         = -1;    sig_pending        = 0;#if EV_ASYNC_ENABLE    async_pending      = 0;#endif    pipe_write_skipped = 0;    pipe_write_wanted  = 0;    evpipe [0]         = -1;    evpipe [1]         = -1;#if EV_USE_INOTIFY    fs_fd              = flags & EVFLAG_NOINOTIFY ? -1 : -2;#endif#if EV_USE_SIGNALFD    sigfd              = flags & EVFLAG_SIGNALFD  ? -2 : -1;#endif

         之后调用ev_recommended_backends得到当前系统支持的backend类型，比如select,poll, epoll等。

         接下来就是根据系统支持的backend，按照一定的优先顺序，去初始化backend：

#if EV_USE_IOCP      if (!backend && (flags & EVBACKEND_IOCP  )) backend = iocp_init   (EV_A_ flags);#endif#if EV_USE_PORT      if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);#endif#if EV_USE_KQUEUE      if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);#endif#if EV_USE_EPOLL      if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init  (EV_A_ flags);#endif#if EV_USE_POLL      if (!backend && (flags & EVBACKEND_POLL  )) backend = poll_init   (EV_A_ flags);#endif#if EV_USE_SELECT      if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);#endif

         接下来，初始化loop中的ev_prepare监视器pending_w，以及ev_io监视器pipe_w

 

         loop_init返回后，backend已经初始化完成，接着，初始化并启动信号监视器ev_signal childev。暂不深入。

 

         至此，初始化默认loop的工作就完成了。

 

2：ev_init

         该函数以宏的形式存在，主要用来设置监视器的公共成员active、pending、priority、cb等。代码如下：

#define ev_init(ev,cb_) do {                    \  ((ev_watcher *)(void *)(ev))->active  =       \  ((ev_watcher *)(void *)(ev))->pending = 0;    \  ev_set_priority ((ev), 0);                    \  ev_set_cb ((ev), cb_);                        \} while (0)

3：ev_io_set

         该宏主要是设置IO监视器ev_io的特有成员：要监听的描述符fd和其上的事件event。其中设置event会包含事件掩码EV__IOFDSET，其代码如下：

#define ev_io_set(ev,fd_,events_)            do { (ev)->fd = (fd_); (ev)->events = (events_) | EV__IOFDSET; } while (0)

4：ev_io_start

void ev_io_start (struct ev_loop *loop, ev_io *w) EV_THROW{int fd = w->fd;if (expect_false (ev_is_active (w)))return;assert (("libev: ev_io_start called with negative fd", fd >= 0));assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));ev_start (loop, (W)w, 1);array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);wlist_add (&anfds[fd].head, (WL)w);/* common bug, apparently */assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));fd_change (loop, fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);w->events &= ~EV__IOFDSET;}

         首先对监视器ev做检查：

ev->active ==0： 监视器现在的状态应是未启动的；

fd>=0;

(!(w->events& ~(EV__IOFDSET | EV_READ | EV_WRITE)))： IO监视器只能监控EV__IOFDSET，EV_READ，EV_WRITE中的事件，其他事件一律不能关心。

 

         调用ev_start矫正ev的优先级；置ev->active=1表明状态为启动状态；++(loop->activecnt)

        

         根据情况调整((loop)->anfds)数组的大小，然后将监视器ev加入到(loop->anfds)[fd].head的链表中。

         loop->anfds是ANFD结构类型的数组，ANFD结构体定义如下：

typedef struct{    WL head;    unsigned char events; /* the events watched for */    unsigned char reify;  /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */    unsigned char emask;  /* the epoll backend stores the actual kernel mask in here */    unsigned char unused;#if EV_USE_EPOLL    unsigned int egen;    /* generation counter to counter epoll bugs */#endif#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP    SOCKET handle;#endif#if EV_USE_IOCP    OVERLAPPED or, ow;#endif} ANFD;

         每一个描述符对应着一个ANFD结构，描述符的值就是((loop)->anfds)的下标。每个描述符上可以有若干监视器，同一个描述符上的监视器以链表的形式组织，这里ANFD结构中的head就是链表头指针。

         ((loop)->anfds)数组是动态变化的，初始为空。(loop)->anfdmax就是该数组的当前大小。

 

         调用fd_change(loop, fd, w->events & EV__IOFDSET |EV_ANFD_REIFY):

void fd_change (struct ev_loop *loop, int fd, int flags){    unsigned char reify = anfds [fd].reify;    anfds [fd].reify |= flags;    if (expect_true (!reify))    {      ++fdchangecnt;      array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);      fdchanges [fdchangecnt - 1] = fd;    }}

        查看(loop->anfds)[fd].reify的原值，如果原值为0，表明该描述符是第一次加入监控，将其记录到((loop)->fdchanges)数组中，该数组记录了当前监控中的描述符，((loop)->fdchangemax)记录该数组当前实际大小，((loop)->fdchangecnt)记录该数组当前使用大小。

         将w->events & EV__IOFDSET | EV_ANFD_REIFY添加到(loop->anfds)[fd].reify中。

 

         最后，将w->events中的EV__IOFDSET掩码消除：

w->events &= ~EV__IOFDSET;

5：fd_reify

void fd_reify (struct ev_loop *loop){    int i;    for (i = 0; i < fdchangecnt; ++i)    {        int fd = fdchanges [i];        ANFD *anfd = anfds + fd;        ev_io *w;        unsigned char o_events = anfd->events;        unsigned char o_reify  = anfd->reify;        anfd->reify  = 0;        /*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */        {            anfd->events = 0;            for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)                anfd->events |= (unsigned char)w->events;            if (o_events != anfd->events)                o_reify = EV__IOFDSET; /* actually |= */        }        if (o_reify & EV__IOFDSET)            backend_modify (loop, fd, o_events, anfd->events);    }  fdchangecnt = 0;}

         轮训数组((loop)->fdchanges)，从0到((loop)->fdchangecnt-1)之间的所有元素，每个元素代表了一个描述符，根据取得的描述符值fd，找到相应的ANFD结构anfd。

         记录原anfd->events和anfd->reify的值，然后：

anfd->reify  = 0;anfd->events = 0;for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)    anfd->events |= (unsigned char)w->events;

         然后调用backend_modify函数开始对fd及其上的所有事件开始监控。以backend为select例，就是根据anfd->events中的事件，将fd添加到相应的fd_set中去。

 

         最后，置((loop)->fdchangecnt)为0。

 

6：time_update函数

         该函数重新获得mn_now、ev_rt_now等的值，并且如果发现时间被人为调整的话，则在代码中也作出相应的调整。ev_rt_now表示日历时间，mn_now要么表示系统启动时间，要么表示日历时间。

/* fetch new monotonic and realtime times from the kernel *//* also detect if there was a timejump, and act accordingly */void time_update (struct ev_loop *loop, ev_tstamp max_block){#if EV_USE_MONOTONIC    if (expect_true (have_monotonic))    {        int i;        ev_tstamp odiff = rtmn_diff;        mn_now = get_clock ();        /* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */        /* interpolate in the meantime */        if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))        {            ev_rt_now = rtmn_diff + mn_now;            return;        }        now_floor = mn_now;        ev_rt_now = ev_time ();        /* loop a few times, before making important decisions.        * on the choice of "4": one iteration isn't enough,        * in case we get preempted during the calls to        * ev_time and get_clock. a second call is almost guaranteed        * to succeed in that case, though. and looping a few more times        * doesn't hurt either as we only do this on time-jumps or        * in the unlikely event of having been preempted here.        */        for (i = 4; --i; )        {            ev_tstamp diff;            rtmn_diff = ev_rt_now - mn_now;            diff = odiff - rtmn_diff;            if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))                return; /* all is well */            ev_rt_now = ev_time ();            mn_now    = get_clock ();            now_floor = mn_now;        }        /* no timer adjustment, as the monotonic clock doesn't jump */        /* timers_reschedule (EV_A_ rtmn_diff - odiff) */# if EV_PERIODIC_ENABLE        periodics_reschedule (EV_A);# endif    }    else#endif    {        ev_rt_now = ev_time ();        if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))        {            /* adjust timers. this is easy, as the offset is the same for all of them */            timers_reschedule (EV_A_ ev_rt_now - mn_now);#if EV_PERIODIC_ENABLE            periodics_reschedule (EV_A);#endif        }        mn_now = ev_rt_now;    }}

         如果宏定义EV_USE_MONOTONIC为1，并且have_monotonic为1（sys_clock_gettime支持CLOCK_MONOTONIC）的话，mn_now就表示系统启动时间，它不会被人为的调整。

         这种情况下，更新系统启动时间mn_now的值，如果该值与旧的mn_now的值之差不超过0.5s的话，表示刚刚更新过时间（更新时间不超过0.5s），则更新ev_rt_now之后，直接退出。

         更新ev_rt_now的值，然后根据ev_rt_now- mn_now之差的变化，判断时间是否被人调整。如果ev_rt_now - mn_now之差的浮动小于1s，则说明时间没有调整，直接退出。如果浮动大于1s，则重新更新mn_now和ev_rt_now，再次判断时间差的浮动，如果判断了3次，浮动始终大于1s，说明时间被认为调整了，则需要更新周期事件，这种情况下不调整超时事件（超时事件都是根据mn_now设置的，在have_monotonic为1的情况下，mn_now表示系统启动时间，不会被调整）。

 

         如果宏定义EV_USE_MONOTONIC为0，或者have_monotonic为0（sys_clock_gettime不支持CLOCK_MONOTONIC）的话，mn_now与ev_rt_now一样，也是日历时间。

         这种情况下，更新ev_rt_now的值，将该值与之前的日历时间比较，如果时间被人调整了，则需要调整超时事件和周期事件。

 

7：fd_event

         在backend_poll函数中，如果有些监视器的事件触发了，就会调用fd_event函数，将触发的描述符fd和事件event记录到pending数组中。

void fd_event (struct ev_loop *loop, int fd, int revents){ANFD *anfd = anfds + fd;if (expect_true (!anfd->reify))fd_event_nocheck (EV_A_ fd, revents);}

         已经触发而还没有处理的事件状态称为PENDING状态。在fd_event函数中，根据fd找到相应的ANFD结构。然后就是：

if (expect_true (!anfd->reify))    fd_event_nocheck (EV_A_ fd, revents);

         fd_event_nocheck的代码如下，根据fd找到相应的ANFD结构，轮训其中的监视器链表，如果某监视器上的事件触发了，则调用ev_feed_event函数处理：

fd_event_nocheck (EV_P_ int fd, int revents){    ANFD *anfd = anfds + fd;    ev_io *w;    for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)    {        int ev = w->events & revents;        if (ev)            ev_feed_event (EV_A_ (W)w, ev);    }}

         ev_feed_event代码如下：

void ev_feed_event (struct ev_loop *loop, void *w, int revents){    W w_ = (W)w;    int pri = ABSPRI (w_);    if (expect_false (w_->pending))        pendings [pri][w_->pending - 1].events |= revents;    else    {        w_->pending = ++pendingcnt [pri];        array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);        pendings [pri][w_->pending - 1].w      = w_;        pendings [pri][w_->pending - 1].events = revents;    }    pendingpri = NUMPRI - 1;}

         (loop->pendingcnt)是一个一维整型数组，(loop->pendingcnt)[i]表示当前处于PENDING状态的优先级为i的监视器的个数。

(loop->pendings )是个二维数组，每个元素类型为ANPENDING，该结构的定义如下：

/* stores the pending event set for a given watcher */typedef struct{  ev_watcher *w;  int events; } ANPENDING;

        APPENDING结构记录了处于PENDING状态的监视器以及触发的事件。(loop->pendings)数组，以优先级为第一维，以APPENDING为第二维。

 

        在函数ev_feed_event中，判断w_->pending的值，该值为0表示该监视器第一次被激活，不为0表示的是该监视器已经处于PENDING状态，而其具体的值，代表该监视器在pendings [pri]中的排名（从1开始），也就是当前(loop->pendingcnt) [pri]的值。

        该值不为0，说明该监视器已经处于PENDING状态了，因此只需要：

    pendings [pri][w_->pending - 1].events |= revents;

        如果该值为0，则

w_->pending = ++pendingcnt [pri];array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);pendings [pri][w_->pending - 1].w      = w_;pendings [pri][w_->pending - 1].events = revents;

8：ev_invoke_pending

void ev_invoke_pending (struct ev_loop *loop ){    pendingpri = NUMPRI;    while (pendingpri) /* pendingpri possibly gets modified in the inner loop */    {        --pendingpri;        while (pendingcnt [pendingpri])        {            ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];            p->w->pending = 0;            EV_CB_INVOKE (p->w, p->events);        }    }}

         该函数主要是，调用所有当前处于PENDING状态的监视器的回调函数。根据优先级pendingpri从高到底，(loop->pendingcnt) [pendingpri]表示PENDING状态的，优先级为pendingpri的监视器个数。从后向前轮训(loop->pendings)[pendingpri]数组，调用每个监视器的回调函数。并且置w->pending = 0。

 

二：总结

三：例子

ev_io io_w;void io_action(struct ev_loop *main_loop, ev_io *io_w, int e){    int rst;    char buf[1024] = {'\0'};    rst = read(io_w->fd, buf, sizeof(buf));    if(rst <= 0)    {        close(io_w->fd);        printf("client over\n");                ev_io_stop(main_loop,io_w);        return;    }    buf[1023] = '\0';    printf("Read in a string: %s \n",buf);    write(io_w->fd, buf, strlen(buf));}int socketfd(){    int listenfd = socket(AF_INET, SOCK_STREAM, 0);    if (listenfd < 0)    {        perror("socket error");        return -1;    }    struct sockaddr_in serveraddr;    struct sockaddr_in clientaddr;    int addrlen = sizeof(struct sockaddr_in);        serveraddr.sin_family = AF_INET;    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);    serveraddr.sin_port = htons(8898);    if(bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in)) < 0)    {        perror("bind error");        return -1;    }    if(listen(listenfd, 5) < 0)    {        perror("listen error");        return -1;    }       int connectfd = 0;    connectfd = accept(listenfd, (struct sockaddr *)&clientaddr, (socklen_t *)&addrlen);    if(connectfd < 0)    {        perror("accept error");        return -1;    }    return connectfd;}int main(){    int fd = socketfd();    if(fd < 0)  return;    struct ev_loop *main_loop = ev_default_loop(0);        ev_init(&io_w,io_action);    ev_io_set(&io_w,fd,EV_READ);        ev_io_start(main_loop,&io_w);    ev_run(main_loop,0);    return;}