Libevent源码分析-----bufferevent工作流程探究

墨蓝 2022-05-09 07:38 203阅读 0赞

和之前的《[Libevent工作流程探究][Libevent]》一样，这里也是用一个例子来探究bufferevent的工作流程。具体的例子可以参考《[Libevent使用例子，从简单到复杂][Libevent 1]》，这里就不列出了。其实要做的例子也就是bufferevent\_socket\_new、bufferevent\_setcb、bufferevent\_enable这几个函数。

因为本文会用到《[Libevent工作流程探究][Libevent]》中提到的说法，比如将一个event插入到event\_base中。所以读者最好先读一下那篇博文。此外，因为bufferevent结构体本身会使用evbuffer结构体和还会调用相应的一些操作，所以读者还应该先阅读《[evbuffer结构与基本操作][evbuffer]》和《[更多evbuffer操作函数][evbuffer 1]》。

# **bufferevent结构体：** #

bufferevent其实也就是在event\_base的基础上再进行一层封装，其本质还是离不开event和event\_base，从bufferevent的结构体就可以看到这一点。

bufferevent结构体中有两个event，分别用来监听同一个fd的可读事件和可写事件。为什么不用一个event同时监听可读和可写呢？这是因为监听可写是困难的，[下面][Link 1]会说到原因。读者也可以自问一下，自己之前有没有试过用最原始的event监听一个fd的可写。

由于socket 是全双工的，所以在bufferevent结构体中，也有两个evbuffer成员，分别是读缓冲区和写缓冲区。 bufferevent结构体定义如下：

//bufferevent_struct.h文件
    
    struct bufferevent {
    
    struct event_base *ev_base;
    
    
    //操作结构体，成员有一些函数指针。类似struct eventop结构体
    
    const struct bufferevent_ops *be_ops;
    
    
    struct event ev_read;//读事件event
    
    struct event ev_write;//写事件event
    
    
    struct evbuffer *input;//读缓冲区
    
    
    struct evbuffer *output; //写缓冲区
    
    
    struct event_watermark wm_read;//读水位
    
    struct event_watermark wm_write;//写水位
    
    
    
    bufferevent_data_cb readcb;//可读时的回调函数指针
    
    bufferevent_data_cb writecb;//可写时的回调函数指针
    
    bufferevent_event_cb errorcb;//错误发生时的回调函数指针
    
    void *cbarg;//回调函数的参数
    
    
    struct timeval timeout_read;//读事件event的超时值
    
    struct timeval timeout_write;//写事件event的超时值
    
    
    /** Events that are currently enabled: currently EV_READ and EV_WRITE
    
    are supported. */
    
    short enabled;
    
    };

如果看过Libevent的参考手册的话，应该还会知道bufferevent除了用于socket外，还可以用于socketpair 和 filter。如果用面向对象的思维，应从这个三个应用中抽出相同的部分作为父类，然后派生出三个子类。

Libevent虽然是用C语言写的，不过它还是提取出一些公共部分，然后定义一个bufferevent\_private结构体，用于保存这些公共部分成员。从集合的角度来说，bufferevent\_private应该是bufferevent的一个子集，即一部分。但在Libevent中，bufferevent确实bufferevent\_private的一个成员。下面是bufferevent\_private结构体。

//bufferevent-internal.h文件
    
    struct bufferevent_private {
    
    struct bufferevent bev;
    
    
    //设置input evbuffer的高水位时，需要一个evbuffer回调函数配合工作
    
    struct evbuffer_cb_entry *read_watermarks_cb;
    
    
    /** If set, we should free the lock when we free the bufferevent. */
    
    //锁是Libevent自动分配的，还是用户分配的
    
    unsigned own_lock : 1;
    
    
    ...
    
    
    //这个socket是否处理正在连接服务器状态
    
    unsigned connecting : 1;
    
    //标志连接被拒绝
    
    unsigned connection_refused : 1;
    
    
    //标志是什么原因把 读 挂起来
    
    bufferevent_suspend_flags read_suspended;
    
    //标志是什么原因把 写 挂起来
    
    bufferevent_suspend_flags write_suspended;
    
    
    enum bufferevent_options options;
    
    int refcnt;// bufferevent的引用计数
    
    
    //锁变量
    
    void *lock;
    
    };

# **新建一个bufferevent：** #

函数bufferevent\_socket\_new可以完成这个工作。

//bufferevent-internal.h文件
    
    struct bufferevent_ops {
    
    const char *type;//类型名称
    
    
    off_t mem_offset;//成员bev的偏移量
    
    
    //启动。将event加入到event_base中
    
    int (*enable)(struct bufferevent *, short);
    
    
    //关闭。将event从event_base中删除
    
    int (*disable)(struct bufferevent *, short);
    
    //销毁
    
    void (*destruct)(struct bufferevent *);
    
    //调整event的超时值
    
    int (*adj_timeouts)(struct bufferevent *);
    
    /** Called to flush data. */
    
    int (*flush)(struct bufferevent *, short, enum bufferevent_flush_mode);
    
    //获取成员的值。具体看实现
    
    int (*ctrl)(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *);
    
    };
    
    
    
    //bufferevent_sock.c文件
    
    const struct bufferevent_ops bufferevent_ops_socket = {
    
    "socket",
    
    evutil_offsetof(struct bufferevent_private, bev),
    
    be_socket_enable,
    
    be_socket_disable,
    
    be_socket_destruct,
    
    be_socket_adj_timeouts,
    
    be_socket_flush,
    
    be_socket_ctrl,
    
    };
    
    
    //由于有几个不同类型的bufferevent，而且它们的enable、disable等操作是不同的。所以
    
    //需要的一些函数指针指明某个类型的bufferevent应该使用哪些操作函数。结构体bufferevent_ops_socket
    
    //就应运而生。对于socket，其操作函数如上。
    
    
    //bufferevent_sock.c文件
    
    struct bufferevent *
    
    bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,
    
    int options)
    
    {
    
    struct bufferevent_private *bufev_p;
    
    struct bufferevent *bufev;
    
    
    ...//win32
    
    
    //结构体内存清零，所有成员都为0
    
    if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)
    
    return NULL;
    
    
    //如果options中需要线程安全，那么就会申请锁
    
    //会新建一个输入和输出缓存区
    
    if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket,
    
    options) < 0) {
    
    mm_free(bufev_p);
    
    return NULL;
    
    }
    
    bufev = &bufev_p->bev;
    
    //设置将evbuffer的数据向fd传
    
    evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD);
    
    
    //将fd与event相关联。同一个fd关联两个event
    
    event_assign(&bufev->ev_read, bufev->ev_base, fd,
    
    EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
    
    event_assign(&bufev->ev_write, bufev->ev_base, fd,
    
    EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
    
    
    //设置evbuffer的回调函数，使得外界给写缓冲区添加数据时，能触发
    
    //写操作，这个回调对于写事件的监听是很重要的
    
    evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev);
    
    
    //冻结读缓冲区的尾部，未解冻之前不能往读缓冲区追加数据
    
    //也就是说不能从socket fd中读取数据
    
    evbuffer_freeze(bufev->input, 0);
    
    
    //冻结写缓冲区的头部，未解冻之前不能把写缓冲区的头部数据删除
    
    //也就是说不能把数据写到socket fd
    
    evbuffer_freeze(bufev->output, 1);
    
    
    return bufev;
    
    }

