六、event_accept函数

最新推荐文章于 2023-09-12 16:40:50 发布

白色的乌云

最新推荐文章于 2023-09-12 16:40:50 发布

阅读量1.2k

点赞数

分类专栏： Haproxy源码分析文章标签： haproxy 源码分析

本文链接：https://blog.csdn.net/solaris_zune/article/details/8861526

版权

Haproxy源码分析专栏收录该内容

10 篇文章 4 订阅

订阅专栏

此函数对应于Listner在有新链接的时候调用的read函数。

[src/client.c]event_accept()
int event_accept(int fd) {
	struct listener *l = fdtab[fd].owner;//这个值从前一部分可知
	struct proxy *p = (struct proxy *)l->private; //这是在解析配置文件时赋予
	struct session *s;
	struct http_txn *txn;
	struct task *t;
	int cfd;
	int max_accept = global.tune.maxaccept;

fdtab[fd].owner的值从上篇文章可以知道是对应的listener。Listener的->private成员则是在初始化listener的时候设置为PROXY，这处于配置文件解析过程。

[src/client.c]event_accept()
	if (p->fe_sps_lim) {
		//front end，session per second以及limit的简写
		int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
		if (max_accept > max)
			max_accept = max;
		//得到当前秒内还能accept多少个链接
	}

计算当前秒内还允许接收多少链接，如果允许的链接大于全局配置的最大值，那么设置为全局配置中的最大值。

[src/freq_ctr.c]freq_ctr_remain()
unsigned int freq_ctr_remain(struct freq_ctr *ctr, unsigned int freq, unsigned int pend)
{
	unsigned int curr, past;
	unsigned int age;

	past = 0;
	curr = 0;		
	age = now.tv_sec - ctr->curr_sec;

	if (likely(age <= 1)) {
		past = ctr->curr_ctr;
		if (likely(!age)) {
			curr = past;
			past = ctr->prev_ctr;
		}
		curr += mul32hi(past, ~curr_sec_ms_scaled);
	}
	curr += pend;

	if (curr >= freq)
		return 0;
	return freq - curr;
}

[include/common/standard.h]mul32hi()
static inline unsigned int mul32hi(unsigned int a, unsigned int b)
{
	return ((unsigned long long)a * b) >> 32;
}

计算上一次统计开始时间与当前时间的时间差(秒)，

如果大于1，那么直接不管上一次统计的数量，因为时间过了很久了，根本统计不出来，因此直接将pend的值和上限比较，然后返回相应的值。

对于不大于1的情况，除了最后一句，其他都很好理解。在时间更新那一篇中，可以知道curr_sec_ms_scaled的值是当前秒内毫秒数乘以一个因子，这个因子是2^32/1000，也就是说，如果是1000毫秒乘以这个因子的话，那么会得到2^32次方。实际上是有误差的，不过相比之下是可以忽略的，因为这是用于毫秒级的因子。

作者乘以这个因子是为了快速的计算出比例值。以下计算先从常规计算来说(非计算机)，2000 * (x / 1000)的意思是把2000分成1000份，取其中的x份的结果。若要取1000-x份的结果呢，当然是2000 * ((1000 – x) / 1000)。现在将分母乘以一个因子使其变为2^32，分子也要乘以相同的因子，才能保持比例不变，也就是需要乘以2^32/1000。比例式变为如下2000 * (x * 2^32 / 1000) / 2^32，2000 * ((1000-x) * 2 ^ 32 / 1000) / 2^32。

之所以这样做是计算机的工作方式对2^n的一些运算非常方便。以上的两个式子可以如下表示，2000 * (x * 2^32/1000) >> 32，2000 * (~x*2^32/1000) >> 32，经过修改之后的式子在计算机中的计算速度肯定要比修改之前的快多了，因为除法运算改为右移操作了，在第二个式子还将减法运算改成取反运算了。

虽然明白了作者要这样做的道理，但是为何作者要将上一时间段的数量乘以本段时间剩下的时间比例的结果作为当前时间段数量的一部分，还不太理解。

[src/client.c]event_accept()
	while (p->feconn < p->maxconn && actconn < global.maxconn && max_accept--) {
		struct sockaddr_storage addr;//使用sockadd_storge是为了兼容IPV6
		socklen_t laddr = sizeof(addr);
	
		//由于之前作者将fd设置为非阻塞，因此此处不会被阻塞住
		if ((cfd = accept(fd, (struct sockaddr *)&addr, &laddr)) == -1) {
			switch (errno) {
			case EAGAIN:
			case EINTR:
			case ECONNABORTED:
				return 0;	    /* nothing more to accept */
			case ENFILE:
				send_log(p, LOG_EMERG,
					 "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
					 p->id, maxfd);
				return 0;
			case EMFILE:
				send_log(p, LOG_EMERG,
					 "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
					 p->id, maxfd);
				return 0;
			case ENOBUFS:
			case ENOMEM:
				send_log(p, LOG_EMERG,
					 "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
					 p->id, maxfd);
				return 0;
			default:
				return 0;
			}
		}

		if (l->nbconn >= l->maxconn) {
			/* too many connections, we shoot this one and return.
			 * FIXME: it would be better to simply switch the listener's
			 * state to LI_FULL and disable the FD. We could re-enable
			 * it upon fd_delete(), but this requires all protocols to
			 * be switched.
			 */
			goto out_close;
		}

		if ((s = pool_alloc2(pool2_session)) == NULL) { /* disable this proxy for a while */
			Alert("out of memory in event_accept().\n");
			disable_listener(l);
			p->state = PR_STIDLE;
			goto out_close;
		}

		LIST_INIT(&s->back_refs);

		s->flags = 0;
		s->term_trace = 0;

		/* if this session comes from a known monitoring system, we want to ignore
		 * it as soon as possible, which means closing it immediately for TCP.
		 */
		if (addr.ss_family == AF_INET &&
		    p->mon_mask.s_addr &&
		    (((struct sockaddr_in *)&addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr) {
			if (p->mode == PR_MODE_TCP) {
				close(cfd);
				pool_free2(pool2_session, s);
				continue;
			}
			s->flags |= SN_MONITOR;
		}

作者说明，如果这链接是来自于一个已知的监控系统，那么我们尽可能快的忽略它，对于TCP来说就是尽快的关闭它，那为什么在TCP下将它直接关闭掉而不做信息交流呢？这是由于在TCP上只需要验证监听者存在即可，而对于http来说却不一样，http需要返回响应信息。

为什么作者先分配内存，然后根据检查结果决定是否释放内存，而不是先检查，然后再决定是否需要分配内存。就如前面所说，这应该是作者的一种习惯吧，因为对于Linux内核的很多地方来说都是这样做的，那是为了防止在检查完之后由于内存不够导致调度而使内核的一些状态改变，因此在内核中一般先要分配资源，然后再做条件判断。而Haprox的作者正是Linux内核网络部分的一个维护者，因此这可能是他的一个习惯。

[src/client.c]event_accept()
		LIST_ADDQ(&sessions, &s->list);

		if ((t = task_new()) == NULL) { /* disable this proxy for a while */
			Alert("out of memory in event_accept().\n");
			disable_listener(l);
			p->state = PR_STIDLE;
			goto out_free_session;
		}

		s->cli_addr = addr;
		if (cfd >= global.maxsock) {
			Alert("accept(): not enough free sockets. Raise -n argument. Giving up.\n");
			goto out_free_task;
		}

链接完成之后，会创建对应的SESSION和TASK。

[src/client.c]event_accept()
		if ((fcntl(cfd, F_SETFL, O_NONBLOCK) == -1) ||
		    (setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY,
				(char *) &one, sizeof(one)) == -1)) {
			Alert("accept(): cannot set the socket in non blocking mode. Giving up\n");
			goto out_free_task;
		}

		if (p->options & PR_O_TCP_CLI_KA)
			setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));

		if (p->options & PR_O_TCP_NOLING)
			setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));

