android—init进程如何重启service

在《android—init.rc的读取》中介绍过，init进程会启动很多native的service，这些service如果不是oneshot的，当service出现异常挂掉后，init需要将其重新启动起来，那么具体是如何操作的？其实主要是借助了信号和socket来实现。

在init的main()函数中，首先进行了signal相关的初始化，设置了init对SIGCHLD(native的service都是在init中通过fork新建的子进程，子进程挂掉后会给init发送SIGCHLD信号)的信号处理函数，

queue_builtin_action(signal_init_action, "signal_init");

static int signal_init_action(int nargs, char **args)
{
signal_init();
return 0;
}

void signal_init(void)
{
int s[2];

struct sigaction act;
memset(&act, 0, sizeof(act));
act.sa_handler = sigchld_handler;
act.sa_flags = SA_NOCLDSTOP;
sigaction(SIGCHLD, &act, 0);

//创建一个socketpair，一个读fd一个写fd
/* create a signalling mechanism for the sigchld handler */
if (socketpair(AF_UNIX, SOCK_STREAM, 0, s) == 0) {
signal_fd = s[0];
signal_recv_fd = s[1];
fcntl(s[0], F_SETFD, FD_CLOEXEC);
fcntl(s[0], F_SETFL, O_NONBLOCK);
fcntl(s[1], F_SETFD, FD_CLOEXEC);
fcntl(s[1], F_SETFL, O_NONBLOCK);
}

handle_signal();
}

SIGCHLD的信号处理函数sigchld_handler()，就是向signal_fd中写数据，这时候signal_recv_fd将会受到数据，那么，init肯定在哪里对这个signal_recv_fd进行了poll。

//接收到SIGCHLD的处理函数
//往signal_fd里随便写个东西,socket pair的另外一端马上就能受到
static void sigchld_handler(int s)
{
write(signal_fd, &s, 1);
}

在init的for循环中，发现确实对signal_recv_fd进行了poll，

if (!signal_fd_init && get_signal_fd() > 0) {
//信号处理函数在子进程挂掉后会给signal_fd写东西
//这时候socketpair的对端，signal_recv_fd会受到，这里监听了该signal_recv_fd
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}

int get_signal_fd()
{
return signal_recv_fd;
}

当signal_recv_fd描述符poll触发返回时，执行handle_signal()函数，

for (i = 0; i < fd_count; i++) {
if (ufds[i].revents == POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
//执行handle_signal()函数
handle_signal();
}
}

而，

void handle_signal(void)
{
char tmp[32];

//从signal_recv_fd中读数据，
/* we got a SIGCHLD - reap and restart as needed */
read(signal_recv_fd, tmp, sizeof(tmp));
while (!wait_for_one_process(0))
;
}

wait_for_one_process的主要功能是等待子进程退出，然后设置对应需要重启service的状态为SVC_RESTARTING，同时需要注意会执行service属性中的onrestart相关的，其实就是去重启相关的其他service，

/*
这个函数基本都是返回0
*/
static int wait_for_one_process(int block)
{
pid_t pid;
int status;
struct service *svc;
struct socketinfo *si;
time_t now;
struct listnode *node;
struct command *cmd;

//等待子进程执行完退出
//通过pid找到service，重启service不在这里，这里只负责启动service下面的onrestart

while ( (pid = waitpid(-1, &status, block ? 0 : WNOHANG)) == -1 && errno == EINTR );
if (pid <= 0) return -1;
INFO("waitpid returned pid %d, status = %08x\n", pid, status);

svc = service_find_by_pid(pid);
if (!svc) {
ERROR("untracked pid %d exited\n", pid);
return 0;
}

NOTICE("process '%s', pid %d exited\n", svc->name, pid);

//
if (!(svc->flags & SVC_ONESHOT) || (svc->flags & SVC_RESTART)) {
kill(-pid, SIGKILL);
NOTICE("process '%s' killing any children in process group\n", svc->name);
}

/* remove any sockets we may have created */
for (si = svc->sockets; si; si = si->next) {
char tmp[128];
snprintf(tmp, sizeof(tmp), ANDROID_SOCKET_DIR"/%s", si->name);
unlink(tmp);
}

svc->pid = 0;
svc->flags &= (~SVC_RUNNING);

/* oneshot processes go into the disabled state on exit,
* except when manually restarted. */
if ((svc->flags & SVC_ONESHOT) && !(svc->flags & SVC_RESTART)) {
svc->flags |= SVC_DISABLED;
}

/* disabled and reset processes do not get restarted automatically */
if (svc->flags & (SVC_DISABLED | SVC_RESET) )  {
notify_service_state(svc->name, "stopped");
return 0;
}

now = gettime();
//如果service是critical的，崩了4次，还有个4分钟后，android就重启进入recovery了
if ((svc->flags & SVC_CRITICAL) && !(svc->flags & SVC_RESTART)) {
if (svc->time_crashed + CRITICAL_CRASH_WINDOW >= now) {
if (++svc->nr_crashed > CRITICAL_CRASH_THRESHOLD) {
ERROR("critical process '%s' exited %d times in %d minutes; "
"rebooting into recovery mode\n", svc->name,
CRITICAL_CRASH_THRESHOLD, CRITICAL_CRASH_WINDOW / 60);
android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
return 0;
}
} else {
svc->time_crashed = now;
svc->nr_crashed = 1;
}
}

svc->flags &= (~SVC_RESTART);
svc->flags |= SVC_RESTARTING;

/* Execute all onrestart commands for this service. */
//重启这个service下的onrestart这个action下的所有commands
list_for_each(node, &svc->onrestart.commands) {
cmd = node_to_item(node, struct command, clist);
cmd->func(cmd->nargs, cmd->args);
}
notify_service_state(svc->name, "restarting");
return 0;
}

上面只是设置了service的状态为SVC_RESTARTING，真正重启的地方在main函数中的for循环的restart_processes()，

restart_processes();

static void restart_processes()
{
process_needs_restart = 0;
//只会去重启service状态是SVC_RESTARTING的service，
service_for_each_flags(SVC_RESTARTING,
restart_service_if_needed);
}

void service_for_each_flags(unsigned matchflags,
void (*func)(struct service *svc))
{
struct listnode *node;
struct service *svc;
list_for_each(node, &service_list) {
svc = node_to_item(node, struct service, slist);
if (svc->flags & matchflags) {
func(svc);
}
}
}
static void restart_service_if_needed(struct service *svc)
{
time_t next_start_time = svc->time_started + 5;

if (next_start_time <= gettime()) {
svc->flags &= (~SVC_RESTARTING);
//重启service
service_start(svc, NULL);
return;
}

if ((next_start_time < process_needs_restart) ||
(process_needs_restart == 0)) {
process_needs_restart = next_start_time;
}
}

至此，init就完成了对service的重启，保证了某些关键service一直运行。