System V的启动风格和BSD的启动风格(1)—代码角度

发布于 2008-12-07
by
归档于 Linux Server, Unix

  V的启动风格和bsd的启动风格不同，网上很多文章介绍这件事，但是那些文章仅仅从应用的角度来分析，这在理解上就有很大的困难，毕竟差异算什么呢？充其量仅仅算一种习惯，没有孰优孰劣的，如果让读者非得分出个所以然来，仅从应用角度来理解就不够了，最好的方法就是从源代码的角度看个究竟，几乎所有的人都知道unix和类unix系统是从init程序开始生命历程的，但是却有了System V和BSD两种风格的启动，说什么/etc/inittab，/etc/rc.d/等等的不同，让人真的很难分辨清楚这到底是怎么一回事，实际上根本没有那么复杂，执行什么脚本以及怎么执行只是它们各自init程序的约定，从这个意义上讲这些启动脚本就是一种动态语言，而init程序就是解释器，本文就分析System V和BSD的init源代码，然后试着分析它们有什么不同并试着指出它们各自的特点以及思想。
  System V和BSD的启动程序都是/sbin/init，源代码都是init.c，我先分析System V的init.c文件（以下简称init）。init从main开始执行，最开始解析命令行参数，随后就进入了一个大循环,细节我就不说了，主要谈一下代码逻辑进而指出为什么启动脚本的不同：

  1. int main(int argc, char **argv)
  2. {
  3. …
  4.     init_main(dfl_level);
  5.     /*NOTREACHED*/
  6.     return 0;
  7. }

 

init_main函数就是一切的循环，在其内部主要解析了/etc/inittab脚本，在进一步分析这个主循环之前首先熟悉一个数据结构，这个数据结构非常重要，从inittab中分析出的一一个要执行的程序就连同它的一些环境变量存储到这个结构里，然后所有这些结构链接成一个全局链表，这个结构就是
CHILD：

  1. typedef struct _child_ {
  2.   int flags;            /* inittab中指示进程的当前状态，比如正在执行，已退出，等待，已经执行过等等 */
  3.   int exstat;            /* inittab中指示进程如果执行后退出的退出状态，init程序由此状态和下面的action字段采取不同的动作 */
  4.   int pid;            /* 如果这个进程已经开始执行，那么这个字段表示该进程的pid */
  5.   time_t tm;            /* When respawned last */
  6.   int count;            /* Times respawned in the last 2 minutes */
  7.   char id[8];            /* Inittab中程序唯一的id号 */
  8.   char rlevel[12];        /* 运行级别，这是System V抽象出来的概念，BSD并没有运行级别的概念*/
  9.   int action;            /* 程序执行的方式，比如wait就是等待这个进程结束在继续，respawn就是结束后重启 */
  10.   char process[128];        /* 命令行，实际就是要执行的程序或脚本的全路径和参数 */
  11.   struct _child_ *new;        /* New entry (after inittab re-read) */
  12.   struct _child_ *next;        /* For the linked list */
  13. } CHILD;