留意函数里面的evbuffer\_add\_cb调用，后面会说到。

函数在最后面会冻结两个缓冲区。其实，虽然这里冻结了，但实际上Libevent在读数据或者写数据之前会解冻的读完或者写完数据后，又会马上冻结。这主要防止数据被意外修改。用户一般不会直接调用evbuffer\_freeze或者evbuffer\_unfreeze函数。一切的冻结和解冻操作都由Libevent内部完成。还有一点要注意，因为这里只是把写缓冲区的头部冻结了。所以还是可以往写缓冲区的尾部追加数据。同样，此时也是可以从读缓冲区读取数据。这个是必须的。因为在Libevent内部不解冻的时候，用户需要从读缓冲区中获取数据(这相当于从socket fd中读取数据)，用户也需要把数据写到写缓冲区中(这相当于把数据写入到socket fd中)。

在bufferevent\_socket\_new函数里面会调用函数bufferevent\_init\_common完成公有部分的初始化。

//bufferevent.c文件
    
    int
    
    bufferevent_init_common(struct bufferevent_private *bufev_private,
    
    struct event_base *base,
    
    const struct bufferevent_ops *ops,
    
    enum bufferevent_options options)
    
    {
    
    struct bufferevent *bufev = &bufev_private->bev;
    
    
    //分配输入缓冲区
    
    if (!bufev->input) {
    
    if ((bufev->input = evbuffer_new()) == NULL)
    
    return -1;
    
    }
    
    
    //分配输出缓冲区
    
    if (!bufev->output) {
    
    if ((bufev->output = evbuffer_new()) == NULL) {
    
    evbuffer_free(bufev->input);
    
    return -1;
    
    }
    
    }
    
    
    bufev_private->refcnt = 1;//引用次数为1
    
    bufev->ev_base = base;
    
    
    /* Disable timeouts. */
    
    //默认情况下,读和写event都是不支持超时的
    
    evutil_timerclear(&bufev->timeout_read);
    
    evutil_timerclear(&bufev->timeout_write);
    
    
    bufev->be_ops = ops;
    
    
    /*
    
    * Set to EV_WRITE so that using bufferevent_write is going to
    
    * trigger a callback. Reading needs to be explicitly enabled
    
    * because otherwise no data will be available.
    
    */
    
    //可写是默认支持的
    
    bufev->enabled = EV_WRITE;
    
    
    #ifndef _EVENT_DISABLE_THREAD_SUPPORT
    
    if (options & BEV_OPT_THREADSAFE) {
    
    //申请锁。
    
    if (bufferevent_enable_locking(bufev, NULL) < 0) {
    
    /* cleanup */
    
    evbuffer_free(bufev->input);
    
    evbuffer_free(bufev->output);
    
    bufev->input = NULL;
    
    bufev->output = NULL;
    
    return -1;
    
    }
    
    }
    
    #endif
    
    ...//延迟调用的初始化，一般不需要用到
    
    
    bufev_private->options = options;
    
    
    //将evbuffer和bufferevent相关联
    
    evbuffer_set_parent(bufev->input, bufev);
    
    evbuffer_set_parent(bufev->output, bufev);
    
    
    return 0;
    
    }

代码中可以看到，默认是enable EV\_WRITE的。

# 设置回调函数： #

函数bufferevent\_setcb完成这个工作。该函数相当简单，也就是进行一些赋值操作。

//bufferevent.c文件
    
    void
    
    bufferevent_setcb(struct bufferevent *bufev,
    
    bufferevent_data_cb readcb, bufferevent_data_cb writecb,
    
    bufferevent_event_cb eventcb, void *cbarg)
    
    {
    
    //bufferevent结构体内部有一个锁变量
    
    BEV_LOCK(bufev);
    
    
    bufev->readcb = readcb;
    
    bufev->writecb = writecb;
    
    bufev->errorcb = eventcb;
    
    
    bufev->cbarg = cbarg;
    
    BEV_UNLOCK(bufev);
    
    }

如果不想设置某个操作的回调函数，直接设置为NULL即可。

# 令bufferevent可以工作: #

相信读者也知道，即使调用了bufferevent\_socket\_new和bufferevent\_setcb，这个bufferevent还是不能工作，必须调用bufferevent\_enable。为什么会这样的呢？

如果看过之前的那些博文，相信读者知道，一个event能够工作，不仅仅需要new出来，还要调用event\_add函数，把这个event添加到event\_base中。在本文前面的代码中，并没有看到event\_add函数的调用。所以还需要调用一个函数，把event添加到event\_base中。函数bufferevent\_enable就是完成这个工作的。

