nginx-----master中的信号处理

最新推荐文章于 2024-05-05 15:01:55 发布
最新推荐文章于 2024-05-05 15:01:55 发布
阅读量1.5k 收藏
点赞数
分类专栏： Nginx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013009575/article/details/17552779
版权
1.nginx信号集 
ngx_signal_t  signals[] = {
    { ngx_signal_value(NGX_RECONFIGURE_SIGNAL),
      "SIG" ngx_value(NGX_RECONFIGURE_SIGNAL),
      "reload",
      ngx_signal_handler },


    { ngx_signal_value(NGX_REOPEN_SIGNAL),
      "SIG" ngx_value(NGX_REOPEN_SIGNAL),
      "reopen",
      ngx_signal_handler },


    { ngx_signal_value(NGX_NOACCEPT_SIGNAL),
      "SIG" ngx_value(NGX_NOACCEPT_SIGNAL),
      "",
      ngx_signal_handler },


    { ngx_signal_value(NGX_TERMINATE_SIGNAL),
      "SIG" ngx_value(NGX_TERMINATE_SIGNAL),
      "stop",
      ngx_signal_handler },


    { ngx_signal_value(NGX_SHUTDOWN_SIGNAL),
      "SIG" ngx_value(NGX_SHUTDOWN_SIGNAL),
      "quit",
      ngx_signal_handler },


    { ngx_signal_value(NGX_CHANGEBIN_SIGNAL),
      "SIG" ngx_value(NGX_CHANGEBIN_SIGNAL),
      "",
      ngx_signal_handler },


    { SIGALRM, "SIGALRM", "", ngx_signal_handler },


    { SIGINT, "SIGINT", "", ngx_signal_handler },


    { SIGIO, "SIGIO", "", ngx_signal_handler },


    { SIGCHLD, "SIGCHLD", "", ngx_signal_handler },


    { SIGSYS, "SIGSYS, SIG_IGN", "", SIG_IGN },


    { SIGPIPE, "SIGPIPE, SIG_IGN", "", SIG_IGN },


    { 0, NULL, "", NULL }
};

2.信号处理函数
注意:在信号处理函数中,没有调用任何操作,他仅仅只是设置标志位,等待在ngx_master_process_cycle主循环中进行相关操作. 
void
ngx_signal_handler(int signo)
{
    char            *action;
    ngx_int_t        ignore;
    ngx_err_t        err;
    ngx_signal_t    *sig;


    ignore = 0;


    err = ngx_errno;


    for (sig = signals; sig->signo != 0; sig++) {
        if (sig->signo == signo) {
            break;
        }
    }


    ngx_time_sigsafe_update();


    action = "";


    switch (ngx_process) {


    case NGX_PROCESS_MASTER:
    case NGX_PROCESS_SINGLE:
        switch (signo) {


        case ngx_signal_value(NGX_SHUTDOWN_SIGNAL):
            ngx_quit = 1;
            action = ", shutting down";
            break;


        case ngx_signal_value(NGX_TERMINATE_SIGNAL):
        case SIGINT:
            ngx_terminate = 1;
            action = ", exiting";
            break;


        case ngx_signal_value(NGX_NOACCEPT_SIGNAL):
            if (ngx_daemonized) {
                ngx_noaccept = 1;
                action = ", stop accepting connections";
            }
            break;


        case ngx_signal_value(NGX_RECONFIGURE_SIGNAL):
            ngx_reconfigure = 1;
            action = ", reconfiguring";
            break;


        case ngx_signal_value(NGX_REOPEN_SIGNAL):
            ngx_reopen = 1;
            action = ", reopening logs";
            break;


        case ngx_signal_value(NGX_CHANGEBIN_SIGNAL):
            if (getppid() > 1 || ngx_new_binary > 0) {


                /*
                 * Ignore the signal in the new binary if its parent is
                 * not the init process, i.e. the old binary's process
                 * is still running.  Or ignore the signal in the old binary's
                 * process if the new binary's process is already running.
                 */


                action = ", ignoring";
                ignore = 1;
                break;
            }


            ngx_change_binary = 1;
            action = ", changing binary";
            break;


        case SIGALRM:
            ngx_sigalrm = 1;
            break;


        case SIGIO:
            ngx_sigio = 1;
            break;


        case SIGCHLD:
            ngx_reap = 1;
            break;
        }


        break;


    case NGX_PROCESS_WORKER:
    case NGX_PROCESS_HELPER:
        switch (signo) {


        case ngx_signal_value(NGX_NOACCEPT_SIGNAL):
            if (!ngx_daemonized) {
                break;
            }
            ngx_debug_quit = 1;
        case ngx_signal_value(NGX_SHUTDOWN_SIGNAL):
            ngx_quit = 1;
            action = ", shutting down";
            break;


        case ngx_signal_value(NGX_TERMINATE_SIGNAL):
        case SIGINT:
            ngx_terminate = 1;
            action = ", exiting";
            break;


        case ngx_signal_value(NGX_REOPEN_SIGNAL):
            ngx_reopen = 1;
            action = ", reopening logs";
            break;


        case ngx_signal_value(NGX_RECONFIGURE_SIGNAL):
        case ngx_signal_value(NGX_CHANGEBIN_SIGNAL):
        case SIGIO:
            action = ", ignoring";
            break;
        }


        break;
    }


    ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0,
                  "signal %d (%s) received%s", signo, sig->signame, action);


    if (ignore) {
        ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, 0,
                      "the changing binary signal is ignored: "
                      "you should shutdown or terminate "
                      "before either old or new binary's process");
    }


    if (signo == SIGCHLD) {
        ngx_process_get_status();
    }


    ngx_set_errno(err);
}

