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

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进程处理流程时已经分析,这里就不再赘述。

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

(0)

相关推荐

  • Android init.rc文件详解及简单实例

    Android init.rc文件详解 本文主要来自$ANDROID_SOURCE/system/init/readme.txt的翻译. 1 简述 Android init.rc文件由系统第一个启动的init程序解析,此文件由语句组成,主要包含了四种类型的语句:Action,Commands,Services,Options.在init.rc文件中一条语句通常是占据一行.单词之间是通过空格符来相隔的.如果需要在单词内使用空格,那么得使用转义字符"\",如果在一行的末尾有一个反斜杠,那么

  • Android中init.rc文件的解析 分享

    对init.rc的解析是在parse_config(): [system/core/init/init_parser.c]中进行的.解析发生在init全过程中的哪个阶段,参看<Android init进程启动过程分析>. 一.解析过程 1.      扫描init.rc中的token 找到其中的 文件结束EOF/文本TEXT/新行NEWLINE,其中的空格' '.'\t'.'\r'会被忽略,#开头的行也被忽略掉: 而对于TEXT,空格' '.'\t'.'\r'.'\n'都是TEXT的结束标志.

  • Android miniTwitter登录界面开发实例

    本文要演示的Android开发实例是如何完成一个Android中的miniTwitter登录界面,下面将分步骤讲解怎样实现图中的界面效果,让大家都能轻松的做出美观的登录界面. 先贴上最终要完成的效果图: miniTwitter登录界面的布局分析 首先由界面图分析布局,基本可以分为三个部分,下面分别讲解每个部分. 第一部分是一个带渐变色背景的LinearLayout布局,关于背景渐变色就不再贴代码了,效果如下图所示: 第二部分,红色线区域内,包括1,2,3,4 如图所示: 红色的1表示的是一个带圆

  • 深入剖析Android中init进程实现的C语言源码

    概述 init是一个进程,确切的说,它是Linux系统中用户空间的第一个进程.由于Android是基于Linux内核的,所以init也是Android系统中用户空间的第一个进程.init的进程号是1.作为天字第一号进程,init有很多重要的工作: init提供property service(属性服务)来管理Android系统的属性. init负责创建系统中的关键进程,包括zygote. 以往的文章一上来就介绍init的源码,但是我这里先从这两个主要工作开始.搞清楚这两个主要工作是如何实现的,我

  • Android init.rc文件简单介绍

    Android init.rc文件简单介绍 init.rc脚本是由Android中linux的第一个用户级进程init进行解析的. init.rc 文件并不是普通的配置文件,而是由一种被称为"Android初始化语言"(Android Init Language,这里简称为AIL)的脚本写成的文件. 该文件在ROM中是只读的,即使有了root权限,可以修改该文件也没有.因为我们在根目录看到的文件只是内存文件的镜像.也就是说,android启动后,会将init.rc文件装载到内存.而修改

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

    Android  Init进程对信号的处理流程 在Android中,当一个进程退出(exit())时,会向它的父进程发送一个SIGCHLD信号.父进程收到该信号后,会释放分配给该子进程的系统资源:并且父进程需要调用wait()或waitpid()等待子进程结束.如果父进程没有做这种处理,且父进程初始化时也没有调用signal(SIGCHLD, SIG_IGN)来显示忽略对SIGCHLD的处理,这时子进程将一直保持当前的退出状态,不会完全退出.这样的子进程不能被调度,所做的只是在进程列表中占据一个

  • Android中View绘制流程详细介绍

    创建Window Window即窗口,这个概念在AndroidFramework中的实现为android.view.Window这个抽象类,这个抽象类是对Android系统中的窗口的抽象.在介绍这个类之前,我们先来看看究竟什么是窗口呢? 实际上,窗口是一个宏观的思想,它是屏幕上用于绘制各种UI元素及响应用户输入事件的一个矩形区域.通常具备以下两个特点: 独立绘制,不与其它界面相互影响: 不会触发其它界面的输入事件: 在Android系统中,窗口是独占一个Surface实例的显示区域,每个窗口的S

  • CentOS 6 启动流程详细介绍

    CentOS 6 启动流程详细介绍 1. POST(Power On Selt Test) 上电自检: 按下电源键首先要检测硬件设备是否能正常运行,如:cpu.内存.硬盘等硬件设备.当然POST不是由硬件去检测(硬件也不会啊!),而是依靠一个软件来完成的,这个软件就是BIOS(Basic Input Output System)基本输入输出系统,它安装在CMOS芯片上,上电就是给CMOS加电,然后启动BIOS程序,BIOS会根据CMOS上记录的硬件信息去读取硬件并检测是否能正常运行,之后初始化硬

  • Android 使用jarsigner给apk签名的方法详细介绍

    Android 使用jarsigner给apk签名的方法详细介绍 工作中APP功能完成以后往往需要往应用商店提交一些内容,如商店中存在本公司别的人员提交的APP,往往需要进行认领,应用商店会让开发者下载空的APK,然后使用自己APP的签名文件进行签名,认证,这里简单说一下如何使用jarsigner命令进行签名. 该arsigner命令在jdk中可以找到, 简单说明一下具体参数: -verbose:签名命令标识符. -keystore:后面跟着的是你签名使用的密钥文件(keystore)的绝对路径

  • Vue electron前端开启局域网接口实现流程详细介绍

    目录 一.主要实现原理 二.获取本机局域网IP 三.开启服务器 四.关闭服务器 五.简单演示 六.整体代码 七.展望 一.主要实现原理 electron本身就集成了Nodejs,简直是不要太舒服.直接用最基本的http模块开接口即可,也可以用express,看个人喜好.下面演示的是http模块. 二.获取本机局域网IP 首先要获取本机局域网的IP,这就是接口的IP地址了. // 获取本机的局域网IP function getServerIp() { let interfaces = os.net

  • SpringCloud使用Feign实现远程调用流程详细介绍

    目录 前言 1. 导入依赖坐标 2. 开启Feign自动装配 3. 声明远程调用 4. 替代RestTemplate 5. 测试 前言 本次示例代码的文件结构如下图所示. 1. 导入依赖坐标 在 order-service 的 pom.xml 文件中导入 Feign 的依赖坐标. <!-- Feign远程调用客户端 --> <dependency> <groupId>org.springframework.cloud</groupId> <artifa

  • linux启动流程详细介绍

    linux启动流程简介 我们都知道,由于linux的稳定性,通常被作为服务器系统,要想称为一个PHP的高手,linux是必修之课.那么linux系统从开机到启动,中间到底都发生了什么?本文来简单探讨一下中间的神秘过程. 1. BIOS加电自检 BIOS是英文"Basic Input Output System"的缩略词 其实,它是一组固化到计算机内主板上一个ROM芯片上的程序. 计算机会首先加载BIOS信息,这是因为BIOS中包含了CPU的相关信息.设备启动顺序信息.硬盘信息.内存信息

  • AngularJS 执行流程详细介绍

    一.启动阶段 大家应该都知道,当浏览器加载一个HTML页面时,它会将HMTL页面先解析成DOM树,然后逐个加载DOM树中的每一个元素节点.我们可以把AngularJS当做一个类似jQuery的js库,我们通过<script>标签引入到HTML中,那么此时Angular就做为一个普通的DOM节点等待浏览器解析,当浏览器解析到这个节点时,发现它是一个js文件,那么浏览器会停止解析剩余的DOM节点,开始执行这个js(即angular.js),同时Angular会设置一个事件监听器来监听浏览器的DOM

  • Android 开发音频组件(Vitamio FAQ)详细介绍

     一.Vitamio介绍 1.1 Vitamio是什么? Vitamio是Android平台视音频播放组件,支持播放几乎格式的视频以及主流网络视频流(http/rtsp/mms等),详细的中文介绍: 这里. Vitamio官网:http://vitamio.org/ Vitamio微博:http://weibo.com/vitamio VPlayer官网:http://vplayer.net Vitamio豆瓣:http://site.douban.com/145815/ 1.2 关于Vitam

  • Android修改DatePicker字体颜色及分割线颜色详细介绍

    一.DatePicker和TimePicker简介 DatePicker是一个日期选择控件,它继承自FrameLayout类,用来实现的主要功能是使用护可以方便选择日期.如果要捕获用户修改DataPicker控件中的数据改变事件,需要为DatePicker添加OnDateChangedListener监听器. TimePicker是一个时间选择控件,也继承自FrameLayout类.时间选择控件向用户显示一天中的时间(可以为24小时,也可以为AM/PM制),并允许用户进行选择.如果要捕获用户修改

随机推荐