下面开始分析主循环

  1. int init_main()
  2. {
  3.   CHILD            *ch;
  4.   struct sigaction    sa;
  5.   sigset_t        sgt;
  6.   pid_t            rc;
  7.   int            f, st;
  8.   if (!reload) {
  9.     for(f = 1; f <= NSIG; f++)
  10.         SETSIG(sa, f, SIG_IGN, SA_RESTART);
  11.   }
  12.   SETSIG(sa, SIGALRM,  signal_handler, 0);//设置信号处理器，这个信号处理器是很有意思的，仅仅搜集信号并不处理，具体处理工作由下面的循环来负责。
  13.   SETSIG(sa, SIGHUP,   signal_handler, 0);
  14.   SETSIG(sa, SIGINT,   signal_handler, 0);
  15.   SETSIG(sa, SIGCHLD,  chld_handler, SA_RESTART);//这个chld_handler信号处理器很重要，inittab脚本中的程序的执行方式不同，有的结束后重新开始有的只执行一次，有的等待其结束才往下进行，这个处理器就是探测子程序结束的信号的。
  16.   SETSIG(sa, SIGPWR,   signal_handler, 0);
  17.   SETSIG(sa, SIGWINCH, signal_handler, 0);
  18.   SETSIG(sa, SIGUSR1,  signal_handler, 0);
  19.   SETSIG(sa, SIGSTOP,  stop_handler, SA_RESTART);
  20.   SETSIG(sa, SIGTSTP,  stop_handler, SA_RESTART);
  21.   SETSIG(sa, SIGCONT,  cont_handler, SA_RESTART);
  22.   SETSIG(sa, SIGSEGV,  (void (*)(int))segv_handler, SA_RESTART);
  23.   console_init();
  24.   if (!reload) {
  25.       /* Close whatever files are open, and reset the console. */
  26.     close(0);
  27.     close(1);
  28.     close(2);
  29.       console_stty();
  30.       setsid();
  31.       putenv(PATH_DFL);
  32.       (void) close(open(UTMP_FILE, O_WRONLY|O_CREAT|O_TRUNC, 0644));
  33.       initlog(L_CO, bootmsg, “booting”);//打印字符，这是我们熟悉的
  34.     if (emerg_shell) {//如果有紧急的shell需要执行，那么马上执行，这个在救援模式下可能要用
  35.         SETSIG(sa, SIGCHLD, SIG_DFL, SA_RESTART);
  36.         if (spawn(&ch_emerg, &f) > 0) {
  37.             while((rc = wait(&st)) != f)
  38.                 if (rc < 0 && errno == ECHILD)
  39.                     break;
  40.         }
  41.           SETSIG(sa, SIGCHLD,  chld_handler, SA_RESTART);
  42.       }
  43.       runlevel = ‘#’;
  44.       read_inittab();//开始解析inittab脚本
  45.  
  46.   } else {
  47.     initlog(L_CO, bootmsg, “reloading”);
  48.     sigfillset(&sgt);
  49.     sigprocmask(SIG_UNBLOCK, &sgt, NULL);
  50.   }
  51.   start_if_needed();//解析完脚本后，脚本中的程序都已经被加入一个全局链表family，说是链表，实际上就是用next和prev串起来的一串要执行的程序结构。
  52.   while(1) {  //可以认为init程序执行到这里，以下的任务就是不断地执行start_if_needed和收容僵尸进程了。
  53.      boot_transitions();
  54.      INITDBG(L_VB, “init_main: waiting..”);
  55.      for(ch = family; ch; ch = ch->next)
  56.     if ((ch->flags & RUNNING) && ch->action != BOOT) break;
  57.      if (ch != NULL && got_signals == 0) check_init_fifo();
  58.      fail_check();
  59.      process_signals();
  60.      start_if_needed();
  61.   }
  62.   /*NOTREACHED*/
  63. }