3.信号和信号处理函数进行绑定在main中,他调用ngx_init_signals完成相关操作. 
ngx_int_t
ngx_init_signals(ngx_log_t *log)
{
    ngx_signal_t      *sig;
    struct sigaction   sa;


    for (sig = signals; sig->signo != 0; sig++) {
        ngx_memzero(&sa, sizeof(struct sigaction));
        sa.sa_handler = sig->handler; 
        sigemptyset(&sa.sa_mask);
        if (sigaction(sig->signo, &sa, NULL) == -1) { //绑定信号和信号处理函数
            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
                          "sigaction(%s) failed", sig->signame);
            return NGX_ERROR;
        }
    }


    return NGX_OK;
}

4.进入master_cycle主循环后,等待信号触发,即阻塞在sigsuspend中.当信号到来时候会进行相关操作. 
//无限循环,等待信号
    for ( ;; ) {
     //设置延时
        if (delay) {
            if (ngx_sigalrm) {
                sigio = 0;
                delay *= 2;
                ngx_sigalrm = 0;
            }


            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                           "termination cycle: %d", delay);
         //设置延时时间
            itv.it_interval.tv_sec = 0;
            itv.it_interval.tv_usec = 0;
            itv.it_value.tv_sec = delay / 1000;
            itv.it_value.tv_usec = (delay % 1000 ) * 1000;
         //启动延时
            if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                              "setitimer() failed");
            }
        }


        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "sigsuspend");


        sigsuspend(&set);


        ngx_time_update();


        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                       "wake up, sigio %i", sigio);


     //收到了SIGCHLD信号，有worker退出
        if (ngx_reap) {
            ngx_reap = 0;
            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "reap children");


            live = ngx_reap_children(cycle);
        }
     //如果worker都退出了  
        //并且收到了NGX_CMD_TERMINATE命令或者SIGTERM信号或SIGINT信号(ngx_terminate ==1)  
        //或NGX_CMD_QUIT命令或SIGQUIT信号(ngx_quit == 1),则master退出  
        if (!live && (ngx_terminate || ngx_quit)) {
            ngx_master_process_exit(cycle);
        }
     //如果有ngx_terminate信号,则通知所有worker进程退出
     //并且等待所有worker进程都退出后master进程退出
        if (ngx_terminate) {
            if (delay == 0) {
                delay = 50; //设置延时
            }


            if (sigio) {
                sigio--;
                continue;
            }


            sigio = ccf->worker_processes + 2 /* cache processes */;


            if (delay > 1000) {
             //延时过大,kill掉所有worker进程
                ngx_signal_worker_processes(cycle, SIGKILL); //kill掉子进程
            } else {
            //发送SIGTERM信号给worker,通知其退出
                ngx_signal_worker_processes(cycle,
                                       ngx_signal_value(NGX_TERMINATE_SIGNAL));
            }


            continue;
        }


     //NGX_CMD_QUIT命令或SIGQUIT信号
        if (ngx_quit) {
         //给所有worker进程发送SIGQUIT信号
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));


            //关闭所有监听的socket
            ls = cycle->listening.elts;
            for (n = 0; n < cycle->listening.nelts; n++) {
                if (ngx_close_socket(ls[n].fd) == -1) {
                    ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
                                  ngx_close_socket_n " %V failed",
                                  &ls[n].addr_text);
                }
            }
            cycle->listening.nelts = 0;


            continue;
        }
     //收到SIGHUP信号,重新载入配置
        if (ngx_reconfigure) {
            ngx_reconfigure = 0;
         //如果是平滑升级,则重启worker
            if (ngx_new_binary) {
                ngx_start_worker_processes(cycle, ccf->worker_processes,
                                           NGX_PROCESS_RESPAWN);
                ngx_start_cache_manager_processes(cycle, 0);
                ngx_noaccepting = 0;


                continue;
            }


            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reconfiguring");
         //重新初始化配置
            cycle = ngx_init_cycle(cycle);
            if (cycle == NULL) {
                cycle = (ngx_cycle_t *) ngx_cycle;
                continue;
            }
         //重启worker
            ngx_cycle = cycle;
            ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx,
                                                   ngx_core_module);
            ngx_start_worker_processes(cycle, ccf->worker_processes,
                                       NGX_PROCESS_JUST_RESPAWN);
            ngx_start_cache_manager_processes(cycle, 1);


            /* allow new processes to start */
            ngx_msleep(100);


            live = 1;
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
        }


     //当ngx_noaccepting==1时，会把ngx_restart设为1，重启worker  
        if (ngx_restart) {
            ngx_restart = 0;
            ngx_start_worker_processes(cycle, ccf->worker_processes,
                                       NGX_PROCESS_RESPAWN);
            ngx_start_cache_manager_processes(cycle, 0);
            live = 1;
        }
        //收到SIGUSR1信号，重新打开所有文件
        if (ngx_reopen) {
            ngx_reopen = 0;
            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
            ngx_reopen_files(cycle, ccf->user);
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_REOPEN_SIGNAL));
        }
     //平滑升级,SIGUSER2信号
        if (ngx_change_binary) {
            ngx_change_binary = 0;
            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "changing binary");
            ngx_new_binary = ngx_exec_new_binary(cycle, ngx_argv);
        }
     //不在接收请求,worker退出,master不退出
        if (ngx_noaccept) {
            ngx_noaccept = 0;
            ngx_noaccepting = 1;
            ngx_signal_worker_processes(cycle,
                                        ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
        }
    }

