文章目录
一：守护进程功能的实现
三章二节
(1)拦截掉SIGHUP，那么终端窗口关闭，进程就不会跟着关闭
(2)守护进程，三章七节，一运行就在后台，不会占着终端。
创建守护进程ngx_daemon（）；
/调用ngx_daemon（）的时机： worker()子进程创建之前；
ps -eo pid,ppid,sid,tty,pgrp,comm,stat,cmd | grep -E ‘bash|PID|nginx’
(1)一个master,4个worker进程，状态S，表示休眠状态，但没有+,+号表示位于前台进程组，没有+说明我们这几个进程不在前台进程组；
(2)master进程的ppid是1【老祖宗进程init】，其他几个worker进程的父进程都是master；
(3)tt这列都为？，表示他们都脱离了终端，不与具体的终端挂钩了
(4)他们的进程组PGRP都相同；
/结论：
1)守护进程如果通过键盘执行可执行文件来启动，那虽然守护进程与具体终端是脱钩的，但是依旧可以往标准错误上输出内容，这个终端对应的屏幕上可以看到输入的内容；
2)但是如果这个nginx守护进程你不是通过终端启动，你可能开机就启动，那么这个nginx守护进程就完全无法往任何屏幕上显示信息了，这个时候，要排错就要靠日志文件了；
二：信号处理函数的进一步完善
（2.1）避免子进程被杀掉时变成僵尸进程
父进程要处理SIGCHILD信号并在信号处理函数中调用waitpid()来解决僵尸进程的问题；
信号处理函数中的代码，要坚持一些书写原则：
a)代码尽可能简单，尽可能快速的执行完毕返回；
b)用一些全局量做一些标记；尽可能不调用函数；
c)不要在信号处理函数中执行太复杂的代码以免阻塞其他信号的到来，甚至阻塞整个程序执行流程；
源码：
ngx_daemon.cxx
//和守护进程相关
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <unistd.h>
#include <errno.h> //errno
#include <sys/stat.h>
#include <fcntl.h>
#include "ngx_func.h"
#include "ngx_macro.h"
#include "ngx_c_conf.h"
//描述：守护进程初始化
//执行失败：返回-1， 子进程：返回0，父进程：返回1
int ngx_daemon()
{
//(1)创建守护进程的第一步，fork()一个子进程出来
switch (fork()) //fork()出来这个子进程才会成为咱们这里讲解的master进程；
{
case -1:
//创建子进程失败
ngx_log_error_core(NGX_LOG_EMERG,errno, "ngx_daemon()中fork()失败!");
return -1;
case 0:
//子进程，走到这里直接break;
break;
default:
//父进程以往 直接退出exit(0);现在希望回到主流程去释放一些资源
return 1; //父进程直接返回1；
} //end switch
//只有fork()出来的子进程才能走到这个流程
ngx_parent = ngx_pid; //ngx_pid是原来父进程的id，因为这里是子进程，所以子进程的ngx_parent设置为原来父进程的pid
ngx_pid = getpid(); //当前子进程的id要重新取得
//(2)脱离终端，终端关闭，将跟此子进程无关
if (setsid() == -1)
{
ngx_log_error_core(NGX_LOG_EMERG, errno,"ngx_daemon()中setsid()失败!");
return -1;
}
//(3)设置为0，不要让它来限制文件权限，以免引起混乱
umask(0);
//(4)打开黑洞设备，以读写方式打开
int fd = open("/dev/null", O_RDWR);
if (fd == -1)
{
ngx_log_error_core(NGX_LOG_EMERG,errno,"ngx_daemon()中open(\"/dev/null\")失败!");
return -1;
}
if (dup2(fd, STDIN_FILENO) == -1) //先关闭STDIN_FILENO[这是规矩，已经打开的描述符，动他之前，先close]，类似于指针指向null，让/dev/null成为标准输入；
{
ngx_log_error_core(NGX_LOG_EMERG,errno,"ngx_daemon()中dup2(STDIN)失败!");
return -1;
}
if (dup2(fd, STDOUT_FILENO) == -1) //再关闭STDIN_FILENO，类似于指针指向null，让/dev/null成为标准输出；
{
ngx_log_error_core(NGX_LOG_EMERG,errno,"ngx_daemon()中dup2(STDOUT)失败!");
return -1;
}
if (fd > STDERR_FILENO) //fd应该是3，这个应该成立
{
if (close(fd) == -1) //释放资源这样这个文件描述符就可以被复用；不然这个数字【文件描述符】会被一直占着；
{
ngx_log_error_core(NGX_LOG_EMERG,errno, "ngx_daemon()中close(fd)失败!");
return -1;
}
}
return 0; //子进程返回0
}
nginx.cxx
//整个程序入口函数放这里
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include "ngx_macro.h" //各种宏定义
#include "ngx_func.h" //各种函数声明
#include "ngx_c_conf.h" //和配置文件处理相关的类,名字带c_表示和类有关
//本文件用的函数声明
static void freeresource();
//和设置标题有关的全局量
size_t g_argvneedmem=0; //保存下这些argv参数所需要的内存大小
size_t g_envneedmem=0; //环境变量所占内存大小
int g_os_argc; //参数个数
char **g_os_argv; //原始命令行参数数组,在main中会被赋值
char *gp_envmem=NULL; //指向自己分配的env环境变量的内存，在ngx_init_setproctitle()函数中会被分配内存
int g_daemonized=0; //守护进程标记，标记是否启用了守护进程模式，0：未启用，1：启用了
//和进程本身有关的全局量
pid_t ngx_pid; //当前进程的pid
pid_t ngx_parent; //父进程的pid
int ngx_process; //进程类型，比如master,worker进程等
sig_atomic_t ngx_reap; //标记子进程状态变化[一般是子进程发来SIGCHLD信号表示退出],sig_atomic_t:系统定义的类型：访问或改变这些变量需要在计算机的一条指令内完成
//一般等价于int【通常情况下，int类型的变量通常是原子访问的，也可以认为 sig_atomic_t就是int类型的数据】
int main(int argc, char *const *argv)
{
int exitcode = 0; //退出代码，先给0表示正常退出
int i; //临时用
//(1)无伤大雅也不需要释放的放最上边
ngx_pid = getpid(); //取得进程pid
ngx_parent = getppid(); //取得父进程的id
//统计argv所占的内存
g_argvneedmem = 0;
for(i = 0; i < argc; i++) //argv = ./nginx -a -b -c asdfas
{
g_argvneedmem += strlen(argv[i]) + 1; //+1是给\0留空间。
}
//统计环境变量所占的内存。注意判断方法是environ[i]是否为空作为环境变量结束标记
for(i = 0; environ[i]; i++)
{
g_envneedmem += strlen(environ[i]) + 1; //+1是因为末尾有\0,是占实际内存位置的，要算进来
} //end for
g_os_argc = argc; //保存参数个数
g_os_argv = (char **) argv; //保存参数指针
//全局量有必要初始化的
ngx_log.fd = -1; //-1：表示日志文件尚未打开；因为后边ngx_log_stderr要用所以这里先给-1
ngx_process = NGX_PROCESS_MASTER; //先标记本进程是master进程
ngx_reap = 0; //标记子进程没有发生变化
//(2)初始化失败，就要直接退出的
//配置文件必须最先要，后边初始化啥的都用，所以先把配置读出来，供后续使用
CConfig *p_config = CConfig::GetInstance(); //单例类
if(p_config->Load("nginx.conf") == false) //把配置文件内容载入到内存
{
ngx_log_init(); //初始化日志
ngx_log_stderr(0,"配置文件[%s]载入失败，退出!","nginx.conf");
//exit(1);终止进程，在main中出现和return效果一样 ,exit(0)表示程序正常, exit(1)/exit(-1)表示程序异常退出，exit(2)表示表示系统找不到指定的文件
exitcode = 2; //标记找不到文件
goto lblexit;
}
//(3)一些必须事先准备好的资源，先初始化
ngx_log_init(); //日志初始化(创建/打开日志文件)，这个需要配置项，所以必须放配置文件载入的后边；
//(4)一些初始化函数，准备放这里
if(ngx_init_signals() != 0) //信号初始化
{
exitcode = 1;
goto lblexit;
}
//(5)一些不好归类的其他类别的代码，准备放这里
ngx_init_setproctitle(); //把环境变量搬家
//------------------------------------
//(6)创建守护进程
if(p_config->GetIntDefault("Daemon",0) == 1) //读配置文件，拿到配置文件中是否按守护进程方式启动的选项
{
//1：按守护进程方式运行
int cdaemonresult = ngx_daemon();
if(cdaemonresult == -1) //fork()失败
{
exitcode = 1; //标记失败
goto lblexit;
}
if(cdaemonresult == 1)
{
//这是原始的父进程
freeresource(); //只有进程退出了才goto到 lblexit，用于提醒用户进程退出了
//而我现在这个情况属于正常fork()守护进程后的正常退出，不应该跑到lblexit()去执行，因为那里有一条打印语句标记整个进程的退出，这里不该限制该条打印语句；
exitcode = 0;
return exitcode; //整个进程直接在这里退出
}
//走到这里，成功创建了守护进程并且这里已经是fork()出来的进程，现在这个进程做了master进程
g_daemonized = 1; //守护进程标记，标记是否启用了守护进程模式，0：未启用，1：启用了
}
//(7)开始正式的主工作流程，主流程一致在下边这个函数里循环，暂时不会走下来，资源释放啥的日后再慢慢完善和考虑
ngx_master_process_cycle(); //不管父进程还是子进程，正常工作期间都在这个函数里循环；
//--------------------------------------------------------------
//for(;;)
//{
// sleep(1); //休息1秒
// printf("休息1秒\n");
//}
//--------------------------------------
lblexit:
//(5)该释放的资源要释放掉
ngx_log_stderr(0,"程序退出，再见了!");
freeresource(); //一系列的main返回前的释放动作函数
//printf("程序退出，再见!\n");
return exitcode;
}
//专门在程序执行末尾释放资源的函数【一系列的main返回前的释放动作函数】
void freeresource()
{
//(1)对于因为设置可执行程序标题导致的环境变量分配的内存，我们应该释放
if(gp_envmem)
{
delete []gp_envmem;
gp_envmem = NULL;
}
//(2)关闭日志文件
if(ngx_log.fd != STDERR_FILENO && ngx_log.fd != -1)
{
close(ngx_log.fd); //不用判断结果了
ngx_log.fd = -1; //标记下，防止被再次close吧
}
}
ngx_log.cxx
//和日志相关的函数放之类
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h> //uintptr_t
#include <stdarg.h> //va_start....
#include <unistd.h> //STDERR_FILENO等
#include <sys/time.h> //gettimeofday
#include <time.h> //localtime_r
#include <fcntl.h> //open
#include <errno.h> //errno
#include "ngx_global.h"
#include "ngx_macro.h"
#include "ngx_func.h"
#include "ngx_c_conf.h"
//全局量---------------------
//错误等级，和ngx_macro.h里定义的日志等级宏是一一对应关系
static u_char err_levels[][20] =
{
{"stderr"}, //0：控制台错误
{"emerg"}, //1：紧急
{"alert"}, //2：警戒
{"crit"}, //3：严重
{"error"}, //4：错误
{"warn"}, //5：警告
{"notice"}, //6：注意
{"info"}, //7：信息
{"debug"} //8：调试
};
ngx_log_t ngx_log;
//----------------------------------------------------------------------------------------------------------------------
//描述：通过可变参数组合出字符串【支持...省略号形参】，自动往字符串最末尾增加换行符【所以调用者不用加\n】， 往标准错误上输出这个字符串；
// 如果err不为0，表示有错误，会将该错误编号以及对应的错误信息一并放到组合出的字符串中一起显示；
//《c++从入门到精通》里老师讲解过，比较典型的C语言中的写法，就是这种va_start,va_end
//fmt:通过这第一个普通参数来寻址后续的所有可变参数的类型及其值
//调用格式比如：ngx_log_stderr(0, "invalid option: \"%s\",%d", "testinfo",123);
/*
ngx_log_stderr(0, "invalid option: \"%s\"", argv[0]); //nginx: invalid option: "./nginx"
ngx_log_stderr(0, "invalid option: %10d", 21); //nginx: invalid option: 21 ---21前面有8个空格
ngx_log_stderr(0, "invalid option: %.6f", 21.378); //nginx: invalid option: 21.378000 ---%.这种只跟f配合有效，往末尾填充0
ngx_log_stderr(0, "invalid option: %.6f", 12.999); //nginx: invalid option: 12.999000
ngx_log_stderr(0, "invalid option: %.2f", 12.999); //nginx: invalid option: 13.00
ngx_log_stderr(0, "invalid option: %xd", 1678); //nginx: invalid option: 68E
ngx_log_stderr(0, "invalid option: %Xd", 1678); //nginx: invalid option: 68E
ngx_log_stderr(15, "invalid option: %s , %d", "testInfo",326); //nginx: invalid option: testInfo , 326
ngx_log_stderr(0, "invalid option: %d", 1678);
*/
void ngx_log_stderr(int err, const char *fmt, ...)
{
va_list args; //创建一个va_list类型变量
u_char errstr[NGX_MAX_ERROR_STR+1]; //2048 -- ************ +1是我自己填的，感谢官方写法有点小瑕疵，所以动手调整一下
u_char *p,*last;
memset(errstr,0,sizeof(errstr)); //我个人加的，这块有必要加，至少在va_end处理之前有必要，否则字符串没有结束标记不行的；***************************
last = errstr + NGX_MAX_ERROR_STR; //last指向整个buffer最后去了【指向最后一个有效位置的后面也就是非有效位】，作为一个标记，防止输出内容超过这么长,
//其实我认为这有问题，所以我才在上边errstr[NGX_MAX_ERROR_STR+1]; 给加了1
//比如你定义 char tmp[2]; 你如果last = tmp+2，那么last实际指向了tmp[2]，而tmp[2]在使用中是无效的
p = ngx_cpymem(errstr, "nginx: ", 7); //p指向"nginx: "之后
va_start(args, fmt); //使args指向起始的参数
p = ngx_vslprintf(p,last,fmt,args); //组合出这个字符串保存在errstr里
va_end(args); //释放args
if (err) //如果错误代码不是0，表示有错误发生
{
//错误代码和错误信息也要显示出来
p = ngx_log_errno(p, last, err);
}
//若位置不够，那换行也要硬插入到末尾，哪怕覆盖到其他内容
if (p >= (last - 1))
{
p = (last - 1) - 1; //把尾部空格留出来，这里感觉nginx处理的似乎就不对
//我觉得，last-1，才是最后 一个而有效的内存，而这个位置要保存\0，所以我认为再减1，这个位置，才适合保存\n
}
*p++ = '\n'; //增加个换行符
//往标准错误【一般是屏幕】输出信息
write(STDERR_FILENO,errstr,p - errstr); //三章七节讲过，这个叫标准错误，一般指屏幕
if(ngx_log.fd > STDERR_FILENO) //如果这是个有效的日志文件，本条件肯定成立，此时也才有意义将这个信息写到日志文件
{
ngx_log_error_core(NGX_LOG_STDERR,err,(const char *)errstr); //这里有个\n，ngx_log_error_core还有个\n，所以写到日志会有一个空行多出来
}
return;
}
//----------------------------------------------------------------------------------------------------------------------
//描述：给一段内存，一个错误编号，我要组合出一个字符串，形如： (错误编号: 错误原因)，放到给的这段内存中去
// 这个函数我改造的比较多，和原始的nginx代码多有不同
//buf：是个内存，要往这里保存数据
//last：放的数据不要超过这里
//err：错误编号，我们是要取得这个错误编号对应的错误字符串，保存到buffer中
u_char *ngx_log_errno(u_char *buf, u_char *last, int err)
{
//以下代码是我自己改造，感觉作者的代码有些瑕疵
char *perrorinfo = strerror(err); //根据资料不会返回NULL;
size_t len = strlen(perrorinfo);
//然后我还要插入一些字符串： (%d:)
char leftstr[10] = {0};
sprintf(leftstr," (%d: ",err);
size_t leftlen = strlen(leftstr);
char rightstr[] = ") ";
size_t rightlen = strlen(rightstr);
size_t extralen = leftlen + rightlen; //左右的额外宽度
if ((buf + len + extralen) < last)
{
//保证整个我装得下，我就装，否则我全部抛弃 ,nginx的做法是 如果位置不够，就硬留出50个位置【哪怕覆盖掉以往的有效内容】，也要硬往后边塞，这样当然也可以；
buf = ngx_cpymem(buf, leftstr, leftlen);
buf = ngx_cpymem(buf, perrorinfo, len);
buf = ngx_cpymem(buf, rightstr, rightlen);
}
return buf;
}
//----------------------------------------------------------------------------------------------------------------------
//往日志文件中写日志，代码中有自动加换行符，所以调用时字符串不用刻意加\n；
// 日过定向为标准错误，则直接往屏幕上写日志【比如日志文件打不开，则会直接定位到标准错误，此时日志就打印到屏幕上，参考ngx_log_init()】
//level:一个等级数字，我们把日志分成一些等级，以方便管理、显示、过滤等等，如果这个等级数字比配置文件中的等级数字"LogLevel"大，那么该条信息不被写到日志文件中
//err：是个错误代码，如果不是0，就应该转换成显示对应的错误信息,一起写到日志文件中，
//ngx_log_error_core(5,8,"这个XXX工作的有问题,显示的结果是=%s","YYYY");
void ngx_log_error_core(int level, int err, const char *fmt, ...)
{
u_char *last;
u_char errstr[NGX_MAX_ERROR_STR+1]; //这个+1也是我放入进来的，本函数可以参考ngx_log_stderr()函数的写法；
memset(errstr,0,sizeof(errstr));
last = errstr + NGX_MAX_ERROR_STR;
struct timeval tv;
struct tm tm;
time_t sec; //秒
u_char *p; //指向当前要拷贝数据到其中的内存位置
va_list args;
memset(&tv,0,sizeof(struct timeval));
memset(&tm,0,sizeof(struct tm));
gettimeofday(&tv, NULL); //获取当前时间，返回自1970-01-01 00:00:00到现在经历的秒数【第二个参数是时区，一般不关心】
sec = tv.tv_sec; //秒
localtime_r(&sec, &tm); //把参数1的time_t转换为本地时间，保存到参数2中去，带_r的是线程安全的版本，尽量使用
tm.tm_mon++; //月份要调整下正常
tm.tm_year += 1900; //年份要调整下才正常
u_char strcurrtime[40]={0}; //先组合出一个当前时间字符串，格式形如：2019/01/08 19:57:11
ngx_slprintf(strcurrtime,
(u_char *)-1, //若用一个u_char *接一个 (u_char *)-1,则 得到的结果是 0xffffffff....，这个值足够大
"%4d/%02d/%02d %02d:%02d:%02d", //格式是 年/月/日 时:分:秒
tm.tm_year, tm.tm_mon,
tm.tm_mday, tm.tm_hour,
tm.tm_min, tm.tm_sec);
p = ngx_cpymem(errstr,strcurrtime,strlen((const char *)strcurrtime)); //日期增加进来，得到形如： 2019/01/08 20:26:07
p = ngx_slprintf(p, last, " [%s] ", err_levels[level]); //日志级别增加进来，得到形如： 2019/01/08 20:26:07 [crit]
p = ngx_slprintf(p, last, "%P: ",ngx_pid); //支持%P格式，进程id增加进来，得到形如： 2019/01/08 20:50:15 [crit] 2037:
va_start(args, fmt); //使args指向起始的参数
p = ngx_vslprintf(p, last, fmt, args); //把fmt和args参数弄进去，组合出来这个字符串
va_end(args); //释放args
if (err) //如果错误代码不是0，表示有错误发生
{
//错误代码和错误信息也要显示出来
p = ngx_log_errno(p, last, err);
}
//若位置不够，那换行也要硬插入到末尾，哪怕覆盖到其他内容
if (p >= (last - 1))
{
p = (last - 1) - 1; //把尾部空格留出来，这里感觉nginx处理的似乎就不对
//我觉得，last-1，才是最后 一个而有效的内存，而这个位置要保存\0，所以我认为再减1，这个位置，才适合保存\n
}
*p++ = '\n'; //增加个换行符
//这么写代码是图方便：随时可以把流程弄到while后边去；大家可以借鉴一下这种写法
ssize_t n;
while(1)
{
if (level > ngx_log.log_level)
{
//要打印的这个日志的等级太落后（等级数字太大，比配置文件中的数字大)
//这种日志就不打印了
break;
}
//磁盘是否满了的判断，先算了吧，还是由管理员保证这个事情吧；
//写日志文件
n = write(ngx_log.fd,errstr,p - errstr); //文件写入成功后，如果中途
if (n == -1)
{
//写失败有问题
if(errno == ENOSPC) //写失败，且原因是磁盘没空间了
{
//磁盘没空间了
//没空间还写个毛线啊
//先do nothing吧；
}
else
{
//这是有其他错误，那么我考虑把这个错误显示到标准错误设备吧；
if(ngx_log.fd != STDERR_FILENO) //当前是定位到文件的，则条件成立
{
n = write(STDERR_FILENO,errstr,p - errstr);
}
}
}
break;
} //end while
return;
}
//----------------------------------------------------------------------------------------------------------------------
//描述：日志初始化，就是把日志文件打开 ，注意这里边涉及到释放的问题，如何解决？
void ngx_log_init()
{
u_char *plogname = NULL;
size_t nlen;
//从配置文件中读取和日志相关的配置信息
CConfig *p_config = CConfig::GetInstance();
plogname = (u_char *)p_config->GetString("Log");
if(plogname == NULL)
{
//没读到，就要给个缺省的路径文件名了
plogname = (u_char *) NGX_ERROR_LOG_PATH; //"logs/error.log" ,logs目录需要提前建立出来
}
ngx_log.log_level = p_config->GetIntDefault("LogLevel",NGX_LOG_NOTICE);//缺省日志等级为6【注意】 ，如果读失败，就给缺省日志等级
//nlen = strlen((const char *)plogname);
//只写打开|追加到末尾|文件不存在则创建【这个需要跟第三参数指定文件访问权限】
//mode = 0644：文件访问权限， 6: 110 , 4: 100： 【用户：读写， 用户所在组：读，其他：读】 老师在第三章第一节介绍过
//ngx_log.fd = open((const char *)plogname,O_WRONLY|O_APPEND|O_CREAT|O_DIRECT,0644); //绕过内和缓冲区，write()成功则写磁盘必然成功，但效率可能会比较低；
ngx_log.fd = open((const char *)plogname,O_WRONLY|O_APPEND|O_CREAT,0644);
if (ngx_log.fd == -1) //如果有错误，则直接定位到 标准错误上去
{
ngx_log_stderr(errno,"[alert] could not open error log file: open() \"%s\" failed", plogname);
ngx_log.fd = STDERR_FILENO; //直接定位到标准错误去了
}
return;
}
ngx_process_cycle.cxx
//和开启子进程相关
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h> //信号相关头文件
#include <errno.h> //errno
#include <unistd.h>
#include "ngx_func.h"
#include "ngx_macro.h"
#include "ngx_c_conf.h"
//函数声明
static void ngx_start_worker_processes(int threadnums);
static int ngx_spawn_process(int threadnums,const char *pprocname);
static void ngx_worker_process_cycle(int inum,const char *pprocname);
static void ngx_worker_process_init(int inum);
//变量声明
static u_char master_process[] = "master process";
//描述：创建worker子进程
void ngx_master_process_cycle()
{
sigset_t set; //信号集
sigemptyset(&set); //清空信号集
//下列这些信号在执行本函数期间不希望收到【考虑到官方nginx中有这些信号，老师就都搬过来了】（保护不希望由信号中断的代码临界区）
//建议fork()子进程时学习这种写法，防止信号的干扰；
sigaddset(&set, SIGCHLD); //子进程状态改变
sigaddset(&set, SIGALRM); //定时器超时
sigaddset(&set, SIGIO); //异步I/O
sigaddset(&set, SIGINT); //终端中断符
sigaddset(&set, SIGHUP); //连接断开
sigaddset(&set, SIGUSR1); //用户定义信号
sigaddset(&set, SIGUSR2); //用户定义信号
sigaddset(&set, SIGWINCH); //终端窗口大小改变
sigaddset(&set, SIGTERM); //终止
sigaddset(&set, SIGQUIT); //终端退出符
//.........可以根据开发的实际需要往其中添加其他要屏蔽的信号......
//设置，此时无法接受的信号；阻塞期间，你发过来的上述信号，多个会被合并为一个，暂存着，等你放开信号屏蔽后才能收到这些信号。。。
//sigprocmask()在第三章第五节详细讲解过
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) //第一个参数用了SIG_BLOCK表明设置 进程 新的信号屏蔽字 为 “当前信号屏蔽字 和 第二个参数指向的信号集的并集
{
ngx_log_error_core(NGX_LOG_ALERT,errno,"ngx_master_process_cycle()中sigprocmask()失败!");
}
//即便sigprocmask失败，程序流程 也继续往下走
//首先我设置主进程标题---------begin
size_t size;
int i;
size = sizeof(master_process); //注意我这里用的是sizeof，所以字符串末尾的\0是被计算进来了的
size += g_argvneedmem; //argv参数长度加进来
if(size < 1000) //长度小于这个，我才设置标题
{
char title[1000] = {0};
strcpy(title,(const char *)master_process); //"master process"
strcat(title," "); //跟一个空格分开一些，清晰 //"master process "
for (i = 0; i < g_os_argc; i++) //"master process ./nginx"
{
strcat(title,g_os_argv[i]);
}//end for
ngx_setproctitle(title); //设置标题
ngx_log_error_core(NGX_LOG_NOTICE,0,"%s %P 启动并开始运行......!",title,ngx_pid); //设置标题时顺便记录下来进程名，进程id等信息到日志
}
//首先我设置主进程标题---------end
//从配置文件中读取要创建的worker进程数量
CConfig *p_config = CConfig::GetInstance(); //单例类
int workprocess = p_config->GetIntDefault("WorkerProcesses",1); //从配置文件中得到要创建的worker进程数量
ngx_start_worker_processes(workprocess); //这里要创建worker子进程
//创建子进程后，父进程的执行流程会返回到这里，子进程不会走进来
sigemptyset(&set); //信号屏蔽字为空，表示不屏蔽任何信号
for ( ;; )
{
// usleep(100000);
//ngx_log_error_core(0,0,"haha--这是父进程，pid为%P",ngx_pid);
//a)根据给定的参数设置新的mask 并 阻塞当前进程【因为是个空集，所以不阻塞任何信号】
//b)此时，一旦收到信号，便恢复原先的信号屏蔽【我们原来的mask在上边设置的，阻塞了多达10个信号，从而保证我下边的执行流程不会再次被其他信号截断】
//c)调用该信号对应的信号处理函数
//d)信号处理函数返回后，sigsuspend返回，使程序流程继续往下走
//printf("for进来了！\n"); //发现，如果print不加\n，无法及时显示到屏幕上，是行缓存问题，以往没注意；可参考https://blog.csdn.net/qq_26093511/article/details/53255970
sigsuspend(&set); //阻塞在这里，等待一个信号，此时进程是挂起的，不占用cpu时间，只有收到信号才会被唤醒（返回）；
//此时master进程完全靠信号驱动干活
// printf("执行到sigsuspend()下边来了\n");
//printf("master进程休息1秒\n");
//ngx_log_stderr(0,"haha--这是父进程，pid为%P",ngx_pid);
sleep(1); //休息1秒
//以后扩充.......
}// end for(;;)
return;
}
//描述：根据给定的参数创建指定数量的子进程，因为以后可能要扩展功能，增加参数，所以单独写成一个函数
//threadnums:要创建的子进程数量
static void ngx_start_worker_processes(int threadnums)
{
int i;
for (i = 0; i < threadnums; i++) //master进程在走这个循环，来创建若干个子进程
{
ngx_spawn_process(i,"worker process");
} //end for
return;
}
//描述：产生一个子进程
//inum：进程编号【0开始】
//pprocname：子进程名字"worker process"
static int ngx_spawn_process(int inum,const char *pprocname)
{
pid_t pid;
pid = fork(); //fork()系统调用产生子进程
switch (pid) //pid判断父子进程，分支处理
{
case -1: //产生子进程失败
ngx_log_error_core(NGX_LOG_ALERT,errno,"ngx_spawn_process()fork()产生子进程num=%d,procname=\"%s\"失败!",inum,pprocname);
return -1;
case 0: //子进程分支
ngx_parent = ngx_pid; //因为是子进程了，所有原来的pid变成了父pid
ngx_pid = getpid(); //重新获取pid,即本子进程的pid
ngx_worker_process_cycle(inum,pprocname); //我希望所有worker子进程，在这个函数里不断循环着不出来，也就是说，子进程流程不往下边走;
break;
default: //这个应该是父进程分支，直接break;，流程往switch之后走
break;
}//end switch
//父进程分支会走到这里，子进程流程不往下边走-------------------------
//若有需要，以后再扩展增加其他代码......
return pid;
}
//描述：worker子进程的功能函数，每个woker子进程，就在这里循环着了（无限循环【处理网络事件和定时器事件以对外提供web服务】）
// 子进程分叉才会走到之类
//inum：进程编号【0开始】
static void ngx_worker_process_cycle(int inum,const char *pprocname)
{
//设置一下变量
ngx_process = NGX_PROCESS_WORKER; //设置进程的类型，是worker进程
//重新为子进程设置进程名，不要与父进程重复------
ngx_worker_process_init(inum);
ngx_setproctitle(pprocname); //设置标题
ngx_log_error_core(NGX_LOG_NOTICE,0,"%s %P 启动并开始运行......!",pprocname,ngx_pid); //设置标题时顺便记录下来进程名，进程id等信息到日志
//暂时先放个死循环，我们在这个循环里一直不出来
//setvbuf(stdout,NULL,_IONBF,0); //这个函数. 直接将printf缓冲区禁止， printf就直接输出了。
for(;;)
{
//先sleep一下 以后扩充.......
//printf("worker进程休息1秒");
//fflush(stdout); //刷新标准输出缓冲区，把输出缓冲区里的东西打印到标准输出设备上，则printf里的东西会立即输出；
sleep(1); //休息1秒
//usleep(100000);
//ngx_log_error_core(0,0,"good--这是子进程，编号为%d,pid为%P！",inum,ngx_pid);
//printf("1212");
//if(inum == 1)
//{
//ngx_log_stderr(0,"good--这是子进程，编号为%d,pid为%P",inum,ngx_pid);
//printf("good--这是子进程，编号为%d,pid为%d\r\n",inum,ngx_pid);
//ngx_log_error_core(0,0,"good--这是子进程，编号为%d",inum,ngx_pid);
//printf("我的测试哈inum=%d",inum++);
//fflush(stdout);
//}
//ngx_log_stderr(0,"good--这是子进程，编号为%d,pid为%P",inum,ngx_pid);
//ngx_log_error_core(0,0,"good--这是子进程，编号为%d,pid为%P",inum,ngx_pid);
} //end for(;;)
return;
}
//描述：子进程创建时调用本函数进行一些初始化工作
static void ngx_worker_process_init(int inum)
{
sigset_t set; //信号集
sigemptyset(&set); //清空信号集
if (sigprocmask(SIG_SETMASK, &set, NULL) == -1) //原来是屏蔽那10个信号【防止fork()期间收到信号导致混乱】，现在不再屏蔽任何信号【接收任何信号】
{
ngx_log_error_core(NGX_LOG_ALERT,errno,"ngx_worker_process_init()中sigprocmask()失败!");
}
//....将来再扩充代码
//....
return;
}
ngx_signal.cxx
//和信号有关的函数放这里
#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h> //信号相关头文件
#include <errno.h> //errno
#include <sys/wait.h> //waitpid
#include "ngx_global.h"
#include "ngx_macro.h"
#include "ngx_func.h"
//一个信号有关的结构 ngx_signal_t
typedef struct
{
int signo; //信号对应的数字编号 ，每个信号都有对应的#define ，大家已经学过了
const char *signame; //信号对应的中文名字 ，比如SIGHUP
//信号处理函数,这个函数由我们自己来提供，但是它的参数和返回值是固定的【操作系统就这样要求】,大家写的时候就先这么写，也不用思考这么多；
void (*handler)(int signo, siginfo_t *siginfo, void *ucontext); //函数指针, siginfo_t:系统定义的结构
} ngx_signal_t;
//声明一个信号处理函数
static void ngx_signal_handler(int signo, siginfo_t *siginfo, void *ucontext); //static表示该函数只在当前文件内可见
static void ngx_process_get_status(void); //获取子进程的结束状态，防止单独kill子进程时子进程变成僵尸进程
//数组 ，定义本系统处理的各种信号，我们取一小部分nginx中的信号，并没有全部搬移到这里，日后若有需要根据具体情况再增加
//在实际商业代码中，你能想到的要处理的信号，都弄进来
ngx_signal_t signals[] = {
// signo signame handler
{ SIGHUP, "SIGHUP", ngx_signal_handler }, //终端断开信号，对于守护进程常用于reload重载配置文件通知--标识1
{ SIGINT, "SIGINT", ngx_signal_handler }, //标识2
{ SIGTERM, "SIGTERM", ngx_signal_handler }, //标识15
{ SIGCHLD, "SIGCHLD", ngx_signal_handler }, //子进程退出时，父进程会收到这个信号--标识17
{ SIGQUIT, "SIGQUIT", ngx_signal_handler }, //标识3
{ SIGIO, "SIGIO", ngx_signal_handler }, //指示一个异步I/O事件【通用异步I/O信号】
{ SIGSYS, "SIGSYS, SIG_IGN", NULL }, //我们想忽略这个信号，SIGSYS表示收到了一个无效系统调用，如果我们不忽略，进程会被操作系统杀死，--标识31
//所以我们把handler设置为NULL，代表 我要求忽略这个信号，请求操作系统不要执行缺省的该信号处理动作（杀掉我）
//...日后根据需要再继续增加
{ 0, NULL, NULL } //信号对应的数字至少是1，所以可以用0作为一个特殊标记
};
//初始化信号的函数，用于注册信号处理程序
//返回值：0成功 ，-1失败
int ngx_init_signals()
{
ngx_signal_t *sig; //指向自定义结构数组的指针
struct sigaction sa; //sigaction：系统定义的跟信号有关的一个结构，我们后续调用系统的sigaction()函数时要用到这个同名的结构
for (sig = signals; sig->signo != 0; sig++) //将signo ==0作为一个标记，因为信号的编号都不为0；
{
//我们注意，现在要把一堆信息往 变量sa对应的结构里弄 ......
memset(&sa,0,sizeof(struct sigaction));
if (sig->handler) //如果信号处理函数不为空，这当然表示我要定义自己的信号处理函数
{
sa.sa_sigaction = sig->handler; //sa_sigaction：指定信号处理程序(函数)，注意sa_sigaction也是函数指针，是这个系统定义的结构sigaction中的一个成员（函数指针成员）；
sa.sa_flags = SA_SIGINFO; //sa_flags：int型，指定信号的一些选项，设置了该标记(SA_SIGINFO)，就表示信号附带的参数可以被传递到信号处理函数中
//说白了就是你要想让sa.sa_sigaction指定的信号处理程序(函数)生效，你就把sa_flags设定为SA_SIGINFO
}
else
{
sa.sa_handler = SIG_IGN; //sa_handler:这个标记SIG_IGN给到sa_handler成员，表示忽略信号的处理程序，否则操作系统的缺省信号处理程序很可能把这个进程杀掉；
//其实sa_handler和sa_sigaction都是一个函数指针用来表示信号处理程序。只不过这两个函数指针他们参数不一样， sa_sigaction带的参数多，信息量大，
//而sa_handler带的参数少，信息量少；如果你想用sa_sigaction，那么你就需要把sa_flags设置为SA_SIGINFO；
} //end if
sigemptyset(&sa.sa_mask); //比如咱们处理某个信号比如SIGUSR1信号时不希望收到SIGUSR2信号，那咱们就可以用诸如sigaddset(&sa.sa_mask,SIGUSR2);这样的语句针对信号为SIGUSR1时做处理，这个sigaddset三章五节讲过；
//这里.sa_mask是个信号集（描述信号的集合），用于表示要阻塞的信号，sigemptyset()这个函数咱们在第三章第五节讲过：把信号集中的所有信号清0，本意就是不准备阻塞任何信号；
//设置信号处理动作(信号处理函数)，说白了这里就是让这个信号来了后调用我的处理程序，有个老的同类函数叫signal，不过signal这个函数被认为是不可靠信号语义，不建议使用，大家统一用sigaction
if (sigaction(sig->signo, &sa, NULL) == -1) //参数1：要操作的信号
//参数2：主要就是那个信号处理函数以及执行信号处理函数时候要屏蔽的信号等等内容
//参数3：返回以往的对信号的处理方式【跟sigprocmask()函数边的第三个参数是的】，跟参数2同一个类型，我们这里不需要这个东西，所以直接设置为NULL；
{
ngx_log_error_core(NGX_LOG_EMERG,errno,"sigaction(%s) failed",sig->signame); //显示到日志文件中去的
return -1; //有失败就直接返回
}
else
{
//ngx_log_error_core(NGX_LOG_EMERG,errno,"sigaction(%s) succed!",sig->signame); //成功不用写日志
//ngx_log_stderr(0,"sigaction(%s) succed!",sig->signame); //直接往屏幕上打印看看 ，不需要时可以去掉
}
} //end for
return 0; //成功
}
//信号处理函数
//siginfo：这个系统定义的结构中包含了信号产生原因的有关信息
static void ngx_signal_handler(int signo, siginfo_t *siginfo, void *ucontext)
{
//printf("来信号了\n");
ngx_signal_t *sig; //自定义结构
char *action; //一个字符串，用于记录一个动作字符串以往日志文件中写
for (sig = signals; sig->signo != 0; sig++) //遍历信号数组
{
//找到对应信号，即可处理
if (sig->signo == signo)
{
break;
}
} //end for
action = (char *)""; //目前还没有什么动作；
if(ngx_process == NGX_PROCESS_MASTER) //master进程，管理进程，处理的信号一般会比较多
{
//master进程的往这里走
switch (signo)
{
case SIGCHLD: //一般子进程退出会收到该信号
ngx_reap = 1; //标记子进程状态变化，日后master主进程的for(;;)循环中可能会用到这个变量【比如重新产生一个子进程】
break;
//.....其他信号处理以后待增加
default:
break;
} //end switch
}
else if(ngx_process == NGX_PROCESS_WORKER) //worker进程，具体干活的进程，处理的信号相对比较少
{
//worker进程的往这里走
//......以后再增加
//....
}
else
{
//非master非worker进程，先啥也不干
//do nothing
} //end if(ngx_process == NGX_PROCESS_MASTER)
//这里记录一些日志信息
//siginfo这个
if(siginfo && siginfo->si_pid) //si_pid = sending process ID【发送该信号的进程id】
{
ngx_log_error_core(NGX_LOG_NOTICE,0,"signal %d (%s) received from %P%s", signo, sig->signame, siginfo->si_pid, action);
}
else
{
ngx_log_error_core(NGX_LOG_NOTICE,0,"signal %d (%s) received %s",signo, sig->signame, action);//没有发送该信号的进程id，所以不显示发送该信号的进程id
}
//.......其他需要扩展的将来再处理；
//子进程状态有变化，通常是意外退出【既然官方是在这里处理，我们也学习官方在这里处理】
if (signo == SIGCHLD)
{
ngx_process_get_status(); //获取子进程的结束状态
} //end if
return;
}
//获取子进程的结束状态，防止单独kill子进程时子进程变成僵尸进程
static void ngx_process_get_status(void)
{
pid_t pid;
int status;
int err;
int one=0; //抄自官方nginx，应该是标记信号正常处理过一次
//当你杀死一个子进程时，父进程会收到这个SIGCHLD信号。
for ( ;; )
{
//waitpid，有人也用wait,但老师要求大家掌握和使用waitpid即可；这个waitpid说白了获取子进程的终止状态，这样，子进程就不会成为僵尸进程了；
//第一次waitpid返回一个> 0值，表示成功，后边显示 2019/01/14 21:43:38 [alert] 3375: pid = 3377 exited on signal 9【SIGKILL】
//第二次再循环回来，再次调用waitpid会返回一个0，表示子进程还没结束，然后这里有return来退出；
pid = waitpid(-1, &status, WNOHANG); //第一个参数为-1，表示等待任何子进程，
//第二个参数：保存子进程的状态信息(大家如果想详细了解，可以百度一下)。
//第三个参数：提供额外选项，WNOHANG表示不要阻塞，让这个waitpid()立即返回
if(pid == 0) //子进程没结束，会立即返回这个数字，但这里应该不是这个数字【因为一般是子进程退出时会执行到这个函数】
{
return;
} //end if(pid == 0)
//-------------------------------
if(pid == -1)//这表示这个waitpid调用有错误，有错误也理解返回出去，我们管不了这么多
{
//这里处理代码抄自官方nginx，主要目的是打印一些日志。考虑到这些代码也许比较成熟，所以，就基本保持原样照抄吧；
err = errno;
if(err == EINTR) //调用被某个信号中断
{
continue;
}
if(err == ECHILD && one) //没有子进程
{
return;
}
if (err == ECHILD) //没有子进程
{
ngx_log_error_core(NGX_LOG_INFO,err,"waitpid() failed!");
return;
}
ngx_log_error_core(NGX_LOG_ALERT,err,"waitpid() failed!");
return;
} //end if(pid == -1)
//-------------------------------
//走到这里，表示 成功【返回进程id】 ，这里根据官方写法，打印一些日志来记录子进程的退出
one = 1; //标记waitpid()返回了正常的返回值
if(WTERMSIG(status)) //获取使子进程终止的信号编号
{
ngx_log_error_core(NGX_LOG_ALERT,0,"pid = %P exited on signal %d!",pid,WTERMSIG(status)); //获取使子进程终止的信号编号
}
else
{
ngx_log_error_core(NGX_LOG_NOTICE,0,"pid = %P exited with code %d!",pid,WEXITSTATUS(status)); //WEXITSTATUS()获取子进程传递给exit或者_exit参数的低八位
}
} //end for
return;
}
