php-fpm的reload过程

背景

谈谈PHP的Reload操作中提到reload会让sleep提前结束，所以就探究了下fpm的reload操作如何实现。

本文在php7.0 fpm下分析，process_control_timeout设置不为0。

---

重启信号

首先，我们从PHP源码可以知道，fpm的reload操作实际上就是对fpm进程发送了USR2信号。

程序在处理信号的时候，主进程的逻辑相当于“暂停”了，如果在这儿执行一些操作的话，第一，有些局部变量拿不到；第二，可能会打断主进程的逻辑。所以，信号处理函数仅仅是通知主进程，用户发送了这个信号。

信号处理函数的注册

fpm的master进程中，fpm_signals_init_main函数通过sigaction注册了信号处理函数sig_handler：

int fpm_signals_init_main() /* {{{ */
{
	struct sigaction act;

	// 。。。。。。

	memset(&act, 0, sizeof(act));
	act.sa_handler = sig_handler;
	sigfillset(&act.sa_mask);

	if (0 > sigaction(SIGTERM,  &act, 0) ||
	    0 > sigaction(SIGINT,   &act, 0) ||
	    0 > sigaction(SIGUSR1,  &act, 0) ||
	    0 > sigaction(SIGUSR2,  &act, 0) ||
	    0 > sigaction(SIGCHLD,  &act, 0) ||
	    0 > sigaction(SIGQUIT,  &act, 0)) {

		zlog(ZLOG_SYSERROR, "failed to init signals: sigaction()");
		return -1;
	}
	return 0;
}
/* }}} */

简而言之，通过sigfillset设置为block掉所有的信号，然后通过sigaction设置对应的信号处理函数。

信号处理函数

刚刚我们提到，当我们reload fpm时，systemctl向fpm的master进程发送USR2信号。这个时候，之前注册的信号处理函数sig_handler函数被执行：

static void sig_handler(int signo) /* {{{ */
{
	static const char sig_chars[NSIG + 1] = {
		[SIGTERM] = 'T',
		[SIGINT]  = 'I',
		[SIGUSR1] = '1',
		[SIGUSR2] = '2',
		[SIGQUIT] = 'Q',
		[SIGCHLD] = 'C'
	};
	char s;
        // ***
	s = sig_chars[signo];
	zend_quiet_write(sp[1], &s, sizeof(s));
	errno = saved_errno;
}
/* }}} */

关键点在zend_quiet_write，它就是write函数。sig_handler函数就是向sp[1]中写入了一个字符串2。

此处需要注意的是，sp[0]和sp[1]是通过socketpair创建的本地套接字，用于信号处理函数和主进程的通信。

---

master开始重启

之前的信号处理函数，仅仅是通过管道通知主进程，但是程序的主逻辑仍然不会被打乱，那fpm master进程怎么reload呢？

答案就在fpm_event_loop中，这是master进程的事件循环。

在循环之前，我们需要用sp[0]创建一个struct fpm_event_s，添加到监听的fd中：

int fpm_event_set(struct fpm_event_s *ev, int fd, int flags, void (*callback)(struct fpm_event_s *, short, void *), void *arg) /* {{{ */
{
	if (!ev || !callback || fd < -1) {
		return -1;
	}
	memset(ev, 0, sizeof(struct fpm_event_s));
	ev->fd = fd;
	ev->callback = callback;
	ev->arg = arg;
	ev->flags = flags;
	return 0;
}
/* }}} */

然后将这个struct fpm_event_s，也就是代码中的ev，添加到监听的fd中。

实际上，这个添加过程也和fpm不同的异步模型有关（都是由对应fpm_event_module_s的add方法实现的），比如epoll的实现就是将ev参数整体放到epoll_event的data.ptr中的。（poll的add可以参考源码）

当所有的fd都添加了之后（当然不仅仅是signal相关的fd咯），我们就可以使用wait方法等待事件来临了。（epoll和poll也都各自实现了wait方法）

好，回到sig_handler给sp[1]写了个字符串2。wait方法接到了信号，拿到对应的ev，调用 fpm_event_fire ，实际上就是调用了ev的callback方法，就是fpm_got_signal方法：