//bufferevent.c文件
    
    int
    
    bufferevent_enable(struct bufferevent *bufev, short event)
    
    {
    
    struct bufferevent_private *bufev_private =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    short impl_events = event;
    
    int r = 0;
    
    
    //增加引用并加锁
    
    //增加引用是为了防止其他线程调用bufferevent_free，释放了bufferevent
    
    _bufferevent_incref_and_lock(bufev);
    
    
    //挂起了读，此时不能监听读事件
    
    if (bufev_private->read_suspended)
    
    impl_events &= ~EV_READ;
    
    
    //挂起了写，此时不能监听写事情
    
    if (bufev_private->write_suspended)
    
    impl_events &= ~EV_WRITE;
    
    
    bufev->enabled |= event;
    
    
    //调用对应类型的enbale函数。因为不同类型的bufferevent有不同的enable函数
    
    if (impl_events && bufev->be_ops->enable(bufev, impl_events) < 0)
    
    r = -1;
    
    
    //减少引用并解锁
    
    _bufferevent_decref_and_unlock(bufev);
    
    return r;
    
    }

上面代码可以看到，最终会调用对应bufferevent类型的enable函数，对于socket bufferevent，其enable函数是be\_socket\_enable，代码如下：

//bufferevent.c文件
    
    int
    
    _bufferevent_add_event(struct event *ev, const struct timeval *tv)
    
    {
    
    if (tv->tv_sec == 0 && tv->tv_usec == 0)
    
    return event_add(ev, NULL);
    
    else
    
    return event_add(ev, tv);
    
    }
    
    
    
    //bufferevent_sock.c文件
    
    #define be_socket_add(ev, t) \
    
    _bufferevent_add_event((ev), (t))
    
    
    
    static int
    
    be_socket_enable(struct bufferevent *bufev, short event)
    
    {
    
    if (event & EV_READ) {
    
    if (be_socket_add(&bufev->ev_read,&bufev->timeout_read) == -1)
    
    return -1;
    
    }
    
    if (event & EV_WRITE) {
    
    if (be_socket_add(&bufev->ev_write,&bufev->timeout_write) == -1)
    
    return -1;
    
    }
    
    return 0;
    
    }

如果读者熟悉Libevent的超时事件，那么可以知道Libevent是在event\_add函数里面确定一个event的超时的。上面代码也展示了这一点，如果读或者写event设置了超时(即其超时值不为0)，那么就会作为参数传给event\_add函数。如果读者不熟悉的Libevent的超时事件的话，可以参考《[超时event的处理][event]》。

用户可以调用函数bufferevent\_set\_timeouts，设置读或者写事件的超时。代码如下：

//bufferevent.c文件
    
    int
    
    bufferevent_set_timeouts(struct bufferevent *bufev,
    
    const struct timeval *tv_read,
    
    const struct timeval *tv_write)
    
    {
    
    int r = 0;
    
    BEV_LOCK(bufev);
    
    if (tv_read) {
    
    bufev->timeout_read = *tv_read;
    
    } else {
    
    evutil_timerclear(&bufev->timeout_read);
    
    }
    
    if (tv_write) {
    
    bufev->timeout_write = *tv_write;
    
    } else {
    
    evutil_timerclear(&bufev->timeout_write);
    
    }
    
    
    if (bufev->be_ops->adj_timeouts)
    
    r = bufev->be_ops->adj_timeouts(bufev);
    
    BEV_UNLOCK(bufev);
    
    
    return r;
    
    }
    
    
    
    //bufferevent_sock.c文件
    
    static int
    
    be_socket_adj_timeouts(struct bufferevent *bufev)
    
    {
    
    int r = 0;
    
    //用户监听了读事件
    
    if (event_pending(&bufev->ev_read, EV_READ, NULL))
    
    if (be_socket_add(&bufev->ev_read, &bufev->timeout_read) < 0)
    
    r = -1;
    
    
    //用户监听了写事件
    
    if (event_pending(&bufev->ev_write, EV_WRITE, NULL)) {
    
    if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) < 0)
    
    r = -1;
    
    }
    
    return r;
    
    }

从上面代码可以看到：用户不仅仅可以设置超时值，还可以修改超时值，也是通过这个函数进行修的。当然也是可以删除超时的，直接把超时参数设置成NULL即可。

至此，已经完成了bufferevent的初始化工作，只需调用event\_base\_dispatch函数，启动发动机就可以工作了。

# **处理读事件：** #

接下来的任务：底层的socket fd接收数据后，bufferevent是怎么工作的。

## **读事件的水位：** ##

在讲解读事件之前，先来看一下水位问题，函数bufferevent\_setwatermark可以设置读和写的水位。这里只讲解读事件的水位。

水位有两个：低水位和高水位。

低水位比较容易懂，就是当可读的数据量到达这个低水位后，才会调用用户设置的回调函数。比如用户想每次读取100字节，那么就可以把低水位设置为100。当可读数据的字节数小于100时，即使有数据都不会打扰用户(即不会调用用户设置的回调函数)。可读数据大于等于100字节后，才会调用用户的回调函数。

高水位是什么呢？其实，这和用户的回调函数没有关系。它的意义是：把读事件的evbuffer的数据量限制在高水位之下。比如，用户认为读缓冲区不能太大(太大的话，链表会很长)。那么用户就会设置读事件的高水位。当读缓冲区的数据量达到这个高水位后，即使socket fd还有数据没有读，也不会读进这个读缓冲区里面。一句话说，就是控制evbuffer的大小。

虽然控制了evbuffer的大小，但socket fd可能还有数据。有数据就会触发可读事件，但处理可读的时候，又会发现设置了高水位，不能读取数据evbuffer。socket fd的数据没有被读完，又触发……。这个貌似是一个死循环。实际上是不会出现这个死循环的，因为Libevent发现evbuffer的数据量到达高水位后，就会把可读事件给挂起来，让它不能再触发了。Libevent使用函数bufferevent\_wm\_suspend\_read把监听读事件的event挂起来。下面看一下Libevent是怎么把一个event挂起来的。

//bufferevent-internal.h文件
    
    #define bufferevent_wm_suspend_read(b) \
    
    bufferevent_suspend_read((b), BEV_SUSPEND_WM)
    
    
    
    //bufferevent.c文件
    
    void
    
    bufferevent_suspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what)
    
    {
    
    struct bufferevent_private *bufev_private =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    BEV_LOCK(bufev);
    
    if (!bufev_private->read_suspended)//不能挂多次
    
    bufev->be_ops->disable(bufev, EV_READ);//实际调用be_socket_disable函数
    
    bufev_private->read_suspended |= what;//因何而被挂起
    
    BEV_UNLOCK(bufev);
    
    }
    
    
    
    //bufferevent_sock.c文件
    
    static int
    
    be_socket_disable(struct bufferevent *bufev, short event)
    
    {
    
    struct bufferevent_private *bufev_p =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    if (event & EV_READ) {
    
    if (event_del(&bufev->ev_read) == -1)
    
    return -1;
    
    }
    
    /* Don't actually disable the write if we are trying to connect. */
    
    if ((event & EV_WRITE) && ! bufev_p->connecting) {
    
    if (event_del(&bufev->ev_write) == -1)//删掉这个event
    
    return -1;
    
    }
    
    return 0;
    
    }

居然是直接删除这个监听读事件的event，真的是挂了!!!

看来不能随便设置高水位，因为它会暂停读。如果只想设置低水位而不想设置高水位，那么在调用bufferevent\_setwatermark函数时，高水位的参数设为0即可。

那么什么时候取消挂起，让bufferevent可以继续读socket 数据呢？从高水位的意义来说，当然是当evbuffer里面的数据量小于高水位时，就能再次读取socket数据了。现在来看一下Libevent是怎么恢复读的。看一下设置水位的函数bufferevent\_setwatermark吧，它进行了一些为高水位埋下了一个回调函数。对，就是evbuffer的回调函数。[前一篇博文][Link 2]说到，当evbuffer里面的数据添加或者删除时，是会触发一些回调函数的。当用户移除evbuffer的一些数据量时，Libevent就会检查这个evbuffer的数据量是否小于高水位，如果小于的话，那么就恢复 读事件。

不说这么多了，上代码。

//bufferevent.c文件
    
    void
    
    bufferevent_setwatermark(struct bufferevent *bufev, short events,
    
    size_t lowmark, size_t highmark)
    
    {
    
    struct bufferevent_private *bufev_private =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    
    BEV_LOCK(bufev);
    
    
    if (events & EV_READ) {
    
    bufev->wm_read.low = lowmark;
    
    bufev->wm_read.high = highmark;
    
    
    if (highmark) {//高水位
    
    /* There is now a new high-water mark for read.
    
    enable the callback if needed, and see if we should
    
    suspend/bufferevent_wm_unsuspend. */
    
    
    //还没设置高水位的回调函数
    
    if (bufev_private->read_watermarks_cb == NULL) {
    
    bufev_private->read_watermarks_cb =
    
    evbuffer_add_cb(bufev->input,
    
    bufferevent_inbuf_wm_cb,
    
    bufev);//添加回调函数
    
    }
    
    evbuffer_cb_set_flags(bufev->input,
    
    bufev_private->read_watermarks_cb,
    
    EVBUFFER_CB_ENABLED|EVBUFFER_CB_NODEFER);
    
    
    //设置(修改)高水位时，evbuffer的数据量已经超过了水位值
    
    //可能是把之前的高水位调高或者调低
    
    //挂起操作和取消挂起操作都是幂等的(即多次挂起的作用等同于挂起一次)
    
    if (evbuffer_get_length(bufev->input) > highmark)
    
    bufferevent_wm_suspend_read(bufev);
    
    else if (evbuffer_get_length(bufev->input) < highmark)//调低了
    
    bufferevent_wm_unsuspend_read(bufev);
    
    } else {
    
    //高水位值等于0，那么就要取消挂起 读事件
    
    //取消挂起操作是幂等的
    
    /* There is now no high-water mark for read. */
    
    if (bufev_private->read_watermarks_cb)
    
    evbuffer_cb_clear_flags(bufev->input,
    
    bufev_private->read_watermarks_cb,
    
    EVBUFFER_CB_ENABLED);
    
    bufferevent_wm_unsuspend_read(bufev);
    
    }
    
    }
    
    BEV_UNLOCK(bufev);
    
    }

这个函数，不仅仅为高水位设置回调函数，还会检查当前evbuffer的数据量是否超过了高水位。因为这个设置水位函数可能是在bufferevent工作一段时间后才添加的，所以evbuffer是有可能已经有数据的了，因此需要检查。如果超过了水位值，那么就需要挂起读。当然也存在另外一种可能：用户之前设置过了一个比较大的高水位，挂起了读。现在发现错了，就把高水位调低一点，此时就需要恢复读。

现在假设用户移除了一些evbuffer的数据，进而触发了evbuffer的回调函数，当然也就调用了函数bufferevent\_inbuf\_wm\_cb。下面看一下这个函数是怎么恢复读的。

