欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

Android Init进程对信号的处理流程详细介绍

程序员文章站 2023-12-19 17:50:58
android  init进程对信号的处理流程 在android中,当一个进程退出(exit())时,会向它的父进程发送一个sigchld信号。父进程收到该信号...

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信号处理的:

void signal_handler_init() { 
  // create a signalling mechanism for sigchld. 
  int s[2]; 
  //socketpair()创造一对未命名的、相互连接的unix域套接字 
  if (socketpair(af_unix, sock_stream | sock_nonblock | sock_cloexec, 0, s) == -1) { 
    error("socketpair failed: %s\n", strerror(errno)); 
    exit(1); 
  } 
 
  signal_write_fd = s[0]; 
  signal_read_fd = s[1]; 
 
  // write to signal_write_fd if we catch sigchld. 
  struct sigaction act; 
  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():

static void sigchld_handler(int) { 
  if (temp_failure_retry(write(signal_write_fd, "1", 1)) == -1) { 
    error("write(signal_write_fd) failed: %s\n", strerror(errno)); 
  } 
}

#define temp_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() 处理这之前的进程退出情况:

static void reap_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); 
void register_epoll_handler(int fd, void (*fn)()) { 
  epoll_event ev; 
  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_ctl failed: %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()函数进行处理:

static void handle_signal() { 
  // clear outstanding requests. 
  char buf[32]; 
  read(signal_read_fd, buf, sizeof(buf)); 
 
  reap_any_outstanding_children(); 
} 

它会将socket的数据的独到buf中,并调用reap_any_outstanding_children()函数处理子进程的退出及服务的重启操作:

static void reap_any_outstanding_children() { 
  while (wait_for_one_process()) { 
  } 
} 
static bool wait_for_one_process() { 
  int status; 
  pid_t pid = temp_failure_retry(waitpid(-1, &status, wnohang));//等待子进程结束,并获取到它的pid进程号,wnohang表明若没有进程结束,则立即返回. 
  if (pid == 0) { 
    return false; 
  } else if (pid == -1) { 
    error("waitpid failed: %s\n", strerror(errno)); 
    return false; 
  } 
 
  service* svc = service_find_by_pid(pid);//根据pid,在链表中找到这个服务信息 
 
  std::string name; 
  if (svc) { 
    name = android::base::stringprintf("service '%s' (pid %d)", svc->name, pid); 
  } else { 
    name = android::base::stringprintf("untracked pid %d", pid); 
  } 
 
  notice("%s %s\n", name.c_str(), describestatus(status).c_str()); 
 
  if (!svc) { 
    return true; 
  } 
 
  // todo: all the code from here down should be a member function on service. 
  //如果该服务进程没有设定svc_oneshot标志,或者设置了svc_restart标志,则先杀掉当前的进程,在重新创建新的进程; 
  //以避免后面重启进程时,因当前服务进程已经存在而发生错误. 
  if (!(svc->flags & svc_oneshot) || (svc->flags & svc_restart)) { 
    notice("service '%s' (pid %d) killing any children in process group\n", svc->name, pid); 
    kill(-pid, sigkill); 
  } 
 
  // remove any sockets we may have created. 
  //如果之前为这个服务进程创建过socket,这时我们需要清除掉该socket 
  for (socketinfo* si = svc->sockets; si; si = si->next) { 
    char tmp[128]; 
    snprintf(tmp, sizeof(tmp), android_socket_dir"/%s", si->name); 
    unlink(tmp);//删除这个socket设备文件 
  } 
 
  if (svc->flags & svc_exec) {////服务完全退出,清除掉所有信息,并将该服务从svc-slist中移除 
    info("svc_exec pid %d finished...\n", svc->pid); 
    waiting_for_exec = false; 
    list_remove(&svc->slist); 
    free(svc->name); 
    free(svc); 
    return true; 
  } 
 
  svc->pid = 0; 
  svc->flags &= (~svc_running); 
 
  // oneshot processes go into the disabled state on exit, 
  // except when manually restarted. 
  //如果该服务进程带有svc_oneshot标志,且没有svc_restart标志,则表明该服务无需重启 
  if ((svc->flags & svc_oneshot) && !(svc->flags & svc_restart)) { 
    svc->flags |= svc_disabled; 
  } 
 
  // disabled and reset processes do not get restarted automatically. 
  //如果服务带有svc_reset标志,表示服务无需重启 
  if (svc->flags & (svc_disabled | svc_reset)) {//从结果看svc_reset标志的判断优先级最高 
    svc->notifystatechange("stopped"); 
    return true; 
  } 
 
  //到此,我们可以得知一个服务进程在init.rc中只要没有声明svc_oneshot和svc_reset标志,当该进程死亡时,就会被重启; 
  //但是,如果一个服务进程带有svc_critical标志,且没有svc_restart标志,当它crash、重启的次数超过4此时,系统会自动重启并进入recovery模式 
  time_t now = 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("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 true; 
      } 
    } else { 
      svc->time_crashed = now; 
      svc->nr_crashed = 1; 
    } 
  } 
 
  svc->flags &= (~svc_restart); 
  svc->flags |= svc_restarting;//为服务加上重启标志,表明它需要重启;后续工作要以此判断 
 
  // execute all onrestart commands for this service. 
  struct listnode* node; 
  list_for_each(node, &svc->onrestart.commands) {//如果服务有onrestart选项,则遍历进程重启时需要执行的命令列表,并执行 
    command* cmd = node_to_item(node, struct command, clist); 
    cmd->func(cmd->nargs, cmd->args); 
  } 
  svc->notifystatechange("restarting"); 
  return true; 
} 

