从 mian 函数开始一步一步分析 nginx 执行流程（四）

如不做特殊说明，本博客所使用的 nginx 源码版本是 1.0.14，[] 中是代码所在的文件！

这一节我们分析ngx_worker_process_cycle()，该函数代码比较少，因为它通过调用函数实现功能的，先贴出代码：

[os/unix/ngx_process_cycle.c

  /* worker_process 所执行的程序，nginx 核心所在 */
  static void
  ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
  {
      ngx_uint_t         i;
      ngx_connection_t  *c;

      ngx_process = NGX_PROCESS_WORKER;

      /* worker 进程初始化 */
      ngx_worker_process_init(cycle, );

      /* 设置程序名称 */
      ngx_setproctitle("worker process");

　　1. 768 行设置 ngx_process 的值为 NGX_PROCESS_WORKER, 该值会在信号回调函数中有用ngx_signal_handler()[ngx_process.c]，该值表示的是进程模型的类型。

　　2. 771 行调用 ngx_worker_process_init() 来先对 worker 进程进行一下初始化，该函数的源码如下：

  /* worker_process 初始化，根据配置来设置一些属性 */
  static void
  ngx_worker_process_init(ngx_cycle_t *cycle, ngx_uint_t priority)
  {
      sigset_t          set;
      ngx_int_t         n;
      ngx_uint_t        i;
      struct rlimit     rlmt;
      ngx_core_conf_t  *ccf;
      ngx_listening_t  *ls;

      if (ngx_set_environment(cycle, NULL) == NULL) {
          /* fatal */
          exit();
      }

      ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

      if (priority && ccf->priority != ) {
          if (setpriority(PRIO_PROCESS, , ccf->priority) == -) {
              ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                            "setpriority(%d) failed", ccf->priority);
          }
      }

      if (ccf->rlimit_nofile != NGX_CONF_UNSET) {
          rlmt.rlim_cur = (rlim_t) ccf->rlimit_nofile;
          rlmt.rlim_max = (rlim_t) ccf->rlimit_nofile;

          if (setrlimit(RLIMIT_NOFILE, &rlmt) == -) {
              ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                            "setrlimit(RLIMIT_NOFILE, %i) failed",
                            ccf->rlimit_nofile);
          }
      }

      if (ccf->rlimit_core != NGX_CONF_UNSET) {
          rlmt.rlim_cur = (rlim_t) ccf->rlimit_core;
          rlmt.rlim_max = (rlim_t) ccf->rlimit_core;

          if (setrlimit(RLIMIT_CORE, &rlmt) == -) {
              ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                            "setrlimit(RLIMIT_CORE, %O) failed",
                            ccf->rlimit_core);
          }
      }

  #ifdef RLIMIT_SIGPENDING
      if (ccf->rlimit_sigpending != NGX_CONF_UNSET) {
          rlmt.rlim_cur = (rlim_t) ccf->rlimit_sigpending;
          rlmt.rlim_max = (rlim_t) ccf->rlimit_sigpending;

          if (setrlimit(RLIMIT_SIGPENDING, &rlmt) == -) {
              ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                            "setrlimit(RLIMIT_SIGPENDING, %i) failed",
                            ccf->rlimit_sigpending);
          }
      }
  #endif

      if (geteuid() == ) {
          if (setgid(ccf->group) == -) {
              ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
                            "setgid(%d) failed", ccf->group);
              /* fatal */
              exit();
          }

          if (initgroups(ccf->username, ccf->group) == -) {
              ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
                            "initgroups(%s, %d) failed",
                            ccf->username, ccf->group);
          }

          if (setuid(ccf->user) == -) {
              ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
                            "setuid(%d) failed", ccf->user);
              /* fatal */
              exit();
          }
      }

  #if (NGX_HAVE_SCHED_SETAFFINITY)

      if (cpu_affinity) {
          ngx_log_error(NGX_LOG_NOTICE, cycle->log, ,
                        "sched_setaffinity(0x%08Xl)", cpu_affinity);

          if (sched_setaffinity(, sizeof(cpu_affinity),
                                (cpu_set_t *) &cpu_affinity)
              == -)
          {
              ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                            "sched_setaffinity(0x%08Xl) failed", cpu_affinity);
          }
      }

  #endif

  #if (NGX_HAVE_PR_SET_DUMPABLE)

      /* allow coredump after setuid() in Linux 2.4.x */

      if (prctl(PR_SET_DUMPABLE, , , , ) == -) {
          ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                        "prctl(PR_SET_DUMPABLE) failed");
      }

  #endif

      if (ccf->working_directory.len) {
          if (chdir((char *) ccf->working_directory.data) == -) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                           "chdir(\"%s\") failed", ccf->working_directory.data);
             /* fatal */
             exit();
         }
     }

     sigemptyset(&set);

     if (sigprocmask(SIG_SETMASK, &set, NULL) == -) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                       "sigprocmask() failed");
     }

     /*
1015      * disable deleting previous events for the listening sockets because
1016      * in the worker processes there are no events at all at this point
1017      */
     ls = cycle->listening.elts;
     for (i = ; i < cycle->listening.nelts; i++) {
         ls[i].previous = NULL;
     }

     for (i = ; ngx_modules[i]; i++) {
         if (ngx_modules[i]->init_process) {
             /* 如果有模块设置了 init_process 函数 */
             if (ngx_modules[i]->init_process(cycle) == NGX_ERROR) {
                 /* fatal */
                 exit();
             }
         }
     }

     for (n = ; n < ngx_last_process; n++) {

         if (ngx_processes[n].pid == -) {
             continue;
         }

         if (n == ngx_process_slot) {
             continue;
         }

         if (ngx_processes[n].channel[] == -) { // channel²»ŽæÔÚ£¬Ìø¹ý
             continue;
         }

         if (close(ngx_processes[n].channel[]) == -) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                           "close() channel failed");
         }
     }

     if (close(ngx_processes[ngx_process_slot].channel[]) == -) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                       "close() channel failed");
     }

 #if 0
     ngx_last_process = ;
 #endif
     /* 貌似要加入读事件 */
     if (ngx_add_channel_event(cycle, ngx_channel, NGX_READ_EVENT,
                               ngx_channel_handler)
         == NGX_ERROR)
     {
         /* fatal */
         exit();
     }
 }

