Nginx学习之路（三）NginX的子进程生产过程

最新推荐文章于 2021-06-03 23:33:41 发布

曾柯

最新推荐文章于 2021-06-03 23:33:41 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

分类专栏： nginx学习文章标签： nginx 服务器多进程 c

本文链接：https://blog.youkuaiyun.com/zk3326312/article/details/79864960

nginx学习专栏收录该内容

10 篇文章

订阅专栏

本文详细解析了Nginx如何通过main函数创建worker进程，包括进程的生成流程、子进程的启动和配置步骤，以及相关系统调用如fork、socketpair等的应用。

上一篇文章中讲了Nginx的main函数的主要流程，这次就继续上次来说明一下Nginx中的worker进程是怎么生成的。

从main函数的

//进入master-worker工作模式，开始创建多个Nginx的子进程。并进入进程循环。
        ngx_master_process_cycle(cycle);

开始进入生成子进程的过程

//开始生成worker进程
    ngx_start_worker_processes(cycle, ccf->worker_processes,
                               NGX_PROCESS_RESPAWN);

然后正式生产子进程

//生成子进程，打开和子进程的会话channel
    for (i = 0; i < n; i++) {
        //ngx_worker_process_cycle这个回调函数要注意，这个是后面的worker函数的主循环
        ngx_spawn_process(cycle, ngx_worker_process_cycle,
                          (void *) (intptr_t) i, "worker process", type);

        ch.pid = ngx_processes[ngx_process_slot].pid;
        ch.slot = ngx_process_slot;
        ch.fd = ngx_processes[ngx_process_slot].channel[0];

        ngx_pass_open_channel(cycle, &ch);
    }

生产子进程的具体过程如下