//bufferevent.c文件
    
    static void
    
    bufferevent_inbuf_wm_cb(struct evbuffer *buf,
    
    const struct evbuffer_cb_info *cbinfo,
    
    void *arg)
    
    {
    
    struct bufferevent *bufev = arg;
    
    size_t size;
    
    
    size = evbuffer_get_length(buf);
    
    
    if (size >= bufev->wm_read.high)
    
    bufferevent_wm_suspend_read(bufev);
    
    else
    
    bufferevent_wm_unsuspend_read(bufev);
    
    }
    
    
    //bufferevent-internal.h文件
    
    #define bufferevent_wm_unsuspend_read(b) \
    
    bufferevent_unsuspend_read((b), BEV_SUSPEND_WM)
    
    
    //bufferevent.c文件
    
    void
    
    bufferevent_unsuspend_read(struct bufferevent *bufev, bufferevent_suspend_flags what)
    
    {
    
    struct bufferevent_private *bufev_private =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    
    BEV_LOCK(bufev);
    
    bufev_private->read_suspended &= ~what;
    
    if (!bufev_private->read_suspended && (bufev->enabled & EV_READ))
    
    bufev->be_ops->enable(bufev, EV_READ);//重新把event插入到event_base中
    
    BEV_UNLOCK(bufev);
    
    }

因为用户可以手动为这个evbuffer添加数据，此时也会调用bufferevent\_inbuf\_wm\_cb函数。此时就要检查evbuffer的数据量是否已经超过高水位了，而不能仅仅检查是否低于高水位。

高水位导致读的挂起和之后读的恢复，一切工作都是由Libevent内部完成的，用户不用做任何工作。

## **从socket中读取数据：** ##

从前面的一系列博文可以知道，如果一个socket可读了，那么监听可读事件的event的回调函数就会被调用。这个回调函数是在bufferevent\_socket\_new函数中被Libevent内部设置的，设置为bufferevent\_readcb函数，用户并不知情。

当socket有数据可读时，Libevent就会监听到，然后调用bufferevent\_readcb函数处理。该函数会调用evbuffer\_read函数，把数据从socket fd中读取到evbuffer中。然后再调用用户在bufferevent\_setcb函数中设置的读事件回调函数。所以，当用户的读事件回调函数被调用时，数据已经在evbuffer中了，用户拿来就用，无需调用read这类会阻塞的函数。

下面看一下bufferevent\_readcb函数的具体实现。

static void
    
    bufferevent_readcb(evutil_socket_t fd, short event, void *arg)
    
    {
    
    struct bufferevent *bufev = arg;
    
    struct bufferevent_private *bufev_p =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    struct evbuffer *input;
    
    int res = 0;
    
    short what = BEV_EVENT_READING;
    
    ev_ssize_t howmuch = -1, readmax=-1;
    
    
    _bufferevent_incref_and_lock(bufev);
    
    
    if (event == EV_TIMEOUT) {
    
    /* Note that we only check for event==EV_TIMEOUT. If
    
    * event==EV_TIMEOUT|EV_READ, we can safely ignore the
    
    * timeout, since a read has occurred */
    
    what |= BEV_EVENT_TIMEOUT;
    
    goto error;
    
    }
    
    
    input = bufev->input;
    
    
    
    //用户设置了高水位
    
    if (bufev->wm_read.high != 0) {
    
    howmuch = bufev->wm_read.high - evbuffer_get_length(input);
    
    /* we somehow lowered the watermark, stop reading */
    
    if (howmuch <= 0) {
    
    bufferevent_wm_suspend_read(bufev);
    
    goto done;
    
    }
    
    }
    
    
    //因为用户可以限速，所以这么要检测最大的可读大小。
    
    //如果没有限速的话，那么将返回16384字节，即16K
    
    //默认情况下是没有限速的。
    
    readmax = _bufferevent_get_read_max(bufev_p);
    
    if (howmuch < 0 || howmuch > readmax) /* The use of -1 for "unlimited"
    
    * uglifies this code. XXXX */
    
    howmuch = readmax;
    
    
    //一些原因导致读 被挂起，比如加锁了。
    
    if (bufev_p->read_suspended)
    
    goto done;
    
    
    //解冻，使得可以在input的后面追加数据
    
    evbuffer_unfreeze(input, 0);
    
    res = evbuffer_read(input, fd, (int)howmuch); //从socket fd中读取数据
    
    evbuffer_freeze(input, 0);//冻结
    
    
    if (res == -1) {
    
    int err = evutil_socket_geterror(fd);
    
    if (EVUTIL_ERR_RW_RETRIABLE(err))//EINTER or EAGAIN
    
    goto reschedule;
    
    
    //不是 EINTER or EAGAIN 这两个可以重试的错误，那么就应该是其他致命的错误
    
    //此时，应该报告给用户
    
    what |= BEV_EVENT_ERROR;/**< unrecoverable error encountered */
    
    } else if (res == 0) {//断开了连接
    
    what |= BEV_EVENT_EOF;
    
    }
    
    
    if (res <= 0)
    
    goto error;
    
    
    //速率相关的操作
    
    _bufferevent_decrement_read_buckets(bufev_p, res);
    
    
    
    //evbuffer的数据量大于低水位值。
    
    if (evbuffer_get_length(input) >= bufev->wm_read.low)
    
    _bufferevent_run_readcb(bufev);//调用用户设置的回调函数
    
    
    goto done;
    
    
    reschedule:
    
    goto done;
    
    
    error:
    
    //把监听可读事件的event从event_base的事件队列中删除掉.event_del
    
    bufferevent_disable(bufev, EV_READ);//会调用be_socket_disable函数
    
    _bufferevent_run_eventcb(bufev, what);//会调用用户设置的错误处理函数
    
    
    done:
    
    _bufferevent_decref_and_unlock(bufev);
    
    }

细心的读者可能会发现：对用户的读事件回调函数的触发是边缘触发的。这也就要求，在回调函数中，用户应该尽可能地把evbuffer的所有数据都读出来。如果想等到下一次回调时再读，那么需要等到下一次socketfd接收到数据才会触发用户的回调函数。如果之后socket fd一直收不到任何数据，那么即使evbuffer还有数据，用户的回调函数也不会被调用了。

# **处理写事件：** #

对一个可读事件进行监听是比较容易的，但对于一个可写事件进行监听则比较困难。为什么呢？因为可读监听是监听fd的读缓冲区是否有数据了，如果没有数据那么就一直等待。对于可写，首先要明白“什么是可写”，可写就是fd的写缓冲区(这个缓冲区在内核)还没满，可以往里面放数据。这就有一个问题，如果写缓冲区没有满，那么就一直是可写状态。如果一个event监听了可写事件，那么这个event就会一直被触发（死循环）。因为一般情况下，如果不是发大量的数据这个写缓冲区是不会满的。