//如果熟悉的话，作者允许配置人员根据实际情况设置自己的发送和接收缓冲区以提高效率
		if (global.tune.client_sndbuf)
			setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf));

		if (global.tune.client_rcvbuf)
			setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf));

非阻塞和NODELAY都设置了，其他根据配置进行可选设置，需要说明的是，作者允许配置人员根据应用的实际情况调整TCP发送和接收缓冲区的大小。

[src/client.c]event_accept()
		t->process = l->handler;//l->handler也是在解析配置文件时设置为process_session
		t->context = s;
		t->nice = l->nice;

		s->task = t;
		s->listener = l;

		/* Note: initially, the session's backend points to the frontend.
		 * This changes later when switching rules are executed or
		 * when the default backend is assigned.
		 */
		s->be = s->fe = p;

		s->req = s->rep = NULL; /* will be allocated later */

每个TASK对应一个SESSION，其context为对应的SESSION，在TASK被调度运行时，他会用process成员对其对应的SESSION进行处理。任务优先级继承自对应的SESSION对应的LISTENER。

作者说明，在初始化阶段，会话的后端对应其前端。

[src/client.c]event_accept()
		s->si[0].state = s->si[0].prev_state = SI_ST_EST;
		s->si[0].err_type = SI_ET_NONE;
		s->si[0].err_loc = NULL;
		s->si[0].owner = t;
		s->si[0].update = stream_sock_data_finish;
		s->si[0].shutr = stream_sock_shutr;
		s->si[0].shutw = stream_sock_shutw;
		s->si[0].chk_rcv = stream_sock_chk_rcv;
		s->si[0].chk_snd = stream_sock_chk_snd;
		s->si[0].connect = NULL;
		s->si[0].iohandler = NULL;
		s->si[0].fd = cfd;
		s->si[0].flags = SI_FL_NONE | SI_FL_CAP_SPLTCP; /* TCP splicing capable */
		if (s->fe->options2 & PR_O2_INDEPSTR)
			s->si[0].flags |= SI_FL_INDEP_STR;
		s->si[0].exp = TICK_ETERNITY;

		s->si[1].state = s->si[1].prev_state = SI_ST_INI;
		s->si[1].err_type = SI_ET_NONE;
		s->si[1].err_loc = NULL;
		s->si[1].owner = t;
		s->si[1].update = stream_sock_data_finish;
		s->si[1].shutr = stream_sock_shutr;
		s->si[1].shutw = stream_sock_shutw;
		s->si[1].chk_rcv = stream_sock_chk_rcv;
		s->si[1].chk_snd = stream_sock_chk_snd;
		s->si[1].connect = tcpv4_connect_server;
		s->si[1].iohandler = NULL;
		s->si[1].exp = TICK_ETERNITY;
		s->si[1].fd = -1; /* just to help with debugging */
		s->si[1].flags = SI_FL_NONE;