ngx_worker_process_init()

　　　　2.1 该函数的代码很长，我将代码折叠起来了！该函数有两个变量 cycle 和 priorty，其中是很多函数调用都要用的全局变量 cycle,另一个是进程优先级标识 priority（只有该标识不为 0,配置中设置进程优先级的参数才起作用。）

　　　　2.2 904 行获取与 ngx_core_moudle(核心模块) 有关的配置文件的指针。如果要用到 nginx.conf 配置文件中的配置，事先都需要这一步---用来获取模块相关的配置文件指针

　　　　2.3 906-911 行根据标识 priorty 和 配置中的 priority 值，调用 setpriority() 函数设置进程的优先级。

　　　　2.4 913-922 行根据配置中设置的 rilimit_nofile 选项值，调用 setrlimit() 函数 + RLIMIT_NOFILE 来设置进程所能打开的最大文件描述符的个数 。

　　　　2.5 924-933 行根据配置中设置的 rilimit_core 选项值，调用 setrlimit() 函数 + RLIMIT_CORE 来设置内核转存文件的最大长度。

　　　　2.6 936-945 行根据配置中设置的 rilimit_sigpending 选项值，调用 setrlimit() 函数 + RLIMIT_SIGPENDING 来设置用户可拥有的最大挂起信号数。

　　　　2.7 948-968 行判断如果执行该进程(worker 进程)是 root 用户的，支持用户在配置文件中配置的 group,username,user 选项值，根据 group 设置用户 ID 所在组 ID 的值、根据 username 和 group 从组文件(/etc/group)中读取一项组数据、根据 user 选项值设置当前进程的有效 ID 和实际 ID 都设置为 user 值。

　　　　2.8 972-983 行根据是否设置 cpu_affinity 来是否将进程 attach 到一个指定 CPU 上运行！

　　　　2.9  998-1005 行根据是否设置了 worker 进程的工作目录（working_directory）来改变当前进程( worker 进程) 到指定目录！

　　　　2.10 1007-1012 行初始化信号有关的变量 set ！

　　　　2.11 1019-1021 行遍历所有监听套接字结构体链表---待分析，英文解释部分不是很懂/* disable deleting previous events for the listening sockets because in the worker processes there are no events at all at this point  */

　　　　2.12  1023-1031 行调用每个模块设置的 init_process 回调函数！

　　　　2.13  之前我们说过每个 worker 进程在创建的时候都会创建 一对 channel(channel[0]和channel[0])，在进程之间进行通信的时候每个进程只要用到一个就行了 channel[0] 或者 channel[1],1033-1056 行很明显是关闭正在运行的 worker 进程的 channel[0]端(要用 channel[1]端j进行读写)，关闭处正在运行的 worker 进程以外的 worker 进程的 channel[1] 。

　　　　2.14 1062-1068 行调将 channel 套接口字上的读事件加入监听行列。