也就是说，不能监听可写事件。但我们确实要往fd中写数据，那怎么办？Libevent的做法是：当我们确实要写入数据时，才监听可写事件。也就是说我们调用bufferevent\_write写入数据时，Libevent才会把监听可写事件的那个event注册到event\_base中。当Libevent把数据都写入到fd的缓冲区后，Libevent又会把这个event从event\_base中删除。比较烦琐。

bufferevent\_writecb函数不仅仅要处理上面说到的那个问题，还要处理另外一个坑爹的问题。那就是：判断socket fd是不是已经连接上服务器了。这是因为这个socket fd是非阻塞的，所以它调用connect时，可能还没连接上就返回了。对于非阻塞socket fd，一般是通过判断这个socket是否可写，从而得知这个socket是否已经连接上服务器。如果可写，那么它就已经成功连接上服务器了。这个问题，这里先提一下，[后面][Link 3]会详细讲。

同前面的监听可读一样，Libevent是在bufferevent\_socket\_new函数设置可写的回调函数，为bufferevent\_writecb。

//bufferevent_sock.c文件
    
    static void
    
    bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
    
    {
    
    struct bufferevent *bufev = arg;
    
    struct bufferevent_private *bufev_p =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    int res = 0;
    
    short what = BEV_EVENT_WRITING;
    
    int connected = 0;
    
    ev_ssize_t atmost = -1;
    
    
    _bufferevent_incref_and_lock(bufev);
    
    
    if (event == EV_TIMEOUT) {
    
    /* Note that we only check for event==EV_TIMEOUT. If
    
    * event==EV_TIMEOUT|EV_WRITE, we can safely ignore the
    
    * timeout, since a read has occurred */
    
    what |= BEV_EVENT_TIMEOUT;
    
    goto error;
    
    }
    
    
    ...//判断这个socket是否已经连接上服务器了
    
    
    
    //用户可能设置了限速，如果没有限速，那么atmost将返回16384(16K)
    
    atmost = _bufferevent_get_write_max(bufev_p);
    
    
    //一些原因导致写被挂起来了
    
    if (bufev_p->write_suspended)
    
    goto done;
    
    
    //如果evbuffer有数据可以写到sockfd中
    
    if (evbuffer_get_length(bufev->output)) {
    
    //解冻链表头
    
    evbuffer_unfreeze(bufev->output, 1);
    
    //将output这个evbuffer的数据写到socket fd 的缓冲区中
    
    //会把已经写到socket fd缓冲区的数据，从evbuffer中删除
    
    res = evbuffer_write_atmost(bufev->output, fd, atmost);
    
    evbuffer_freeze(bufev->output, 1);
    
    
    if (res == -1) {
    
    int err = evutil_socket_geterror(fd);
    
    if (EVUTIL_ERR_RW_RETRIABLE(err))//可以恢复的错误。一般是EINTR或者EAGAIN
    
    goto reschedule;
    
    what |= BEV_EVENT_ERROR;
    
    } else if (res == 0) {//该socket已经断开连接了
    
    what |= BEV_EVENT_EOF;
    
    }
    
    if (res <= 0)
    
    goto error;
    
    }
    
    
    //如果把写缓冲区的数据都写完成了。为了防止event_base不断地触发可写
    
    //事件，此时要把这个监听可写的event删除。
    
    //前面的atmost限制了一次最大的可写数据。如果还没写所有的数据
    
    //那么就不能delete这个event，而是要继续监听可写事情，知道把所有的
    
    //数据都写到socket fd中。
    
    if (evbuffer_get_length(bufev->output) == 0) {
    
    event_del(&bufev->ev_write);
    
    }
    
    
    
    //如果evbuffer里面的数据量已经写得七七八八了，小于设置的低水位值，那么
    
    //就会调用用户设置的写事件回调函数
    
    if ((res || !connected) &&
    
    evbuffer_get_length(bufev->output) <= bufev->wm_write.low) {
    
    _bufferevent_run_writecb(bufev);
    
    }
    
    
    goto done;
    
    
    reschedule:
    
    if (evbuffer_get_length(bufev->output) == 0) {
    
    event_del(&bufev->ev_write);
    
    }
    
    goto done;
    
    
    error:
    
    bufferevent_disable(bufev, EV_WRITE);//有错误。把这个写event删除
    
    _bufferevent_run_eventcb(bufev, what);
    
    
    done:
    
    _bufferevent_decref_and_unlock(bufev);
    
    }

上面代码的逻辑比较清晰，调用evbuffer\_write\_atmost函数把数据从evbuffer中写到evbuffer缓冲区中，此时要注意函数的返回值，因为可能写的时候发生错误。如果发生了错误，就要调用用户设置的event回调函数(网上也有人称其为错误处理函数)。

之后，还要判断evbuffer的数据是否已经全部写到socket 的缓冲区了。如果已经全部写了，那么就要把监听写事件的event从event\_base的插入队列中删除。如果还没写完，那么就不能删除，因为还要继续监听可写事件，下次接着写。

现在来看一下，把监听写事件的event从event\_base的插入队列中删除后，如果下次用户有数据要写的时候，怎么把这个event添加到event\_base的插入队列。

用户一般是通过bufferevent\_write函数把数据写入到evbuffer(写入evbuffer后，接着就会被写入socket，所以调用bufferevent\_write就相当于把数据写入到socket。)。而这个bufferevent\_write函数是直接调用evbuffer\_add函数的。函数evbuffer\_add没有调用什么可疑的函数，能够把监听可写的event添加到event\_base中。唯一的可能就是那个回调函数。对就是evbuffer的回调函数。关于evbuffer的回调函数，可以参考[这里][Link 2]。

