网络服务主模型
最后更新于：2022-04-01 15:56:59
### 一.概述
Lighttpd采用多进程网络服务模型。
进程分两种：监控进程watcher 和 工作进程 workers。
监控进程：fork工作进程并监视工作进程的数目，一旦有工作进程退出，监控进程立即fork新的工作进程。
工作进程：接收客户端请求并做出服务响应。
一般情况下，存在一个监控进程和多个工作进程。
max-worker值默认为0时，没有监控进程，只有一个工作进程。
关于初始化：Lighttpd很多地方内存申请都是采用calloc，malloc()和calloc()的主要区别是前者不能初始化所分配的内存空间，而后者能。
主流程入口文件：server.c
### 二.Lighttpd进程守护化
main函数中的函数daemonize调用使得Lighttpd进程转换为守护进程，从而脱离控制终端，在后台提供服务，避免了执行过程中的信息在终端上显示，也避免了服务被终端信息打断。
（启动时假如选项D可不守护化）
下面我们来分析下：
~~~
#ifdef HAVE_FORK
static void daemonize(void) {
#ifdef SIGTTOU
/* 下面用于屏蔽一些有关控制终端操作的信号，防止守护进程没有正常运作之前控制终端受到干扰退出或挂起 */
signal(SIGTTOU, SIG_IGN); //忽略后台进程写控制终端信号
#endif
#ifdef SIGTTIN
signal(SIGTTIN, SIG_IGN); //忽略后台进程读控制终端信号
#endif
#ifdef SIGTSTP
signal(SIGTSTP, SIG_IGN); //忽略终端挂起
#endif
/* 下面开始从普通进程转换为守护进程
* 目标1：后台运行。
* 做法：脱离控制终端->调用fork之后终止父进程，子进程被init收养，此步达到后台运行的目标。
*/
if (0 != fork()) exit(0);
/*,目标2：脱离控制终端，登陆会话和进程组。
* 做法：使用setsid创建新会话，成为新会话的首进程，则与原来的
* 登陆会话和进程组自动脱离，从而脱离控制终端。
* （上一步的fork保证了子进程不可能是一个会话的首进程，这是调用setsid的必要条件）
*/
if (-1 == setsid()) exit(0);
/* 上面已经完成了大部分工作，但是有的系统上，当会话首进程打开
* 一个尚未与任何会话相关联的终端设备时，该设备自动作为控制
* 终端分配给该会话。
* 为避免该情况，我们再次fork进程，于是新进程不再是会话首进程。
* 会话首进程退出时可能会给所有会话内的进程发送SIGHUP，而该
* 信号默认是结束进程，故需要忽略该信号来防止孙子进程意外结束。
*/
signal(SIGHUP, SIG_IGN);
if (0 != fork()) exit(0);
/* 最后目标：改变工作目录到根目录。
* 原因：进程活动时，其工作目录所在的文件系统不能卸下。
*/
if (0 != chdir("/")) exit(0);
}
#endif
~~~
进程属于一个进程组（一个或多个进程的集合），登陆会话是包含一个或多个进程组的集合，这些进程组共享一个控制终端。
### 三.多进程网络服务模型
Lighttpd一开始是单进程的，在完成一组公共操作后开始转换为多进程。
代码框架如下：
具体代码分析注释：
~~~
#ifdef USE_ALARM
signal(SIGALRM, signal_handler);
/* setup periodic timer (1 second) */
if (setitimer(ITIMER_REAL, &interval, NULL)) { //每隔一秒产生一个ALARM
log_error_write(srv, __FILE__, __LINE__, "s", "setting timer failed");
return -1;
}
getitimer(ITIMER_REAL, &interval);
#endif
#ifdef HAVE_FORK
/* start watcher and workers */
num_childs = srv->srvconf.max_worker; //存放最大的子进程的数目
if (num_childs > 0) {
int child = 0; //child变量用于标记是否为子进程，0代表父进程，1代表子进程
while (!child && !srv_shutdown && !graceful_shutdown) { //子进程不可进入，srv_shutdown=1 或 graceful_shutdown=1时父进程跳出
if (num_childs > 0) {
switch (fork()) { //创建子进程
case -1:
return -1;
case 0:
child = 1; //子进程标记
break;
default:
num_childs--; //父进程
break;
}
} else { //子进程产生完毕
int status; //保存子进程退出状态
if (-1 != wait(&status)) { //阻塞等待子进程退出，收尸
/**
* one of our workers went away
*/
num_childs++; //表示可以再产生新的子进程
} else {
switch (errno) { //发生中断
case EINTR:
/**
* if we receive a SIGHUP we have to close our logs ourself as we don't
* have the mainloop who can help us here
*/
if (handle_sig_hup) {
handle_sig_hup = 0;
log_error_cycle(srv); //重新打开日志文件
/**
* forward to all procs in the process-group
*
* we also send it ourself
*/
if (!forwarded_sig_hup) { //通知组内所有进程
forwarded_sig_hup = 1; //只通知一次，使得后面的kill只调用一次
kill(0, SIGHUP);
}
}
break;
default:
break;
}
}
}
}
/**
* for the parent this is the exit-point
*/
if (!child) { //父进程的退出点，关闭所以工作进程，做一些清理工作（关闭日志，连接的网络资源，插件，内存等）。
/**
* kill all children too
*/
if (graceful_shutdown) {
kill(0, SIGINT);
} else if (srv_shutdown) {
kill(0, SIGTERM);
}
log_error_close(srv);
network_close(srv);
connections_free(srv);
plugins_free(srv);
server_free(srv);
return 0;
}
}
#endif
~~~
下面的是子进程部分的关键代码分析：
一开始子进程进行各种初始化工作，包括fd时间处理器的初始化（fdevent_init(srv->max_fds + 1, srv->event_handler)），stat cache初始化（stat_cache_init()）等。
子进程工作在一个大while循环中。
while的工作流程如下：
1、判断连接是否断开。如果断开，则调用处理程序进行处理并重新开始新一轮的日志记录。
2、判断是否接到了alarm函数发出的信号。接受到信号后，判断服务器记录的时间是否和当前时间相同。如果相同，说明时间还没有过一秒，继续处理连接请求。如果不相同，则时间已经过了一秒。那么，服务器则触发插件，清理超时连接，清理stat-cache缓存。这理里面最重要的是处理超时连接。程序中通过一个for循环查询所有的连接，比较其idle的时间和允许的最大idle时间来判断连接是否超时。如果连接超时，则让连接进入出错的状态（connection_set_state(srv, con, CON_STATE_ERROR);）。
3、判断服务器socket连接是否失效。如果失效了，则在不是服务器过载的情况下将所有连接重新加入到fdevent中。
4、如果socket没有失效，判断服务器是否过载。如果过载了，则关闭所有连接，清理服务器并退出服务器。
5、分配文件描述符。
6、启动事件轮询。等待各种IO时间的发生。包括文件读写，socket请求等。
7、一旦有事件发生，调用相应的处理函数进行处理。
8、最后，检查joblist中是否有未处理的job并处理之。
至此，一次循环结束了。然后，继续循环直到服务器关闭。
~~~
/* main-loop */
while (!srv_shutdown) { //只要srv_shutdown不为1，工作进程持续执行
int n;
size_t ndx;
time_t min_ts;
if (handle_sig_hup) { //如果收到HUP信号
handler_t r;
/* reset notification */
handle_sig_hup = 0; //重置标识
/* cycle logfiles */
switch(r = plugins_call_handle_sighup(srv)) { //通过plugins_call_handle_sighup来调用各个模块的HUP处理函数
case HANDLER_GO_ON:
break;
default:
log_error_write(srv, __FILE__, __LINE__, "sd", "sighup-handler return with an error", r);
break;
}
if (-1 == log_error_cycle(srv)) { //重新打开日志文件，并写入收到HUP信号到日志。此处并没有重新读取配置文件
log_error_write(srv, __FILE__, __LINE__, "s", "cycling errorlog failed, dying");
return -1;
} else {
#ifdef HAVE_SIGACTION
log_error_write(srv, __FILE__, __LINE__, "sdsd",
"logfiles cycled UID =",
last_sighup_info.si_uid,
"PID =",
last_sighup_info.si_pid);
#else
log_error_write(srv, __FILE__, __LINE__, "s",
"logfiles cycled");
#endif
}
}
if (handle_sig_alarm) { //收到ALARM信号
/* a new second */
#ifdef USE_ALARM
/* reset notification */
handle_sig_alarm = 0;
#endif
/* get current time */
min_ts = time(NULL);
if (min_ts != srv->cur_ts) {
int cs = 0;
connections *conns = srv->conns;
handler_t r;
switch(r = plugins_call_handle_trigger(srv)) { //调用plugins_call_handle_trigger来处理各个模块的ALARM信号处理函数
case HANDLER_GO_ON:
break;
case HANDLER_ERROR:
log_error_write(srv, __FILE__, __LINE__, "s", "one of the triggers failed");
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
/* trigger waitpid */
srv->cur_ts = min_ts; //更新服务器记录时间
/* cleanup stat-cache */
stat_cache_trigger_cleanup(srv); //清除缓存，删除一些比较旧的节点
/**
* check all connections for timeouts
*
*/
for (ndx = 0; ndx < conns->used; ndx++) { //处理超时连接
int changed = 0;
connection *con;
int t_diff;
con = conns->ptr[ndx];
if (con->state == CON_STATE_READ ||
con->state == CON_STATE_READ_POST) {
if (con->request_count == 1) {
if (srv->cur_ts - con->read_idle_ts > con->conf.max_read_idle) {
/* time - out */
#if 0
log_error_write(srv, __FILE__, __LINE__, "sd",
"connection closed - read-timeout:", con->fd);
#endif
/* lighttpd 中采用了状态机(state-engine)去处理每一个连接,
* 状态机中的每一种节点表示连接当时所处的状态,包括 connect 、
* reqstart 、 read 、 reqend 、 readpost 、handlereq、
* respstart、write、respend、error、close 这 11 个状态
*/
connection_set_state(srv, con, CON_STATE_ERROR); //调用connection_set_state进行状态机的状态转换
changed = 1;
}
} else {
if (srv->cur_ts - con->read_idle_ts > con->conf.max_keep_alive_idle) {
/* time - out */
#if 0
log_error_write(srv, __FILE__, __LINE__, "sd",
"connection closed - read-timeout:", con->fd);
#endif
connection_set_state(srv, con, CON_STATE_ERROR);
changed = 1;
}
}
}
………………
/* we don't like div by zero */
if (0 == (t_diff = srv->cur_ts - con->connection_start)) t_diff = 1;
/* 处理传输速度限制
* 如果某一时刻平均传输速度达到了用户设置的最大值,则停止发送数据(con->traffic_limit_reached将被设为1，
* 进入下面if中处理)。只要检测到平均传输速度小于用户设置的最大值就继续发送数据，
* 则满足if的条件，con->traffic_limit_reached设为 0,同时调用状态机切换函数。
*/
if (con->traffic_limit_reached &&
(con->conf.kbytes_per_second == 0 ||
((con->bytes_written / t_diff) < con->conf.kbytes_per_second * 1024))) {
/* enable connection again */
con->traffic_limit_reached = 0;
changed = 1;
}
if (changed) {
connection_state_machine(srv, con);
}
con->bytes_written_cur_second = 0;
*(con->conf.global_bytes_per_second_cnt_ptr) = 0;
#if 0
if (cs == 0) {
fprintf(stderr, "connection-state: ");
cs = 1;
}
fprintf(stderr, "c[%d,%d]: %s ",
con->fd,
con->fcgi.fd,
connection_get_state(con->state));
#endif
}
if (cs == 1) fprintf(stderr, "\n");
}
}
/* 根据当前的资源利用情况禁用或启用 server sockets 服务
*
* 禁用：当文件描述符(当前文件描述符和等待文件描述符之和)大于 0.9 倍服务器最大
* (系统允许或用户设置)文件描述符数目或当前连接大于最大(系统允许或用户设置)连接
* 数目或收到终止服务器指令时。
*
* 启用:当文件描述符(当前文件描述符和等待文件描述符之和)小于 0.8 倍服务器最大
* (系统允许或用户设置)文件描述符数目并且当前连接小于 0.9 倍最大(系统允许或用户设
* 置)连接数目并且终止服务器标志为 0 时。
*/
if (srv->sockets_disabled) {
/* our server sockets are disabled, why ? */
if ((srv->cur_fds + srv->want_fds < srv->max_fds * 0.8) && /* we have enough unused fds */
(srv->conns->used < srv->max_conns * 0.9) &&
(0 == graceful_shutdown)) {
for (i = 0; i < srv->srv_sockets.used; i++) {
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_event_add(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd, FDEVENT_IN);
}
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets enabled again");
srv->sockets_disabled = 0;
}
} else {
if ((srv->cur_fds + srv->want_fds > srv->max_fds * 0.9) || /* out of fds */
(srv->conns->used > srv->max_conns) || /* out of connections */
(graceful_shutdown)) { /* graceful_shutdown */
/* disable server-fds */
for (i = 0; i < srv->srv_sockets.used; i++) { //逐个删除该工作进程上的所有在 socket 描述符上的事件监听器(通过 fdevent_event_del 函数)。
server_socket *srv_socket = srv->srv_sockets.ptr[i];
fdevent_event_del(srv->ev, &(srv_socket->fde_ndx), srv_socket->fd);
if (graceful_shutdown) { //如果是关闭服务器则注销事件监听器结构(主要是释放内存空间,防止内存泄露)并且关闭文件描述符、删除附属文件。
/* we don't want this socket anymore,
*
* closing it right away will make it possible for
* the next lighttpd to take over (graceful restart)
* */
fdevent_unregister(srv->ev, srv_socket->fd);
close(srv_socket->fd);
srv_socket->fd = -1;
/* network_close() will cleanup after us */
if (srv->srvconf.pid_file->used &&
srv->srvconf.changeroot->used == 0) {
if (0 != unlink(srv->srvconf.pid_file->ptr)) {
if (errno != EACCES && errno != EPERM) {
log_error_write(srv, __FILE__, __LINE__, "sbds",
"unlink failed for:",
srv->srvconf.pid_file,
errno,
strerror(errno));
}
}
}
}
}
if (graceful_shutdown) {
log_error_write(srv, __FILE__, __LINE__, "s", "[note] graceful shutdown started");
} else if (srv->conns->used > srv->max_conns) {
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets disabled, connection limit reached");
} else {
log_error_write(srv, __FILE__, __LINE__, "s", "[note] sockets disabled, out-of-fds");
}
srv->sockets_disabled = 1;
}
}
if (graceful_shutdown && srv->conns->used == 0) {
/* we are in graceful shutdown phase and all connections are closed
* we are ready to terminate without harming anyone */
srv_shutdown = 1;
}
/* we still have some fds to share */
if (srv->want_fds) { //如果有待处理的文件描述符,则通过状态机切换函数进行处理,为了合理利用资源,程序会保证至少有 16 个空闲文件描述符
/* check the fdwaitqueue for waiting fds */
int free_fds = srv->max_fds - srv->cur_fds - 16;
connection *con;
for (; free_fds > 0 && NULL != (con = fdwaitqueue_unshift(srv, srv->fdwaitqueue)); free_fds--) {
connection_state_machine(srv, con);
srv->want_fds--;
}
}
/* 通过 fdevent_poll -> epoll_wait(以 USE_LINUX_EPOLL 为例)来轮询 I/O 事件的发生,
* 其中等待 I/O 事件发生的超时值 timeout_ms=1000milliseconds,即 1 秒。
* 如果在等待的这 1 秒内有 I/O 事件发生,则返回的 n 值记录事件数目,随后用一个 do-while
* 循环对每一个发生的 I/O 事件进行处理。
*/
if ((n = fdevent_poll(srv->ev, 1000)) > 0) {
/* n is the number of events */
int revents;
int fd_ndx;
#if 0
if (n > 0) {
log_error_write(srv, __FILE__, __LINE__, "sd",
"polls:", n);
}
#endif
fd_ndx = -1;
do {
fdevent_handler handler;
void *context;
handler_t r;
fd_ndx = fdevent_event_next_fdndx (srv->ev, fd_ndx); //获得发生了 I/O 事件的文件描述符在 fdarray 中的索引
revents = fdevent_event_get_revent (srv->ev, fd_ndx); //获得该文件描述符上发生的 I/O 事件类型
fd = fdevent_event_get_fd (srv->ev, fd_ndx); //获得该文件描述符
handler = fdevent_get_handler(srv->ev, fd); //获得 I/O 事件处理的回调函数
context = fdevent_get_context(srv->ev, fd); //获得 I/O 事件处理的上下文环境
/* connection_handle_fdevent needs a joblist_append */
#if 0
log_error_write(srv, __FILE__, __LINE__, "sdd",
"event for", fd, revents);
#endif
switch (r = (*handler)(srv, context, revents)) { //调用回调函数进行 I/O 事件处理,并传入相关参数。
case HANDLER_FINISHED:
case HANDLER_GO_ON:
case HANDLER_WAIT_FOR_EVENT:
case HANDLER_WAIT_FOR_FD:
break;
case HANDLER_ERROR:
/* should never happen */
SEGFAULT();
break;
default:
log_error_write(srv, __FILE__, __LINE__, "d", r);
break;
}
} while (--n > 0);
} else if (n < 0 && errno != EINTR) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"fdevent_poll failed:",
strerror(errno));
}
~~~
参考资料：《Lighttpd源码分析》 高群凯 编著