随心而动随意而行
关注
专栏目录
NGX 信号处理流程
Dalek的专栏
07-11 943
int ngx_cdecl main(int argc, char *const *argv) { .... #if !(NGX_WIN32) if (ngx_init_signals(cycle->log) != NGX_OK) { // 服务器启动时进行初始化信号处理 return 1; } if (!ngx_inherited && ccf
nginx-工作原理及配置文件详解＜一＞
Op_Wa的博客
10-26 2456
nginx工作原理 nginx由内核和模块组成。其中，内核的设计非常微小和简洁，完成的工作也非常简单，仅仅通过查找配置文件将客户端请求映射到一个location block（location是nginx配置中的一个指令，用于URI匹配），而在这个location中所配置的每个指令将会启动不同的模块去完成相应的工作。 nginx的模块分类 nginx的模块从结构上分为核心模块、基础模块和第三方模块 HTTP模块、EVENT模块和MAIL模块等属于核心模块 HTTP Access模块、HTTP FastCGI
【nginx】nginx介绍-信号处理
zwan0518的专栏
11-15 3176
nginx是通过master进程和worker进程进行工作提供服务的模式。master进程主要用来监听worker进程状态进行相应的重启、停止等操作；worker进程则进行具体的提供服务，接受和处理请求。在master和worker进程之间的通信则是通过信号的方式。这篇文章就讲述我们在运维和使用nginx的时候，对于几种常用的信号nginx是如何处理的。
nginx-6 信号处理
yt_php的博客
02-22 423
nginx的信号处理，根据传入的信号做处理。 如终止掉主进程 如热处理等都可以通过信号处理器实现 信号（signal）的名字都以SIG开头，查看全部信号名称 kill[参数][进程号]，发送指定的信号到相应进程。不指定型号将发送SIGTERM（15）终止指定进程。 常用信号： SIGTERM(15), INT(2) 快速关闭 &amp;amp;amp;amp;lt;同 Ctrl + C&amp;amp;amp;amp;gt; SIGQUIT(3) 从容...
从实战出发，谈谈 nginx 信号集
weixin_30474613的博客
11-29 171
前言 之前工作时候，一台引流测试机器的一个 ngx_lua 服务突然出现了一些 HTTP/500 响应，从错误日志打印的堆栈来看，是不久前新发布的版本里添加的一个 Lua table 不存在，而有代码向其进行索引导致的。这令人百思不得其解，如果是版本回退导致的，那么为什么使用这个 Lua table 的代码没有被回退，偏偏定义这个 table 的代码被回退了呢？ 经过排查发现，当时 ...
nginx信号管理
error311的博客
03-06 136
1.查看nginx进程 ps -aux|grep nginx 2. QUIT 优雅的关闭进程,即等请求结束后再关闭 kill -QUIT 7623 3. TERM，INT 强制关闭 kill -TERM 7623 4.HUP 改变配置文件,平滑的重读配置文件（处理完此进程后，重新加载配置文件） kill -HUP 7623 5.USR1 重读日志（日志文...
nginx-rtmp-module-master.zip
02-08
总之，`nginx-rtmp-module-master.zip` 提供了一整套完善的实时流处理方案，无论是搭建简单的直播平台还是构建复杂的流媒体系统，都能发挥重要作用。通过深入理解和灵活运用，可以实现高效、稳定的流媒体服务。
nginx-1.21.6.tar.gz
03-05
**Nginx 1.21.6：高效Web服务器与反向代理详解** Nginx 是一个高性能的HTTP和反向...在实际应用中，Nginx 不仅可以作为静态资源服务器，还可以作为复杂架构中的关键组件，处理动态请求、负载均衡和安全防护等任务。
nginx -s reload原理
u011764940的博客
01-06 3534
我们执行这条命令的原因是希望 nginx 不停止服务始终在处理新的请求的同时把 nginx 的配置文件平滑的把旧的 nginx.conf 配置更新为新的 nginx.conf 配置。 这样一个功能对于 nginx 非常有必要，但是有时候我们会发现在执行nginx -s reload命令后，worker 子进程的数量会变多了，这是因为老的配置运行的 worker 进程长时间没有退出，当使用 stream 做四层反向代理的时候，可能这种场景会更多。 nginx reload流程 (1)向 master..
Nginx笔记-Nginx中进程结构及使用Linux信号量管理
01-09
Nginx只能处理静态资源，动态资源还得反向代理到应用服务器上。 下面是Nginx处理请求的过程： Nginx有点及特点 热部署、平滑升级、开源及二次开发、高并发高性能、扩展性好、异步非阻塞的事件驱动模型 Nginx是多...
Nginx服务的信号控制
Leon_Jinhai_Sun的博客
10-28 201
Nginx服务的信号控制 Nginx中的master和worker进程? Nginx的工作方式? 如何获取进程的PID? 信号有哪些? 如何通过信号控制Nginx的启停等相关操作? 前面在提到Nginx的高性能，其实也和它的架构模式有关。Nginx默认采用的是多进程的方式来工作的，当将Nginx启动后，我们通过ps -ef | grep nginx命令可以查看到如下内容： 从上图中可以看到,Nginx后台进程中包含一个master进程和多个worker进程，master进程主要用来管理worke
深入理解nginx中的signal处理机制
最新发布
一个致力于开源代码学习、分析和交流的博客
05-05 849
本文通过对nginx的源码分析，从signal信号的注册和阻塞状态设置，到signal信号的处理，最后到跨进程singla信号的发送进行了详细的介绍，我们可以从中一窥nginx如何利用操作系统的signal机制来实现对进程的各种控制功能。
Nginx的信号控制与配置和日志
小麦大大博客
08-20 195
信号 具体语法: Kill -信号选项 nginx的主进程号 Kill -HUP 4873 Kill -信号控制 `cat /xxx/path/log/nginx.pid` Kil; -USR1 `cat /usr/local/nginx/logs/nginx.pid` 配置 Nginx配置段 // 全局区 worker_processes 1; // 有1个工作的子进程,可以自行...
摘录nginx 信号处理方法部分代码
liu0808的专栏
11-27 267
编译及执行步骤： 1.接收进程编译 ： g++ -g -o a.out signal.c 2.运行接收进程：./a.out 3.发送进程编译： g++ -o b.out signal.c 4.发送进程查询接收进程pid：ps -alx | grep a.out | awk ‘{print $3}’ 5.发送进程发送信号：./b.out -s reload -p 36357（36357是第4部查询到
Nginx架构篇之 Nginx的进程结构和信号管理 (六)
jqsfjqsf的博客
02-17 265
本系列文章目录 展开/收起 Nginx初认识之 Nginx重载配置文件、热部署和更新日志 (一) Nginx初认识之 Nginx搭建静态资源服务器 (二) Nginx初认识之 Nginx搭建反向代理服务器 (三) Nginx初认识之 GoAccess可视化实时监控access.log日志 (四) Nginx初认识之...
SIGHUP信号与控制终端
ClearRiver 's Style
06-28 1376
UNIX中进程组织结构为 session (会话)包含一个前台进程组及一个或多个后台进程组，一个进程组包含多个进程。一个session可能会有一个session首进程，而一个session首进程可能会有一个控制终端。一个进程组可能会有一个进程组首进程。进程组首进程的进程ID与该进程组ID相等。这儿是可能会有，在一定情况之下是没有的。与终端交互的进程是前台进程，否则便是后台进程。  SIGHUP会在
nginx master工作循环
爱宝贝丶的博客
12-24 418
【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> ...
Nginx master工作流程
猫和鱼爪的鸟窝
07-28 2098
master工作流程图       master进程不需要处理网络事件，它不负责业务的执行，只会通过管理worker等子进程来实现重启服务、平滑升级、更换日志文件、配置文件实时生效等功能。       它会通过检查一下7个标志位来决定ngx_master_process_cycle函数的运行（和worker检查4个标志位是差不多的）： 1. sig_atomic ngx_reap
【Linux网络编程】Nginx -- 核心数据结构体与处理流程(二)
CopperSun 技术博客
04-26 300
【Linux网络编程】Nginx -- 核心数据结构体与处理流程(二) 【1】Nginx 框架启动流程分析 【1.1】Nginx 框架启动 ——一般过程 1) 因为 Nginx 是以配置文件作为核心提供服务的，所以最主要的就是确定配置文件 nginx.conf 的路径，此处会预先创建一个临时的 ngx_cycle_t 类型变量，用它的成员存储配置文件路径(实际上还会使用这个临时 ngx_cycle_t 结构体的其他成员，如 log 成员会指向屏幕输出日志)，最后调用 ngx_process_op.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值