//bufferevent.c文件
    
    int
    
    bufferevent_write(struct bufferevent *bufev, const void *data, size_t size)
    
    {
    
    if (evbuffer_add(bufev->output, data, size) == -1)
    
    return (-1);
    
    
    return 0;
    
    }
    
    
    
    //buffer.c文件
    
    int
    
    evbuffer_add(struct evbuffer *buf, const void *data_in, size_t datlen)
    
    {
    
    ...
    
    
    out:
    
    evbuffer_invoke_callbacks(buf);//调用回调函数
    
    result = 0;
    
    done:
    
    return result;
    
    }

还记得本文前面的bufferevent\_socket\_new函数吗？该函数里面会有

evbuffer_add_cb(bufev->output,bufferevent_socket_outbuf_cb, bufev);

当bufferevent的写缓冲区output的数据发生变化时，函数bufferevent\_socket\_outbuf\_cb就会被调用。现在马上飞到这个函数。

//bufferevent_sock.c文件
    
    static void
    
    bufferevent_socket_outbuf_cb(struct evbuffer *buf,
    
    const struct evbuffer_cb_info *cbinfo,
    
    void *arg)
    
    {
    
    struct bufferevent *bufev = arg;
    
    struct bufferevent_private *bufev_p =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    
    if (cbinfo->n_added && //evbuffer添加了数据
    
    (bufev->enabled & EV_WRITE) && //默认情况下是enable EV_WRITE的
    
    !event_pending(&bufev->ev_write, EV_WRITE, NULL) &&//这个event已经被踢出event_base了
    
    !bufev_p->write_suspended) {//这个bufferevent的写并没有被挂起
    
    
    //把这个event添加到event_base中
    
    if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) == -1) {
    
    /* Should we log this? */
    
    }
    
    }
    
    }

这个函数首先进行一些判断，满足条件后就会把这个监听写事件的event添加到event\_base中。其中event\_pending函数就是判断这个bufev->ev\_write是否已经被event\_base删除了。关于event\_pending，可以参考[这里][Link 4]。

对于bufferevent\_write，初次使用该函数的读者可能会有疑问：调用该函数后，参数data指向的内存空间能不能马上释放，还是要等到Libevent把data指向的数据都写到socket 缓存区才能删除？其实，从[前一篇博文][Link 5]可以看到，evbuffer\_add是直接复制一份用户要发送的数据到evbuffer缓存区的。所以，调用完bufferevent\_write，就可以马上释放参数data指向的内存空间。

网上的关于Libevent的一些使用例子，包括我写的《 [Libevent使用例子，从简单到复杂][Libevent 2]》，都是在主线程中调用bufferevent\_write函数写入数据的。从上面的分析可以得知，是可以马上把监听可写事件的event添加到event\_base中。如果是在次线程调用该函数写入数据呢？此时，主线程可能还睡眠在poll、epoll这类的多路IO复用函数上。这种情况下能不能及时唤醒主线程呢？其实是可以的，只要你的Libevent在一开始使用了线程功能。具体的分析过程可以参考《[evthread\_notify\_base通知主线程][evthread_notify_base]》。上面代码中的be\_socket\_add会调用event\_add，而在次线程调用event\_add就会调用evthread\_notify\_base通知主线程。

# **bufferevent\_socket\_connect：** #

用户可以在调用bufferevent\_socket\_new函数时，传一个-1作为socket的文件描述符，然后调用bufferevent\_socket\_connect函数连接服务器，无需自己写代码调用connect函数连接服务器。

bufferevent\_socket\_connect函数会调用socket函数申请一个套接字fd，然后把这个fd设置成非阻塞的(这就导致了一些坑爹的事情)。接着就connect服务器，因为该socket fd是非阻塞的，所以不会等待，而是马上返回，连接这工作交给内核来完成。所以，返回后这个socket还没有真正连接上服务器。那么什么时候连接上呢？内核又是怎么通知通知用户呢？

一般来说，当可以往socket fd写东西了，那就说明已经连接上了。也就是说这个socket fd变成可写状态，就连接上了。

所以，对于“非阻塞connect”比较流行的做法是：用select或者poll这类多路IO复用函数监听该socket的可写事件。当这个socket触发了可写事件，然后再对这个socket调用getsockopt函数，做进一步的判断。

Libevent也是这样实现的，下面来看一下bufferevent\_socket\_connect函数。

//bufferevent_sock.c文件
    
    int
    
    bufferevent_socket_connect(struct bufferevent *bev,
    
    struct sockaddr *sa, int socklen)
    
    {
    
    struct bufferevent_private *bufev_p =
    
    EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
    
    
    evutil_socket_t fd;
    
    int r = 0;
    
    int result=-1;
    
    int ownfd = 0;
    
    
    _bufferevent_incref_and_lock(bev);
    
    
    if (!bufev_p)
    
    goto done;
    
    
    
    fd = bufferevent_getfd(bev);
    
    if (fd < 0) {//该bufferevent还没有设置fd
    
    if (!sa)
    
    goto done;
    
    fd = socket(sa->sa_family, SOCK_STREAM, 0);
    
    if (fd < 0)
    
    goto done;
    
    if (evutil_make_socket_nonblocking(fd)<0)//设置为非阻塞
    
    goto done;
    
    ownfd = 1;
    
    }
    
    if (sa) {
    
    r = evutil_socket_connect(&fd, sa, socklen);//非阻塞connect
    
    if (r < 0)
    
    goto freesock;
    
    }
    
    ...
    
    
    //为bufferevent里面的两个event设置监听的fd
    
    //后面会调用bufferevent_enable
    
    bufferevent_setfd(bev, fd);
    
    
    if (r == 0) {//暂时还没连接上，因为fd是非阻塞的
    
    //此时需要监听可写事件，当可写了，并且没有错误的话，就成功连接上了
    
    if (! be_socket_enable(bev, EV_WRITE)) {
    
    bufev_p->connecting = 1;//标志这个sockfd正在连接
    
    result = 0;
    
    goto done;
    
    }
    
    } else if (r == 1) {//已经连接上了
    
    /* The connect succeeded already. How very BSD of it. */
    
    result = 0;
    
    bufev_p->connecting = 1;
    
    event_active(&bev->ev_write, EV_WRITE, 1);//手动激活这个event
    
    } else {// connection refused
    
    /* The connect failed already. How very BSD of it. */
    
    bufev_p->connection_refused = 1;
    
    bufev_p->connecting = 1;
    
    result = 0;
    
    event_active(&bev->ev_write, EV_WRITE, 1);//手动激活这个event
    
    }
    
    
    goto done;
    
    
    freesock:
    
    _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);//出现错误
    
    if (ownfd)
    
    evutil_closesocket(fd);
    
    done:
    
    _bufferevent_decref_and_unlock(bev);
    
    return result;
    
    }