　　3. 774 行设置进程的名称，这里显然设置为 "worker process"。

  #if (NGX_THREADS)
      {
      ngx_int_t         n;
      ngx_err_t         err;
      ngx_core_conf_t  *ccf;

      /* 核心模块的 */
      ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

      if (ngx_threads_n) {
          if (ngx_init_threads(ngx_threads_n, ccf->thread_stack_size, cycle)
              == NGX_ERROR)
          {
              /* fatal */
              exit();
          }

          err = ngx_thread_key_create(&ngx_core_tls_key);
          if (err != ) {
              ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
                            ngx_thread_key_create_n " failed");
              /* fatal */
              exit();
          }

          for (n = ; n < ngx_threads_n; n++) {

              ngx_threads[n].cv = ngx_cond_init(cycle->log);

              if (ngx_threads[n].cv == NULL) {
                  /* fatal */
                  exit();
              }

              if (ngx_create_thread((ngx_tid_t *) &ngx_threads[n].tid,
                                    ngx_worker_thread_cycle,
                                    (void *) &ngx_threads[n], cycle->log)

　　

　　4. 776-821 行，目前还不支持线程，所以暂时不分析。

　　

      /* worker 进程也是一个死循环 */
      /* 以下的 ngx_exiting 、ngx_quit、ngx_terminate、ngx_reopen 是一个全局变量，是旗标，它们控制着 worker 进程的行为 */
      for ( ;; ) {

          /* 如果 ngx_exiting 为 1，则开始准备关闭 worker 进程*/
          if (ngx_exiting) {

              c = cycle->connections;
              /* 关闭所有正在处理的连接 */
              for (i = ; i < cycle->connection_n; i++) {

                  /* THREAD: lock */

                  if (c[i].fd != - && c[i].idle) {
                      c[i].close = ;
                      /* 调用他们对应的关闭连接处理方法 */
                      c[i].read->handler(c[i].read);
                  }
              }

              //
              if (ngx_event_timer_rbtree.root == ngx_event_timer_rbtree.sentinel)
              {
                  ngx_log_error(NGX_LOG_NOTICE, cycle->log, , "exiting");

                  ngx_worker_process_exit(cycle);
              }
          }

          ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, , "worker cycle");

          /* 通过 ngx_process_events_and_timers 调到对应的时间控制阻塞点 --- 一切事件的监听从这里开始了  */
          /* ngx_process_events_and_timers() 定义在 event/ngx_event.h/c 文件中  */
          ngx_process_events_and_timers(cycle);/* 处理事件和定时器 */

          /* 强制关闭进程 */
          if (ngx_terminate) {
              ngx_log_error(NGX_LOG_NOTICE, cycle->log, , "exiting");

              ngx_worker_process_exit(cycle);
          }

          /* 优雅的关闭进程 */
          if (ngx_quit) {
              ngx_quit = ;
              ngx_log_error(NGX_LOG_NOTICE, cycle->log, ,
                            "gracefully shutting down");
              ngx_setproctitle("worker process is shutting down");

              if (!ngx_exiting) {
                  //¹Ø±Õsocket£¬È»ºóÉèÖÃÍ˳ö±êÖŸ
                  ngx_close_listening_sockets(cycle);
                  ngx_exiting = ;
              }
          }

          /* 重新打开所有文件 */
          if (ngx_reopen) {
              ngx_reopen = ;
              ngx_log_error(NGX_LOG_NOTICE, cycle->log, , "reopening logs");
              ngx_reopen_files(cycle, -);
          }
      }
  }

　　5. worker 进程本身也是个死循环。上面的 825-885 行就是 worker 进程所在的循环　　

　　6. 之前的代码我们分析过在 master 进程收到一些信号时，有的信号会通过 ngx_signal_worker_processes() 函数发送给 worker 进程，在这个 for 循环中 worker 进程就要处理收到的这些信号。

　　7. 828-850 行，ngx_exiting 为 1，关闭所有的连接。清除所有定时器然后调用 ngx_worker_process_exit() 退出 worker 进程。

　　8. 856 行，非常重要的一行，所有的事件都在这个函数处理，服务器就等待在这个函数中，等待事件的到来(新连接到达或者客户端发来数据)! 我们将在下一节分析该函数。

　　9. 859-863 行根据是否设置 ngx_terminate 标志位来是否强制关闭进程(ngx_worker_process_exit())！

　　10. 866-877 行根据 ngx_quit 标志外来优雅的关闭进程。为什么说优雅呢？在这段代码中并不直接调用 ngx_worker_process_exit() 立即关闭进程，而是关闭所有监听套接口描述符同时设置 ngx_exiting = 1，也就是说到一个循环才会关闭该进程，让该进程在关闭之前执行完剩下的循环，做一些在关闭前还没有完全做完的工作。所以说是优雅的退出。

　　11. 880-884行调用 ngx_reopen_files 重新打开 worker 进程所打开的文件。

　　12. 至此，ngx_worker_process_cycle() 函数分析完毕。接下来要分析的函数是 ngx_process_events_and_timers(),这个函数处理所有事件。是 nginx 的精髓！>_<