static void fpm_got_signal(struct fpm_event_s *ev, short which, void *arg) /* {{{ */
{
	char c;
	int res, ret;
	int fd = ev->fd;

	do {
		res = read(fd, &c, 1);

		switch (c) {
			// 。。。。。。
			case '2' :                  /* SIGUSR2 */
				zlog(ZLOG_DEBUG, "received SIGUSR2");
				zlog(ZLOG_NOTICE, "Reloading in progress ...");
				fpm_pctl(FPM_PCTL_STATE_RELOADING, FPM_PCTL_ACTION_SET);
				break;
		}

		if (fpm_globals.is_child) {
			break;
		}
	} while (1);
	return;
}
/* }}} */

如果接收到了字符串2，则执行

fpm_pctl(FPM_PCTL_STATE_RELOADING, FPM_PCTL_ACTION_SET)

实际上就这么几行：

void fpm_pctl(int new_state, int action) /* {{{ */
{
	switch (action) {
		case FPM_PCTL_ACTION_SET :
			//。。。。。。
			fpm_signal_sent = 0;
			fpm_state = new_state;

			zlog(ZLOG_DEBUG, "switching to '%s' state", fpm_state_names[fpm_state]);
			/* fall down */

		case FPM_PCTL_ACTION_TIMEOUT :
			fpm_pctl_action_next();
			break;
		//。。。。。
	}
}
/* }}} */

即，将fpm_state设置为FPM_PCTL_STATE_RELOADING后，没有break，继续执行fpm_pctl_action_next：

static void fpm_pctl_action_next() /* {{{ */
{
	int sig, timeout;

	if (!fpm_globals.running_children) {
		fpm_pctl_action_last();
	}

	if (fpm_signal_sent == 0) {
		if (fpm_state == FPM_PCTL_STATE_TERMINATING) {
			sig = SIGTERM;
		} else {
			sig = SIGQUIT;
		}
		timeout = fpm_global_config.process_control_timeout;
	} else {
		if (fpm_signal_sent == SIGQUIT) {
			sig = SIGTERM;
		} else {
			sig = SIGKILL;
		}
		timeout = 1;
	}

	fpm_pctl_kill_all(sig);
	fpm_signal_sent = sig;
	fpm_pctl_timeout_set(timeout);
}
/* }}} */

即，给所有子进程发送SIGQUIT信号。

这边还有一个fpm_pctl_timeout_set，这个等会讨论。

---

子进程处理信号

父进程发送完信号了，就该子进程处理啦。

子进程只有SIGQUIT交给sig_soft_quit处理。子进程初始化完成后，收到了SIGQUIT信号，由sig_soft_quit处理，最终调用fcgi_terminate处理：

void fcgi_terminate(void)
{
	in_shutdown = 1;
}

就是将in_shutdown设置为1。

---

子进程退出

子进程的循环主体在fcgi_accept_request中，其中多处判断in_shutdown，若为1则直接退出：

• 1365行
• 1400行
• 1468行

---

超时处理

前面提到的超时处理的回调函数是fpm_pctl_timeout_set。执行了如下操作：

fpm_pctl(FPM_PCTL_STATE_UNSPECIFIED, FPM_PCTL_ACTION_TIMEOUT);

在这种条件下，发送的信号变成了SIGTERM。

在子进程的信号处理函数（fpm_signals_init_child）设置中，SIGTERM的处理行为是SIG_DFL，也就是直接退出子进程。

---

为何sleep会被打断？

我们可以看到，sleep的实现就是系统调用sleep（php_sleep是sleep的一个宏）：

/* {{{ proto void sleep(int seconds)
   Delay for a given number of seconds */
PHP_FUNCTION(sleep)
{
	zend_long num;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &num) == FAILURE) {
		RETURN_FALSE;
	}
	php_sleep((unsigned int)num);

}
/* }}} */

sleep函数执行时，此时进程的状态是S：

interruptible sleep

此时一旦有信号触发，立马处理信号，比如我们刚刚说过的SIGQUIT，结束了之后发现，sleep执行完了。

因为sleep的说明写了啊：

sleep() makes the calling thread sleep until seconds seconds have elapsed or a signal arrives which is not ignored.

需要注意的是，php的sleep没有return系统调用sleep的返回值，所以即使信号打断了sleep，也仅仅是跳过sleep继续执行而已。而PHP代码无法通过返回值知道sleep是被打断了，还是真的sleep了指定的时间。