SESSION的si成员是stream interface的两成员数组，session->si[0]对应于与客户端的连接，此时haproxy作为后台；session->si[1]对应于与真正后台的连接，此时haproxy作为客户端。

si[0]不需要connect函数。对于session->si[0]来说，其拥有者为对应的session的task，相关的函数指针成员为stream_sock_*()。

si[1]需要connect函数，此函数为tcpv4_connect_server，其他函数指针成员与si[0]一样。此时其对应的fd并没有，因为与真正后台的连接还没有建立，所以将其值设置为-1以便于调试。对于session->si[1]来说，其拥有者为对应的session的task。

最后需要说明的就是stream interface是很重要的结构体，如果说前端PROXY和后端PROXY是一种整体概念，此处的stream interface就是实现上的前端和后端与连接直接相关的那部分。stream interface的初始化在event_accept函数中。

[src/client.c]event_accept()
		if (s->be->options2 & PR_O2_INDEPSTR)
			s->si[1].flags |= SI_FL_INDEP_STR;

		s->srv = s->prev_srv = s->srv_conn = NULL;
		s->pend_pos = NULL;
		s->conn_retries = s->be->conn_retries;

		/* init store persistence */
		s->store_count = 0;

		/* FIXME: the logs are horribly complicated now, because they are
		 * defined in <p>, <p>, and later <be> and <be>.
		 */

		if (s->flags & SN_MONITOR)
			s->logs.logwait = 0;
		else
			s->logs.logwait = p->to_log;

		if (s->logs.logwait & LW_REQ)
			//根据是否记录http请求选择日志记录函数
			s->do_log = http_sess_log;
		else
			s->do_log = tcp_sess_log;

		/* default error reporting function, may be changed by analysers */
		s->srv_error = default_srv_error;

		s->logs.accept_date = date; /* user-visible date for logging */
		s->logs.tv_accept = now;  /* corrected date for internal use */
		tv_zero(&s->logs.tv_request);
		s->logs.t_queue = -1;
		s->logs.t_connect = -1;
		s->logs.t_data = -1;
		s->logs.t_close = 0;
		s->logs.bytes_in = s->logs.bytes_out = 0;
		s->logs.prx_queue_size = 0;  /* we get the number of pending conns before us */
		s->logs.srv_queue_size = 0; /* we will get this number soon */

		s->data_source = DATA_SRC_NONE;

		s->uniq_id = totalconn;
		proxy_inc_fe_ctr(l, p);	/* note: cum_beconn will be increased once assigned */
		//前端增加对当前当前秒的连接数记录

		txn = &s->txn;
		/* Those variables will be checked and freed if non-NULL in
		 * session.c:session_free(). It is important that they are
		 * properly initialized.
		 */
		txn->sessid = NULL;
		txn->srv_cookie = NULL;
		txn->cli_cookie = NULL;
		txn->uri = NULL;
		txn->req.cap = NULL;
		txn->rsp.cap = NULL;
		txn->hdr_idx.v = NULL;
		txn->hdr_idx.size = txn->hdr_idx.used = 0;

		if (p->mode == PR_MODE_HTTP) {
			/* the captures are only used in HTTP frontends */
			if (p->nb_req_cap > 0 &&
			    (txn->req.cap = pool_alloc2(p->req_cap_pool)) == NULL)
					goto out_fail_reqcap;	/* no memory */

			if (p->nb_rsp_cap > 0 &&
			    (txn->rsp.cap = pool_alloc2(p->rsp_cap_pool)) == NULL)
					goto out_fail_rspcap;	/* no memory */
		}

		if (p->acl_requires & ACL_USE_L7_ANY) {
			/* we have to allocate header indexes only if we know
			 * that we may make use of them. This of course includes
			 * (mode == PR_MODE_HTTP).
			 */
			txn->hdr_idx.size = MAX_HTTP_HDR;

			if ((txn->hdr_idx.v = pool_alloc2(p->hdr_idx_pool)) == NULL)
				goto out_fail_idx; /* no memory */

			/* and now initialize the HTTP transaction state */
			http_init_txn(s);
		}