重头戏开始了，注意，解析inittab的逻辑是，一行一行解析，碰到id号重复的或者不合法的就跳过，如果没有错误则加入全局family链表

  1. void read_inittab(void)
  2. {
  3.   FILE        *fp;            /* The INITTAB file */
  4.   CHILD        *ch, *old, *i;        /* Pointers to CHILD structure */
  5.   CHILD        *head = NULL;        /* Head of linked list */
  7.   sigset_t    nmask, omask;        /* For blocking SIGCHLD. */
  8.   char        buf[256];        /* Line buffer */
  9.   char        err[64];        /* Error message. */
  10.   char        *id, *rlevel,
  11.         *action, *process;    /* 这四个字段代表的正是inittab文件中每一行的信息 */
  12.   char        *p;
  13.   int        lineNo = 0;        /* Line number in INITTAB file */
  14.   int        actionNo;        /* Decoded action field */
  15.   int        f;            /* Counter */
  16.   int        round;            /* round 0 for SIGTERM, 1 for SIGKILL */
  17.   int        foundOne = 0;        /* No killing no sleep */
  18.   int        talk;            /* Talk to the user */
  19.   int        done = 0;        /* Ready yet? */
  20.   if ((fp = fopen(INITTAB, “r”)) == NULL)
  21.     initlog(L_VB, “No inittab file found”);
  22.   while(!done) {//循环读取inittab的每一个行。
  23.     if (fp == NULL || fgets(buf, sizeof(buf), fp) == NULL) {   //将一行的信息存入buf
  24.         done = 1;                                          //如果没有到行尾就说明没有结束
  25.         for(old = newFamily; old; old = old->next)         
  26.             if (strpbrk(old->rlevel, “S”)) break;
  27.         if (old == NULL)
  28.             snprintf(buf, sizeof(buf), “~~:S:wait:%s\n”, SULOGIN);
  29.         else
  30.             continue;
  31.     }
  32.     lineNo++;  //递增行号
  33.     for(p = buf; *p == ‘ ’ || *p == ‘\t’; p++);//以下的解析逻辑就不细说了，挺好理解的，就是解析字符串，我最讨厌这件事了
  34.     if (*p == ‘#’ || *p == ‘\n’) continue;
  35.     id =      strsep(&p, “:”);
  36.     rlevel =  strsep(&p, “:”);
  37.     action =  strsep(&p, “:”);
  38.     process = strsep(&p, “\n”);
  39.     err[0] = 0;
  40.     if (!id || !*id) strcpy(err, “missing id field”);
  41.     if (!rlevel)     strcpy(err, “missing runlevel field”);
  42.     if (!process)    strcpy(err, “missing process field”);
  43.     if (!action || !*action)
  44.             strcpy(err, “missing action field”);
  45.     if (id && strlen(id) > sizeof(utproto.ut_id))
  46.         sprintf(err, “id field too long (max %d characters)”,
  47.             (int)sizeof(utproto.ut_id));
  48.     if (rlevel && strlen(rlevel) > 11)
  49.         strcpy(err, “rlevel field too long (max 11 characters)”);
  50.     if (process && strlen(process) > 127)
  51.         strcpy(err, “process field too long”);
  52.     if (action && strlen(action) > 32)
  53.         strcpy(err, “action field too long”);
  54.     if (err[0] != 0) {
  55.         initlog(L_VB, “%s[%d]: %s”, INITTAB, lineNo, err);
  56.         INITDBG(L_VB, “%s:%s:%s:%s”, id, rlevel, action, process);
  57.         continue;
  58.     }
  59.     actionNo = -1;
  60.     for(f = 0; actions[f].name; f++)  //actions代表一个结构数组，将一个说明运行方式的字符串映射到一个数字。这个循环就是匹配运行方式字符串并将它映射成数字。
  61.         if (strcasecmp(action, actions[f].name) == 0) {
  62.             actionNo = actions[f].act;
  63.             break;
  64.         }
  65.     if (actionNo == -1) {
  66.         initlog(L_VB, “%s[%d]: %s: unknown action field”,
  67.             INITTAB, lineNo, action);
  68.         continue;
  69.     }
  70.     for(old = newFamily; old; old = old->next) {//这个循环检测唯一性，如果已经有这个id了，那么就不往下继续了，直接读取下一行。
  71.         if(strcmp(old->id, id) == 0 && strcmp(id, “~~”)) {
  72.             initlog(L_VB, “%s[%d]: duplicate ID field \”%s\”",
  73.                 INITTAB, lineNo, id);
  74.             break;
  75.         }
  76.     }
  77.     if (old) continue;
  78.     ch = imalloc(sizeof(CHILD));//分配一个CHILD，注意这个结构很重要，前面已经说过了。
  79.     ch->action = actionNo;      //从这里开始就开始初始化这个新创建的CHILD结构了，同样，细节我就不说了。
  80.     strncpy(ch->id, id, sizeof(utproto.ut_id) + 1); /* Hack for different libs. */
  81.     strncpy(ch->process, process, sizeof(ch->process) - 1);
  82.     if (rlevel[0]) {
  83.         for(f = 0; f < sizeof(rlevel) - 1 && rlevel[f]; f++) {
  84.             ch->rlevel[f] = rlevel[f];
  85.             if (ch->rlevel[f] == ‘s’) ch->rlevel[f] = ‘S’;
  86.         }
  87.         strncpy(ch->rlevel, rlevel, sizeof(ch->rlevel) - 1);
  88.     } else {
  89.         strcpy(ch->rlevel, “0123456789″);
  90.         if (ISPOWER(ch->action))
  91.             strcpy(ch->rlevel, “S0123456789″);
  92.     }
  93.     if (ch->action == SYSINIT) strcpy(ch->rlevel, “#”);
  94.     if (ch->action == BOOT || ch->action == BOOTWAIT)
  95.         strcpy(ch->rlevel, “*”);
  96.     if (ISPOWER(ch->action)) {   //这个if-else判断就是简单地将新创建的CHILD先链接到一个局部链表newFamily，这个newFamily链表的意义在于检测id号的唯一性
  97.         ch->flags |= XECUTED;//XECUTED标志代表已经执行过，init程序不会再重新执行它了
  98.         old = NULL;
  99.         for(i = newFamily; i; i = i->next) {
  100.             if (!ISPOWER(i->action)) break;
  101.             old = i;
  102.         }
  103.         if (old) {
  104.             ch->next = i;
  105.             old->next = ch;
  106.             if (i == NULL) head = ch;
  107.         } else {
  108.             ch->next = newFamily;
  109.             newFamily = ch;
  110.             if (ch->next == NULL) head = ch;
  111.         }
  112.     } else {
  113.         if (ch->action == KBREQUEST) ch->flags |= XECUTED;
  114.         ch->next = NULL;
  115.         if (head)
  116.             head->next = ch;
  117.         else
  118.             newFamily = ch;
  119.         head = ch;
  120.     }
  121.     for(old = family; old; old = old->next)     //全局意义上的分析，看是否有人两次解析inittab之间改动了inittab文件
  122.         if (strcmp(old->id, ch->id) == 0) { //如果有人改动了，那么以最近一次解析结果为准
  123.             old->new = ch;
  124.             break;
  125.         }
  126.   }
  127.   if (fp) fclose(fp);
  128.   INITDBG(L_VB, “Checking for children to kill”);
  129.  ……   //这里省略了一个逻辑，该逻辑就是检测看是否有需要结束的进程，如果有的话就进一步判断能否结束，判断通过结束之。有一点要注意的是，并不是仅仅在系统启动的时候要解析inittab，而是系统运行中的时候通过给init进程发信号也可以让init进程解析inittab脚本文件
  130.   if (foundOne) do_sleep(1);
  131.   for(ch = family; ch; ch = ch->next)
  132.     if (ch->flags & KILLME) {
  133.         if (!(ch->flags & ZOMBIE))
  134.             initlog(L_CO, “Pid %d [id %s] seems to hang”, ch->pid, ch->id);
  135.         else {
  136.             INITDBG(L_VB, “Updating utmp for pid %d [id %s]“,ch->pid, ch->id);
  137.             ch->flags &= ~RUNNING;
  138.             if (ch->process[0] != ‘+’)
  139.                 write_utmp_wtmp(“”, ch->id, ch->pid, DEAD_PROCESS, NULL);
  140.         }
  141.     }
  142.   sigemptyset(&nmask);
  143.   sigaddset(&nmask, SIGCHLD);
  144.   sigprocmask(SIG_BLOCK, &nmask, &omask);
  145.   for(ch = family; ch; ch = old) {//释放掉原来的老的链表元素
  146.     old = ch->next;
  147.     free(ch);
  148.   }
  149.   family = newFamily;  //终于将局部链表链入全局链表了，链入的肯定是没有错误的链表
  150.   for(ch = family; ch; ch = ch->next) ch->new = NULL;
  151.   newFamily = NULL;
  152.   sigprocmask(SIG_SETMASK, &omask, NULL);
  153. }

解析完毕inittab之后就要开始执行inittab中要求执行的程序了，现在全局链表family已经设置好，接下来需要做的就是遍历这个链表然后依次执行链表中元素指定的程序，然后根据元素的一些字段设置一些参数，而这些参数进一步反馈到主循环，指示下一部的行为，还是看代码吧：

  1. void start_if_needed(void)
  2. {
  3.     CHILD *ch;        
  4.     int delete;    
  5.     INITDBG(L_VB, “Checking for children to start”);
  6.     for(ch = family; ch; ch = ch->next) {      //循环遍历family链表中的一切元素。
  7.         if (ch->flags & WAITING) break;    //如果有等待标志，那么说明只有这个程序执行完才可以往下进行，故直接退出循环。
  8.         if (ch->flags & RUNNING) continue; //如果已经在运行了，那么忽略它。
  9.         delete = 1;
  10.         if (strchr(ch->rlevel, runlevel) ||((ch->flags & DEMAND) && !strchr(“#*Ss”, runlevel))) {
  11.             startup(ch);      //启动一个进程，具体的代码就不分析了，startup中要做的就是设置一些CHILD结构的标志然后fork出一个进程并且exec这个要执行的程序，以上的if (ch->flags & WAITING)判断之类的就是在startup中被设置的。
  12.             delete = 0;
  13.         }
  14.         if (delete) {  //如果需要删除，则将该CHILD从全局表删除，因为留着它没有任何意义
  15.             ch->flags &= ~(RUNNING|WAITING);
  16.             if (!ISPOWER(ch->action) && ch->action != KBREQUEST)
  17.                 ch->flags &= ~XECUTED;
  18.             ch->pid = 0;
  19.         } else
  20.             if (ch->flags & WAITING) break;  //如果新执行的程序在startup中其flags被设置了WAITING，那么就不继续循环了，原因同上。
  21.     }
  22. }

以上这个函数很短，就是一些判断然后执行，但是如果在startup中设置了WAITING，那么何时清除它呢？这就是信号处理的事情了，众所周知，一旦子进程结束就要向父进程发送一个SIGCHLD信号，那么我们就看一下init进程的SIGCHLD信号处理器chld_handler：

  1. void chld_handler()
  2. {
  3.     CHILD        *ch;
  4.     int        pid, st;
  5.     int        saved_errno = errno;
  6.     while((pid = waitpid(-1, &st, WNOHANG)) != 0) {   //找到结束进程的pid
  7.         if (errno == ECHILD) break;
  8.         for( ch = family; ch; ch = ch->next )     //遍历family链表，找到关于这个进程的CHILD
  9.             if ( ch->pid == pid && (ch->flags & RUNNING) ) {
  10.                 ADDSET(got_signals, SIGCHLD);  //将信号加入全局的got_signals，这个got_signals要在process_signals用
  11.                 ch->exstat = st;
  12.                 ch->flags |= ZOMBIE;      //设置ZOMBIE标志，这个标志在init_main主循环中的process_signals要用来清除WAITING标志。
  13.                 if (ch->new) {
  14.                     ch->new->exstat = st;
  15.                     ch->new->flags |= ZOMBIE;
  16.                 }
  17.                 break;
  18.             }
  19.         if (ch == NULL)
  20.             INITDBG(L_VB, “chld_handler: unknown child %d exited.”, pid);
  21.     }
  22.     errno = saved_errno;
  23. }

那么我们就来看一下got_signals,我们只关心我们关注的信号：

  1. void process_signals()
  2. {
  3.   CHILD        *ch;
  4.   int        pwrstat;
  5.   int        oldlevel;
  6.   int        fd;
  7.   char        c;
  8. ……
  9.   if (ISMEMBER(got_signals, SIGCHLD)) {   //子进程结束信号
  10.     INITDBG(L_VB, “got SIGCHLD”);
  11.     DELSET(got_signals, SIGCHLD);     
  12.     for(ch = family; ch; ch = ch->next)  //找到结束的子进程
  13.         if (ch->flags & ZOMBIE) {        //注意，init在chld_handler中设置了ZOMBIE标志
  14.         ch->flags &= ~(RUNNING|ZOMBIE|WAITING);  //清除RUNNING，ZOMBIE，WAITING
  15.         if (ch->process[0] != ‘+’)
  16.             write_utmp_wtmp(“”, ch->id, ch->pid, DEAD_PROCESS, NULL);
  17.         }
  18.   }
  19.   if (ISMEMBER(got_signals, SIGHUP)) {//这个信号大家一定很熟悉，我们经常在命令行敲的kill -1 1就是这个信号，重新载入inittab
  20.     {
  21.         oldlevel = runlevel;
  22.         if (runlevel == ‘U’) {
  23.             runlevel = oldlevel;
  24.             re_exec();
  25.         } else {
  26.             if (oldlevel != ‘S’ && runlevel == ‘S’) console_stty();
  27.             if (runlevel == ’6′ || runlevel == ’0′ ||
  28.                 runlevel == ’1′) console_stty();
  29.             read_inittab();
  30.             fail_cancel();
  31.             setproctitle(“init [%c]“, runlevel);
  32.             DELSET(got_signals, SIGHUP);
  33.         }
  34.     }
  35.   }
  36. ……
  37. }

上面函数不短，但是做事逻辑很清晰，比如清除了WAITING后，在start_if_needed中就可以继续往下进行了。
  这样，整个代码大体逻辑就分析完了，通读代码，并没有发现/etc/rc.d等信息，实际上这些都是在inittab中约定好的，你只要按照inittab的格式写脚本就可以了，如果不按inittab规则写的话系统就可能起不来了，因为init程序定义了inittab的解析规则，这是一种机制和策略分离的体现，机制就是inittab的规则，包括运行级别的概念，而策略完全可以在inittab中调用的脚本中体现，但是有人会问定义如此一个inittab规则是不是机制和策略的耦合性过大了，你完全可以这么说，耦合性过大可能不好，但是读完我的下一篇文章了解到bsd的init程序后你可能会认为耦合性过小也不是什么好事，所以耦合性多大为宜是很难界定的。

来自:http://blog.csdn.net/dog250/archive/2008/11/12/3279772.aspx

原创文章，转载请注明： 转载自PT Ubuntu Blog

本文链接地址: http://www.ptubuntu.com/2008/12/780.html

Share
发表评论?

发表评论

电子邮件地址不会被公开。 必填项已用 * 标注

*

您可以使用这些 HTML 标签和属性： <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>


Verify Code   If you cannot see the CheckCode image,please refresh the page again!