Android Init进程对信号的处理流程详细介绍
Android Init进程对信号的处理流程
在Android中，当一个进程退出（exit()）时，会向它的父进程发送一个SIGCHLD信号。父进程收到该信号后，会释放分配给该子进程的系统资源；并且父进程需要调用wait()或waitpid()等待子进程结束。如果父进程没有做这种处理，且父进程初始化时也没有调用signal(SIGCHLD,SIG_IGN)来显示忽略对SIGCHLD的处理，这时子进程将一直保持当前的退出状态，不会完全退出。这样的子进程不能被调度，所做的只是在进程列表中占据一个位置，保存了该进程的PID、终止状态、CPU使用时间等信息；我们将这种进程称为“Zombie”进程，即僵尸进程。
在Linux中，设置僵尸进程的目的是维护子进程的一些信息，以供父进程后续查询获取。特殊的，如果一个父进程终止，那么它的所有僵尸子进程的父进程将被设置为Init进程（PID为1），并由Init进程负责回收这些僵尸进程（Init进程将wait()/waitpid()它们，并清除它们在进程列表中的信息）。
由于僵尸进程仍会在进程列表中占据一个位置，而Linux所支持的最大进程数量是有限的；超过这个界限值后，我们就无法创建进程。所以，我们有必要清理那些僵尸进程，以保证系统的正常运作。
接下来，我们分析下Init进程是如何处理SIGCHLD信号的。
在Init.cpp中，我们是通过signal_handler_init()来初始化SIGCHLD信号处理的：
voidsignal_handler_init(){
//CreateasignallingmechanismforSIGCHLD.
ints[2];
//socketpair()创造一对未命名的、相互连接的UNIX域套接字
if(socketpair(AF_UNIX,SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC,0,s)==-1){
ERROR("socketpairfailed:%s\n",strerror(errno));
exit(1);
}
signal_write_fd=s[0];
signal_read_fd=s[1];
//Writetosignal_write_fdifwecatchSIGCHLD.
structsigactionact;
memset(&act,0,sizeof(act));
act.sa_handler=SIGCHLD_handler;//设置信号处理函数句柄,当有信号产生时,会向上面创建的socket写入数据,epoll监控到该socket对中的fd可读时,就会调用注册的函数去处理该事件
act.sa_flags=SA_NOCLDSTOP;//设置标志,表示只有当子进程终止时才接受SIGCHID信号
sigaction(SIGCHLD,&act,0);//初始化SIGCHLD信号处理方式
reap_any_outstanding_children();//处理这之前退出的子进程
register_epoll_handler(signal_read_fd,handle_signal);
}
我们通过sigaction()函数来初始化信号。在act参数中，指定了信号处理函数：SIGCHLD_handler()；如果有信号到来，就会调用该函数处理；同时，在参数act中，我们还设置了SA_NOCLDSTOP标志，表示只有当子进程终止时才接受SIGCHLD信号。
Linux中，信号是一种软中断，所以信号的到来会终止当前进程正在处理的操作。所以，我们在注册的信号处理函数中不要调一些不可重入的函数。并且，Linux不会对信号做排队处理，在一个信号的处理期间不管再收到多少个信号，当前信号处理完毕后，内核也只会再发送一个信号给进程；所以这里就存在信号丢失的可能。为了避免丢失信号，我们注册的信号处理函数操作应该越高效、越快越好。
而我们处理SIGCHLD信号时，父进程会做等待操作，这个时间是比较长的。为了解决这个问题，上面的信号初始化代码中创建了一对未命名且相关联的本地socket用于线程间通信。注册的信号处理函数是SIGCHLD_handler()：
staticvoidSIGCHLD_handler(int){
if(TEMP_FAILURE_RETRY(write(signal_write_fd,"1",1))==-1){
ERROR("write(signal_write_fd)failed:%s\n",strerror(errno));
}
}
#defineTEMP_FAILURE_RETRY(exp)\
({\
decltype(exp)_rc;\
do{\
_rc=(exp);\
}while(_rc==-1&&errno==EINTR);\
_rc;\
})
当有信号到来时，只要向socket中写入数据，这个过程是很快的，此时信号的处理就转移到socket的响应中去进行了；这样就不会影响下一个信号的处理。同时，write()函数外围嵌套了一个do...while循环，循环条件是write()发生错误且当前的错误号为EINTR（EINTR：此调用被信号所中断），即当前write()是由于有中断到来而发生错误时，操作将再次执行；其他情况下，write()函数只会执行一次。再初始化完信号处理后，就会调用reap_any_outstanding_children()处理这之前的进程退出情况：
staticvoidreap_any_outstanding_children(){
while(wait_for_one_process()){
}
}
wait_for_one_process()主要调用waitpid()等待子进程结束，当该进程代表的服务需要重启时，会对它做一些设置、清理工作。
最后，通过epoll_ctl()向epoll_fd注册本地socket，监听其是否可读；并注册了epoll事件的处理函数：
register_epoll_handler(signal_read_fd,handle_signal);
voidregister_epoll_handler(intfd,void(*fn)()){
epoll_eventev;
ev.events=EPOLLIN;//对文件描述符可读
ev.data.ptr=reinterpret_cast<void*>(fn);//保存指定的函数指针,用于后续的事件处理
if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,fd,&ev)==-1){//向epoll_fd添加要监听的fd,比如property、keychord和signal事件监听
ERROR("epoll_ctlfailed:%s\n",strerror(errno));
}
}
我们以Zygote进程退出为例，来看下SIGCHLD信号处理的具体流程。Zygote进程在init.rc中被声明为Service并由Init进程创建。当Zygote进程退出时，将向Init进程发送SIGCHLD信号。前面的代码已经完成了信号的初始化操作，所以当信号到来时会调用SIGCHLD_handler()函数处理，它的处理就是直接通过socket写入一个数据就立刻返回；这时，SIGCHLD的处理就转移到socket事件的响应上。我们通过epoll_ctl注册了本地socket，并监听它是否可读；这时由于之前的write()调用，此时socket有数据可读，此刻会调用注册的handle_signal()函数进行处理：
staticvoidhandle_signal(){
//Clearoutstandingrequests.
charbuf[32];
read(signal_read_fd,buf,sizeof(buf));
reap_any_outstanding_children();
}
它会将socket的数据的独到buf中，并调用reap_any_outstanding_children()函数处理子进程的退出及服务的重启操作：
staticvoidreap_any_outstanding_children(){
while(wait_for_one_process()){
}
}
staticboolwait_for_one_process(){
intstatus;
pid_tpid=TEMP_FAILURE_RETRY(waitpid(-1,&status,WNOHANG));//等待子进程结束,并获取到它的pid进程号,WNOHANG表明若没有进程结束,则立即返回.
if(pid==0){
returnfalse;
}elseif(pid==-1){
ERROR("waitpidfailed:%s\n",strerror(errno));
returnfalse;
}
service*svc=service_find_by_pid(pid);//根据pid,在链表中找到这个服务信息
std::stringname;
if(svc){
name=android::base::StringPrintf("Service'%s'(pid%d)",svc->name,pid);
}else{
name=android::base::StringPrintf("Untrackedpid%d",pid);
}
NOTICE("%s%s\n",name.c_str(),DescribeStatus(status).c_str());
if(!svc){
returntrue;
}
//TODO:allthecodefromheredownshouldbeamemberfunctiononservice.
//如果该服务进程没有设定SVC_ONESHOT标志,或者设置了SVC_RESTART标志,则先杀掉当前的进程,在重新创建新的进程;
//以避免后面重启进程时,因当前服务进程已经存在而发生错误.
if(!(svc->flags&SVC_ONESHOT)||(svc->flags&SVC_RESTART)){
NOTICE("Service'%s'(pid%d)killinganychildreninprocessgroup\n",svc->name,pid);
kill(-pid,SIGKILL);
}
//Removeanysocketswemayhavecreated.
//如果之前为这个服务进程创建过socket,这时我们需要清除掉该socket
for(socketinfo*si=svc->sockets;si;si=si->next){
chartmp[128];
snprintf(tmp,sizeof(tmp),ANDROID_SOCKET_DIR"/%s",si->name);
unlink(tmp);//删除这个socket设备文件
}
if(svc->flags&SVC_EXEC){////服务完全退出,清除掉所有信息,并将该服务从svc-slist中移除
INFO("SVC_EXECpid%dfinished...\n",svc->pid);
waiting_for_exec=false;
list_remove(&svc->slist);
free(svc->name);
free(svc);
returntrue;
}
svc->pid=0;
svc->flags&=(~SVC_RUNNING);
//Oneshotprocessesgointothedisabledstateonexit,
//exceptwhenmanuallyrestarted.
//如果该服务进程带有SVC_ONESHOT标志,且没有SVC_RESTART标志,则表明该服务无需重启
if((svc->flags&SVC_ONESHOT)&&!(svc->flags&SVC_RESTART)){
svc->flags|=SVC_DISABLED;
}
//Disabledandresetprocessesdonotgetrestartedautomatically.
//如果服务带有SVC_RESET标志,表示服务无需重启
if(svc->flags&(SVC_DISABLED|SVC_RESET)){//从结果看SVC_RESET标志的判断优先级最高
svc->NotifyStateChange("stopped");
returntrue;
}
//到此,我们可以得知一个服务进程在init.rc中只要没有声明SVC_ONESHOT和SVC_RESET标志,当该进程死亡时，就会被重启;
//但是,如果一个服务进程带有SVC_CRITICAL标志,且没有SVC_RESTART标志,当它crash、重启的次数超过4此时,系统会自动重启并进入recovery模式
time_tnow=gettime();
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("criticalprocess'%s'exited%dtimesin%dminutes;"
"rebootingintorecoverymode\n",svc->name,
CRITICAL_CRASH_THRESHOLD,CRITICAL_CRASH_WINDOW/60);
android_reboot(ANDROID_RB_RESTART2,0,"recovery");
returntrue;
}
}else{
svc->time_crashed=now;
svc->nr_crashed=1;
}
}
svc->flags&=(~SVC_RESTART);
svc->flags|=SVC_RESTARTING;//为服务加上重启标志,表明它需要重启;后续工作要以此判断
//Executeallonrestartcommandsforthisservice.
structlistnode*node;
list_for_each(node,&svc->onrestart.commands){//如果服务有onrestart选项,则遍历进程重启时需要执行的命令列表,并执行
command*cmd=node_to_item(node,structcommand,clist);
cmd->func(cmd->nargs,cmd->args);
}
svc->NotifyStateChange("restarting");
returntrue;
}
该函数中的处理主要这几个要点：
- 调用waitpid()等待子进程结束，waitpid()的返回值就是子进程的进程号。如果没有子进程退出，由于设置了WONHANG标志，waitpid()就会立即返回而不会挂起。嵌套的TEMP_FAILURE_RETRY()含义与之前介绍的类似，当waitpid()返回错误且错误码是EINTR，将重复调用waitpid()。
- 根据pid，从service_list列表中找到对应进程对应的service信息。如果该服务进程的定义在init.rc中没有设定SVC_ONESHOT标志,或者设置了SVC_RESTART标志,则先杀掉当前的进程,再重新创建新的进程；以避免后面重新创建进程时,因当前服务进程已经存在而发生错误。
- 如果为当前服务创建了socket，则清除这个socket。
- 如果该服务进程带有SVC_ONESHOT标志,且没有SVC_RESTART标志,则表明该服务无需重启。
- 如果服务带有SVC_RESET标志,表示服务无需重启。
- 如果一个服务进程带有SVC_CRITICAL标志,且没有SVC_RESTART标志,当它crash、重启的次数超过4此时,系统会自动重启并进入recovery模式。
- 如果服务判断为需要重启，则为该服务加上重启标志SVC_RESTARTING,表明它需要重新启动;后续工作要以此判断。//重要
- 最后，如果服务有onrestart选项,则遍历服务重启时需要执行的命令列表,并执行这些命令
如果这个子进程所代表的服务需要重启，则会为该服务加上SVC_RESTARTING标志。
在之前介绍Init进程初始化流程时，我们分析过，当Init进程处理完，它就会进入一个循环化身为守护进程，处理signal、property和keychord等服务：
while(true){
if(!waiting_for_exec){
execute_one_command();//执行命令列表中的命令
restart_processes();//启动服务列表中的进程
}
inttimeout=-1;
if(process_needs_restart){
timeout=(process_needs_restart-gettime())*1000;
if(timeout<0)
timeout=0;
}
if(!action_queue_empty()||cur_action){
timeout=0;
}
bootchart_sample(&timeout);//bootchart是一个用可视化方式对启动过程进行性能分析的工具;需要定时唤醒进程
epoll_eventev;
intnr=TEMP_FAILURE_RETRY(epoll_wait(epoll_fd,&ev,1,timeout));//开始轮询,epoll_wait()等待事件产生
if(nr==-1){
ERROR("epoll_waitfailed:%s\n",strerror(errno));
}elseif(nr==1){
((void(*)())ev.data.ptr)();//调用epoll_event事件存储的函数指针处理事件
}
}
其中，它会循环调用restart_processes()去重启在service_list列表中带有所有带有SVC_RESTARTING标志（该标志是在wait_for_one_process()处理中设置的）的服务：
staticvoidrestart_processes()
{
process_needs_restart=0;
service_for_each_flags(SVC_RESTARTING,
restart_service_if_needed);
}
voidservice_for_each_flags(unsignedmatchflags,
void(*func)(structservice*svc))
{
structlistnode*node;
structservice*svc;
list_for_each(node,&service_list){
svc=node_to_item(node,structservice,slist);
if(svc->flags&matchflags){
func(svc);
}
}
}
staticvoidrestart_service_if_needed(structservice*svc)
{
time_tnext_start_time=svc->time_started+5;
if(next_start_time<=gettime()){
svc->flags&=(~SVC_RESTARTING);
service_start(svc,NULL);
return;
}
if((next_start_time<process_needs_restart)||
(process_needs_restart==0)){
process_needs_restart=next_start_time;
}
}
最终会调用service_start()函数去重新启动一个退出的服务。service_start()的处理过程在介绍Init进程处理流程时已经分析，这里就不再赘述。
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！