这个函数比较多错误处理的代码，大致看一下就行了。有几个地方要注意，即使connect的时候被拒绝，或者已经连接上了，都会手动激活这个event。一个event即使没有加入event\_base，也是可以手动激活的。具体原理参考[这里][Link 6]。

无论是手动激活event，或者监听到这个event可写了，都是会调用bufferevent\_writecb函数。现在再次看一下该函数，只看connect部分。

//bufferevent_sock.c文件
    
    static void
    
    bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
    
    {
    
    struct bufferevent_private *bufev_p =
    
    EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
    
    int connected = 0;
    
    
    _bufferevent_incref_and_lock(bufev);
    
    
    ...
    
    //正在连接。因为这个sockfd可能是非阻塞的，所以可能之前的connect还没
    
    //连接上。而判断该sockfd是否成功连接上了的一个方法是判断这个sockfd是否可写
    
    if (bufev_p->connecting) {
    
    //c等于1，说明已经连接成功
    
    //c等于0，说明还没连接上
    
    //c等于-1，说明发生错误
    
    int c = evutil_socket_finished_connecting(fd);
    
    
    
    if (bufev_p->connection_refused) {//在bufferevent_socket_connect中被设置
    
    bufev_p->connection_refused = 0;
    
    c = -1;
    
    }
    
    
    if (c == 0)//还没连接上，继续监听可写吧
    
    goto done;
    
    
    
    //错误，或者已经连接上了
    
    bufev_p->connecting = 0;//修改标志值
    
    
    if (c < 0) {//错误
    
    event_del(&bufev->ev_write);
    
    event_del(&bufev->ev_read);
    
    _bufferevent_run_eventcb(bufev, BEV_EVENT_ERROR);
    
    goto done;
    
    
    } else {//连接上了。
    
    connected = 1;
    
    ...//win32
    
    
    //居然会调用用户设置的错误处理函数。太神奇了
    
    _bufferevent_run_eventcb(bufev,
    
    BEV_EVENT_CONNECTED);
    
    if (!(bufev->enabled & EV_WRITE) || //默认都是enable EV_WRITE的
    
    bufev_p->write_suspended) {
    
    event_del(&bufev->ev_write);//不再需要监听可写。因为已经连接上了
    
    goto done;
    
    }
    
    }
    
    }
    
    
    ...
    
    
    
    done:
    
    _bufferevent_decref_and_unlock(bufev);
    
    }

可以看到无论是connect被拒绝、发生错误或者连接上了，都在这里做统一的处理。

如果已经连接上了，那么会调用用户设置event回调函数(网上也称之为错误处理函数)，通知用户已经连接上了。并且，还会把监听可写事件的event从event\_base中删除，其理由在前面已经说过了。

函数evutil\_socket\_finished\_connecting会检查这个socket，从而得知这个socket是处于什么状态。在bufferevent\_socket\_connect函数中，出现的一些错误，比如被拒绝，也是能通过这个函数检查出来的。所以可以在这里做统一的处理。该函数的内部是使用。贴一下这个函数的代码吧。

//evutil.c文件
    
    //Return 1 for connected, 0 for not yet, -1 for error.
    
    int
    
    evutil_socket_finished_connecting(evutil_socket_t fd)
    
    {
    
    int e;
    
    ev_socklen_t elen = sizeof(e);
    
    
    //用来检测这个fd是否已经连接上了，这个fd是非阻塞的
    
    //如果e的值被设为0，那么就说明连接上了。
    
    //否则e被设置为对应的错误值。
    
    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&e, &elen) < 0)
    
    return -1;
    
    
    if (e) {
    
    if (EVUTIL_ERR_CONNECT_RETRIABLE(e))//还没连接上
    
    return 0;
    
    EVUTIL_SET_SOCKET_ERROR(e);
    
    return -1;
    
    }
    
    
    return 1;
    
    }

本文来自 luotuo44 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/luotuo44/article/details/39344743?utm\_source=copy

[Libevent]: http://blog.csdn.net/luotuo44/article/details/38501341
[Libevent 1]: http://blog.csdn.net/luotuo44/article/details/34416429
[evbuffer]: http://blog.csdn.net/luotuo44/article/details/39290721
[evbuffer 1]: http://blog.csdn.net/luotuo44/article/details/39325447
[Link 1]: http://blog.csdn.net/luotuo44/article/details/39344743#t7
[event]: http://blog.csdn.net/luotuo44/article/details/38637671
[Link 2]: http://blog.csdn.net/luotuo44/article/details/39325447#t6
[Link 3]: http://blog.csdn.net/luotuo44/article/details/39344743#t8
[Link 4]: http://blog.csdn.net/luotuo44/article/details/38739549#t1
[Link 5]: http://blog.csdn.net/luotuo44/article/details/39290721#t2
[Libevent 2]: http://blog.csdn.net/luotuo44/article/details/39670221
[evthread_notify_base]: http://blog.csdn.net/luotuo44/article/details/38556059
[Link 6]: http://blog.csdn.net/luotuo44/article/details/38739549#t2