ngx_pid_t
ngx_spawn_process(ngx_cycle_t *cycle, ngx_spawn_proc_pt proc, void *data,
    char *name, ngx_int_t respawn)
{
    //proc:是子进程的执行函数，  
    //data是参数，  
    //name是子进程的名字  
    u_long     on;
    ngx_pid_t  pid;
    ngx_int_t  s;//将要创建的子进程在进程表中的位置

    if (respawn >= 0) {
        s = respawn;//替换进程ngx_processes[respawn],可安全重用该进程表项  

    } else {
        for (s = 0; s < ngx_last_process; s++) {
            if (ngx_processes[s].pid == -1) {
                break;
            }
        }
	//进程表已经满 
        if (s == NGX_MAX_PROCESSES) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                          "no more than %d processes can be spawned",
                          NGX_MAX_PROCESSES);
            return NGX_INVALID_PID;
        }
    }

	//不是分离的子进程
    if (respawn != NGX_PROCESS_DETACHED) {

        /* Solaris 9 still has no AF_LOCAL */

        if (socketpair(AF_UNIX, SOCK_STREAM, 0, ngx_processes[s].channel) == -1)
        {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "socketpair() failed while spawning \"%s\"", name);
            return NGX_INVALID_PID;
        }

        ngx_log_debug2(NGX_LOG_DEBUG_CORE, cycle->log, 0,
                       "channel %d:%d",
                       ngx_processes[s].channel[0],
                       ngx_processes[s].channel[1]);
	//设置socket为非阻塞模式
        if (ngx_nonblocking(ngx_processes[s].channel[0]) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          ngx_nonblocking_n " failed while spawning \"%s\"",
                          name);
            ngx_close_channel(ngx_processes[s].channel, cycle->log);
            return NGX_INVALID_PID;
        }

        if (ngx_nonblocking(ngx_processes[s].channel[1]) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          ngx_nonblocking_n " failed while spawning \"%s\"",
                          name);
            ngx_close_channel(ngx_processes[s].channel, cycle->log);
            return NGX_INVALID_PID;
        }
	//开启channel[0]的消息驱动IO 
        on = 1;
	//FIOASYNC:设置/清楚信号驱动异步I/O标志  
        /*根据iocl 的第三个参数指向一个0 值或非0 值 
        分别清除或设置针对本套接口的信号驱动异步I/O 标志， 
        它决定是否收取针对本套接口的异步I/O 信号（SIGIO ）。 
        本请求和O_ASYNC 文件状态标志等效， 
        而该标志可以通过fcntl 的F_SETFL 命令清除或设置。*/ 
        if (ioctl(ngx_processes[s].channel[0], FIOASYNC, &on) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "ioctl(FIOASYNC) failed while spawning \"%s\"", name);
            ngx_close_channel(ngx_processes[s].channel, cycle->log);
            return NGX_INVALID_PID;
        }
	//设置channel[0]的宿主，控制channel[0]的SIGIO信号只发给这个进程 
        if (fcntl(ngx_processes[s].channel[0], F_SETOWN, ngx_pid) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "fcntl(F_SETOWN) failed while spawning \"%s\"", name);
            ngx_close_channel(ngx_processes[s].channel, cycle->log);
            return NGX_INVALID_PID;
        }
	//若进程执行了exec后，关闭socket，fcntl设定FD_CLOEXEC属性后，该fd在fork的子进程内还可以用，但是在execl调用中则不可以使用了
        if (fcntl(ngx_processes[s].channel[0], F_SETFD, FD_CLOEXEC) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "fcntl(FD_CLOEXEC) failed while spawning \"%s\"",
                           name);
            ngx_close_channel(ngx_processes[s].channel, cycle->log);
            return NGX_INVALID_PID;
        }
	//同上
        if (fcntl(ngx_processes[s].channel[1], F_SETFD, FD_CLOEXEC) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "fcntl(FD_CLOEXEC) failed while spawning \"%s\"",
                           name);
            ngx_close_channel(ngx_processes[s].channel, cycle->log);
            return NGX_INVALID_PID;
        }
	//全局变量，用于监听可读时间的socket  
        ngx_channel = ngx_processes[s].channel[1];

    } else {
        ngx_processes[s].channel[0] = -1;
        ngx_processes[s].channel[1] = -1;
    }

    ngx_process_slot = s;


    pid = fork();

    switch (pid) {

    case -1:
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "fork() failed while spawning \"%s\"", name);
        ngx_close_channel(ngx_processes[s].channel, cycle->log);
        return NGX_INVALID_PID;
	//子进程
    case 0:
	//给两个表示进程id的全局变量赋值
	ngx_parent = ngx_pid;
        ngx_pid = ngx_getpid();
	//调用传入的回调函数，子进程的正式主循环开始，回调函数的实体是ngx_worker_process_cycle
        proc(cycle, data);
        break;

    default:
        break;
    }

    ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start %s %P", name, pid);
    //设置一些进程表项字段
    ngx_processes[s].pid = pid;
    ngx_processes[s].exited = 0;
    //如果是重复创建，即为替换进程，不用设置其他进程表字段，直接返回。
    if (respawn >= 0) {
        return pid;
    }
	//设置其他进程表字段
    ngx_processes[s].proc = proc;
    ngx_processes[s].data = data;
    ngx_processes[s].name = name;
    ngx_processes[s].exiting = 0;
	//设置进程表项的一些状态字 
    switch (respawn) {

    case NGX_PROCESS_NORESPAWN:
        ngx_processes[s].respawn = 0;
        ngx_processes[s].just_spawn = 0;
        ngx_processes[s].detached = 0;
        break;

    case NGX_PROCESS_JUST_SPAWN:
        ngx_processes[s].respawn = 0;
        ngx_processes[s].just_spawn = 1;
        ngx_processes[s].detached = 0;
        break;

    case NGX_PROCESS_RESPAWN:
        ngx_processes[s].respawn = 1;
        ngx_processes[s].just_spawn = 0;
        ngx_processes[s].detached = 0;
        break;

    case NGX_PROCESS_JUST_RESPAWN:
        ngx_processes[s].respawn = 1;
        ngx_processes[s].just_spawn = 1;
        ngx_processes[s].detached = 0;
        break;

    case NGX_PROCESS_DETACHED:
        ngx_processes[s].respawn = 0;
        ngx_processes[s].just_spawn = 0;
        ngx_processes[s].detached = 1;
        break;
    }

    if (s == ngx_last_process) {
        ngx_last_process++;
    }

    return pid;
}

至此，worker进程就生成完毕了