初始化SESSION对应的日志系统，如果SESSION用于处理HTTP，还需要初始化对应的txn结构，这主要适用于做头部分析的，当然包括通过Cookie来定位对应的SERVER。

[src/client.c]event_accept()
		if ((p->mode == PR_MODE_TCP || p->mode == PR_MODE_HTTP)
		    && (p->logfac1 >= 0 || p->logfac2 >= 0)) {
			if (p->to_log) {
				/* we have the client ip */
				if (s->logs.logwait & LW_CLIP)
					if (!(s->logs.logwait &= ~LW_CLIP))
						s->do_log(s);
			}
			else if (s->cli_addr.ss_family == AF_INET) {
				char pn[INET_ADDRSTRLEN], sn[INET_ADDRSTRLEN];

				if (!(s->flags & SN_FRT_ADDR_SET))
					get_frt_addr(s);

				if (inet_ntop(AF_INET, (const void *)&((struct sockaddr_in *)&s->frt_addr)->sin_addr,
					      sn, sizeof(sn)) &&
				    inet_ntop(AF_INET, (const void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
					      pn, sizeof(pn))) {
					send_log(p, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n",
						 pn, ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port),
						 sn, ntohs(((struct sockaddr_in *)&s->frt_addr)->sin_port),
						 p->id, (p->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
				}
			}
			else {
				char pn[INET6_ADDRSTRLEN], sn[INET6_ADDRSTRLEN];

				if (!(s->flags & SN_FRT_ADDR_SET))
					get_frt_addr(s);

				if (inet_ntop(AF_INET6, (const void *)&((struct sockaddr_in6 *)&s->frt_addr)->sin6_addr,
					      sn, sizeof(sn)) &&
				    inet_ntop(AF_INET6, (const void *)&((struct sockaddr_in6 *)&s->cli_addr)->sin6_addr,
					      pn, sizeof(pn))) {
					send_log(p, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n",
						 pn, ntohs(((struct sockaddr_in6 *)&s->cli_addr)->sin6_port),
						 sn, ntohs(((struct sockaddr_in6 *)&s->frt_addr)->sin6_port),
						 p->id, (p->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
				}
			}
		}

		if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
			int len;

			if (!(s->flags & SN_FRT_ADDR_SET))
				get_frt_addr(s);

			if (s->cli_addr.ss_family == AF_INET) {
				char pn[INET_ADDRSTRLEN];
				inet_ntop(AF_INET,
					  (const void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
					  pn, sizeof(pn));

				len = sprintf(trash, "%08x:%s.accept(%04x)=%04x from [%s:%d]\n",
					      s->uniq_id, p->id, (unsigned short)fd, (unsigned short)cfd,
					      pn, ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port));
			}
			else {
				char pn[INET6_ADDRSTRLEN];
				inet_ntop(AF_INET6,
					  (const void *)&((struct sockaddr_in6 *)(&s->cli_addr))->sin6_addr,
					  pn, sizeof(pn));

				len = sprintf(trash, "%08x:%s.accept(%04x)=%04x from [%s:%d]\n",
					      s->uniq_id, p->id, (unsigned short)fd, (unsigned short)cfd,
					      pn, ntohs(((struct sockaddr_in6 *)(&s->cli_addr))->sin6_port));
			}

			if (write(1, trash, len) < 0) /* shut gcc warning */;
		}

以上主要是对链接的源和目的IP进行一个日志记录，如果有要求的话。

[src/client.c]event_accept()
		if ((s->req = pool_alloc2(pool2_buffer)) == NULL)
			goto out_fail_req; /* no memory */

		s->req->size = global.tune.bufsize;
		buffer_init(s->req);
		s->req->prod = &s->si[0];
		s->req->cons = &s->si[1];
		s->si[0].ib = s->si[1].ob = s->req;

		s->req->flags |= BF_READ_ATTACHED; /* the producer is already connected */

		if (p->mode == PR_MODE_HTTP)
			s->req->flags |= BF_READ_DONTWAIT; /* one read is usually enough */

		/* activate default analysers enabled for this listener */
		s->req->analysers = l->analysers;

		/* note: this should not happen anymore since there's always at least the switching rules */
		if (!s->req->analysers) {
			buffer_auto_connect(s->req);  /* don't wait to establish connection */
			buffer_auto_close(s->req);    /* let the producer forward close requests */
		}

		s->req->rto = s->fe->timeout.client;
		s->req->wto = s->be->timeout.server;
		s->req->cto = s->be->timeout.connect;

分配用于请求的缓冲区并进行初始化，然后将session的请求方的生产者(stream interface)设置为session->si[0]，将消费者设置为session->si[1]。根据前面很容易理解，与客户端连接的fd是放在si[0]中，与后端连接的fd是在si[1]中。对于stream interface来说，需要将其成员中的输入输出缓冲区设置一下。设置标志用于表明请求部分的输入连接是已经附接上了。

作者说对于http请求来说，往往读取一次的数据就已经足够了，也就是说，读取一次一般都可以把一个http请求的全部数据读取完成，因此每次读取完成都唤醒相应的task，因此给请求缓冲区设置一个标志位用于表示此种类型，BF_READ_DONTWAIT。

对于请求数据需要先做什么处理然后再往后传送，这个处理规则默认来自于listener。对于默认处理方式不存在的数据，将会允许相应的链接直接建立以传送数据，不过作者注释说这种可能已经不存在了，因为现在肯定都会存在相应的处理方式。

将请求部分的缓冲区的读超时设置为session前端设置的客户端超时时间，写超时设置为后端后端服务器指定的超时时间，连接超时为后端的连接超时。

对于读写的意思，在这儿读应该表示的是读取数据到此buffer，写表示将buffer的数据写出去。

[src/client.c]event_accept()
		if ((s->rep = pool_alloc2(pool2_buffer)) == NULL)
			goto out_fail_rep; /* no memory */

		s->rep->size = global.tune.bufsize;
		buffer_init(s->rep);
		s->rep->prod = &s->si[1];
		s->rep->cons = &s->si[0];
		s->si[0].ob = s->si[1].ib = s->rep;
		s->rep->analysers = 0;

		if (s->fe->options2 & PR_O2_NODELAY) {
			s->req->flags |= BF_NEVER_WAIT;
			s->rep->flags |= BF_NEVER_WAIT;
		}

		s->rep->rto = s->be->timeout.server;
		s->rep->wto = s->fe->timeout.client;
		s->rep->cto = TICK_ETERNITY;

		s->req->rex = TICK_ETERNITY;
		s->req->wex = TICK_ETERNITY;
		s->req->analyse_exp = TICK_ETERNITY;
		s->rep->rex = TICK_ETERNITY;
		s->rep->wex = TICK_ETERNITY;
		s->rep->analyse_exp = TICK_ETERNITY;
		t->expire = TICK_ETERNITY;

分配并初始化好响应缓冲区。

[src/client.c]event_accept()
		fd_insert(cfd);
		fdtab[cfd].owner = &s->si[0];
		fdtab[cfd].state = FD_STREADY;
		fdtab[cfd].flags = FD_FL_TCP | FD_FL_TCP_NODELAY;
		if (p->options & PR_O_TCP_NOLING)
			fdtab[cfd].flags |= FD_FL_TCP_NOLING;

		fdtab[cfd].cb[DIR_RD].f = l->proto->read;
		fdtab[cfd].cb[DIR_RD].b = s->req;
		fdtab[cfd].cb[DIR_WR].f = l->proto->write;
		fdtab[cfd].cb[DIR_WR].b = s->rep;
		fdinfo[cfd].peeraddr = (struct sockaddr *)&s->cli_addr;
		fdinfo[cfd].peerlen = sizeof(s->cli_addr);

将与客户端链接的fd插入fdtab中，那么与服务端链接的fd呢？与服务端链接还没有建立，因此没有fd可以插入，但是之前对si[1]设置了connect函数为tcpv4_connect_server，因此能预测到与后端链接fd的建立于将会在那个函数中，需要提一下的是客户端的读写函数式从对应listener的proto中来的，也就是与协议相关的。

之前在listener的初始化中看到listener的fd在fdtab中的拥有者是LISTENER，此处对于与客户端相连接的fd在fdtab中的拥有者是对应的stream interface。listener fd没有保存对应的远程地址，此处保存了。

[src/client.c]event_accept()
		if ((p->mode == PR_MODE_HTTP && (s->flags & SN_MONITOR)) ||
		    (p->mode == PR_MODE_HEALTH && (p->options & PR_O_HTTP_CHK))) {
			/* Either we got a request from a monitoring system on an HTTP instance,
			 * or we're in health check mode with the 'httpchk' option enabled. In
			 * both cases, we return a fake "HTTP/1.0 200 OK" response and we exit.
			 */
			struct chunk msg;
			chunk_initstr(&msg, "HTTP/1.0 200 OK\r\n\r\n");
			stream_int_retnclose(&s->si[0], &msg); /* forge a 200 response */
			s->req->analysers = 0;
			t->expire = s->rep->wex;
		}
		else if (p->mode == PR_MODE_HEALTH) {  /* health check mode, no client reading */
			struct chunk msg;
			chunk_initstr(&msg, "OK\n");
			stream_int_retnclose(&s->si[0], &msg); /* forge an "OK" response */
			s->req->analysers = 0;
			t->expire = s->rep->wex;
		}
		else {
			EV_FD_SET(cfd, DIR_RD);
		}

对于监视器或者是健康监测的情况，都返回一个正确的信息，然后设定标志位以使链接会被关闭，

若此链接是正常的业务链接，那么将会对此fd调用EV_FD_SET(cfd,DIR_RD)，这是一个宏定义，#define EV_FD_SET(fd, ev) (cur_poller.set((fd), (ev)))，也就是调用当前poller的set函数。现在看一下sepoll的set函数。

[src/ev_sepoll.c]__fd_set()
REGPRM2 static int __fd_set(const int fd, int dir)
{
	unsigned int i;

#if DEBUG_DEV
	if (fdtab[fd].state == FD_STCLOSE) {
		fprintf(stderr, "sepoll.fd_set called on closed fd #%d.\n", fd);
		ABORT_NOW();
	}
#endif
	i = ((unsigned)fdtab[fd].spec.e >> dir) & FD_EV_MASK_DIR;

	if (i != FD_EV_STOP) {
		if (unlikely(i != FD_EV_IDLE))
			return 0;
		// switch to SPEC state and allocate a SPEC entry.
		fd_created++;
		alloc_spec_entry(fd);
	}
	fdtab[fd].spec.e ^= (unsigned int)(FD_EV_IN_SL << dir);
	return 1;
}

对于新建的fd，其对应的fdtab[fd].spec.e为0，因此i的结果是0，也就是FD_EV_IDLE的值，表示此处的fd之前没有使用，那么现在需要alloc_spec_entry(fd)为fd分配新的节点，并且将fd_created加一，表示新建了一个fd。fd_created在sepoll的__do_poll函数中用于第二次循环处理新的fd。最后，不关闭是新建的fd，还是之前被停止使用的fd，都要将要求设置的事件记录在spec.e中，表示有人对这个fd的这个事件感兴趣。对于此函数，在新链接被建立的时候都会被调用(当然不同模型的set函数有差别，不过肯定都是要设置事件的)。sepoll多的只是对spec list的处理(包括fd_created)。

[src/ev_sepoll.c] alloc_spec_entry ()
REGPRM1 static inline void alloc_spec_entry(const int fd)
{
	if (fdtab[fd].spec.s1)
		/* sometimes the entry already exists for the other direction */
		return;
	fdtab[fd].spec.s1 = nbspec + 1;
	spec_list[nbspec] = fd;
	nbspec++;
}

此函数只是简单的将spec list中的fd与fdtab[fd].spec.s1建立映射关系，并且将spec list的fd数目增加。

[src/client.c]event_accept()
		/* it is important not to call the wakeup function directly but to
		 * pass through task_wakeup(), because this one knows how to apply
		 * priorities to tasks.
		 */
		task_wakeup(t, TASK_WOKEN_INIT);

		l->nbconn++; /* warning! right now, it's up to the handler to decrease this */
		if (l->nbconn >= l->maxconn) {
			EV_FD_CLR(l->fd, DIR_RD);
			l->state = LI_FULL;
		}

		p->feconn++;  /* beconn will be increased later */
		if (p->feconn > p->counters.feconn_max)
			p->counters.feconn_max = p->feconn;

		if (l->counters) {
			if (l->nbconn > l->counters->conn_max)
				l->counters->conn_max = l->nbconn;
		}

		actconn++;
		totalconn++;

准备工作都做好之后，那么唤醒当前session对应的task，接着更新各种统计量

[src/client.c]event_accept()
		// fprintf(stderr, "accepting from %p => %d conn, %d total, task=%p\n", p, actconn, totalconn, t);
	} /* end of while (p->feconn < p->maxconn) */
	return 0;

	/* Error unrolling */
 out_fail_rep:
	pool_free2(pool2_buffer, s->req);
 out_fail_req:
	pool_free2(p->hdr_idx_pool, txn->hdr_idx.v);
 out_fail_idx:
	pool_free2(p->rsp_cap_pool, txn->rsp.cap);
 out_fail_rspcap:
	pool_free2(p->req_cap_pool, txn->req.cap);
 out_fail_reqcap:
 out_free_task:
	task_free(t);
 out_free_session:
	LIST_DEL(&s->list);
	pool_free2(pool2_session, s);
 out_close:
	close(cfd);
	return 0;
}