该函数中的处理主要这几个要点:

  1. 调用waitpid()等待子进程结束,waitpid()的返回值就是子进程的进程号。如果没有子进程退出,由于设置了wonhang标志,waitpid()就会立即返回而不会挂起。嵌套的temp_failure_retry()含义与之前介绍的类似,当waitpid()返回错误且错误码是eintr,将重复调用waitpid()。
  2. 根据pid,从service_list列表中找到对应进程对应的service信息。如果该服务进程的定义在init.rc中没有设定svc_oneshot标志,或者设置了svc_restart标志,则先杀掉当前的进程,再重新创建新的进程;以避免后面重新创建进程时,因当前服务进程已经存在而发生错误。
  3. 如果为当前服务创建了socket,则清除这个socket。
  4. 如果该服务进程带有svc_oneshot标志,且没有svc_restart标志,则表明该服务无需重启。
  5. 如果服务带有svc_reset标志,表示服务无需重启。
  6. 如果一个服务进程带有svc_critical标志,且没有svc_restart标志,当它crash、重启的次数超过4此时,系统会自动重启并进入recovery模式。
  7. 如果服务判断为需要重启,则为该服务加上重启标志svc_restarting,表明它需要重新启动;后续工作要以此判断。//重要
  8. 最后,如果服务有onrestart选项,则遍历服务重启时需要执行的命令列表,并执行这些命令

如果这个子进程所代表的服务需要重启,则会为该服务加上svc_restarting标志。

在之前介绍init进程初始化流程时,我们分析过,当init进程处理完,它就会进入一个循环化身为守护进程,处理signal、property和keychord等服务:

while (true) { 
   if (!waiting_for_exec) { 
     execute_one_command();//执行命令列表中的命令 
     restart_processes();//启动服务列表中的进程 
   } 
 
   int timeout = -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_event ev; 
   int nr = temp_failure_retry(epoll_wait(epoll_fd, &ev, 1, timeout));//开始轮询,epoll_wait()等待事件产生 
   if (nr == -1) { 
     error("epoll_wait failed: %s\n", strerror(errno)); 
   } else if (nr == 1) { 
     ((void (*)()) ev.data.ptr)();//调用epoll_event事件存储的函数指针处理事件 
   } 
 } 

其中,它会循环调用restart_processes()去重启在service_list列表中带有所有带有svc_restarting标志(该标志是在wait_for_one_process()处理中设置的)的服务:

static void restart_processes() 
{ 
  process_needs_restart = 0; 
  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_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进程处理流程时已经分析,这里就不再赘述。

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

上一篇:

下一篇: