seo的网站建设苏州网站建设苏州

seo的网站建设,苏州网站建设苏州,品牌设计流程,网站开发工程师的职位主要探讨四个主题#xff1a;信号处理、守护进程、进程组和会话。这些都是Linux/Unix进程管理中的重要概念。下面将分别深入探讨它们的工作原理和机制。 一、信号处理#xff08;Signal#xff09; 1.1 信号的基本概念 信号是Linux系统中用于进程间通信的一种机制#xff0…主要探讨四个主题信号处理、守护进程、进程组和会话。这些都是Linux/Unix进程管理中的重要概念。下面将分别深入探讨它们的工作原理和机制。一、信号处理Signal1.1 信号的基本概念信号是Linux系统中用于进程间通信的一种机制它是一种异步的通知用来通知进程发生了某个事件。信号可以由内核、其他进程或进程自身发送。常见信号列表信号编号 信号名 默认动作 说明1 SIGHUP 终止 终端挂起或控制进程终止2 SIGINT 终止 来自键盘的中断CtrlC3 SIGQUIT 终止核心转储 来自键盘的退出Ctrl\9 SIGKILL 终止 强制终止信号不可捕获或忽略10 SIGUSR1 终止 用户自定义信号112 SIGUSR2 终止 用户自定义信号214 SIGALRM 终止 由alarm函数设置的定时器超时15 SIGTERM 终止 终止信号可被捕获17 SIGCHLD 忽略 子进程状态改变20 SIGTSTP 停止 来自键盘的停止CtrlZ1.2 信号的处理机制当信号发生时内核会在进程的进程表项中设置一个标志位这个过程称为“递送”。信号产生和递送之间的时间间隔内信号是“未决”的。进程可以选择以下三种方式处理信号忽略信号除了SIGKILL和SIGSTOP其他信号都可以被忽略。捕捉信号为信号指定一个处理函数当信号发生时执行该处理函数。执行默认动作大多数信号的默认动作是终止进程。1.3 信号处理函数使用sigaction函数可以设置信号处理方式。示例c#include stdio.h#include signal.h#include unistd.hvoid signal_handler(int signo) {if (signo SIGINT) {printf(“Received SIGINT\n”);} else if (signo SIGTERM) {printf(“Received SIGTERM\n”);}}int main() {struct sigaction sa;sa.sa_handler signal_handler; sigemptyset(sa.sa_mask); sa.sa_flags 0; // 注册信号处理函数 if (sigaction(SIGINT, sa, NULL) -1) { perror(sigaction); return 1; } if (sigaction(SIGTERM, sa, NULL) -1) { perror(sigaction); return 1; } // 无限循环等待信号 while (1) { pause(); } return 0;}1.4 信号的阻塞与未决进程可以阻塞信号被阻塞的信号将保持在未决状态直到进程解除阻塞。使用sigprocmask可以设置进程的信号屏蔽字。c#include signal.hint main() {sigset_t newset, oldset;// 初始化信号集 sigemptyset(newset); sigaddset(newset, SIGINT); // 阻塞SIGINT // 设置信号屏蔽字 sigprocmask(SIG_BLOCK, newset, oldset); // 在这段代码中SIGINT被阻塞 // 即使按下CtrlC也不会中断 // 恢复原来的信号屏蔽字 sigprocmask(SIG_SETMASK, oldset, NULL); return 0;}二、守护进程Daemon2.1 守护进程的特点守护进程是运行在后台的一种特殊进程它独立于控制终端通常周期性地执行某种任务或等待处理某些事件。守护进程通常在系统启动时开始运行直到系统关闭。守护进程的特点在后台运行脱离控制终端避免被终端信号打断独立于用户会话通常以root权限运行通常用来提供服务2.2 编写守护进程的步骤创建子进程父进程退出使子进程成为孤儿进程被init进程收养。在子进程中创建新会话调用setsid使子进程成为会话组长脱离终端。改变当前工作目录通常改为根目录避免占用可卸载的文件系统。重设文件权限掩码umask(0)确保守护进程创建文件时有足够的权限。关闭不需要的文件描述符释放从父进程继承的打开文件。处理信号通常忽略某些信号如SIGHUP。2.3 守护进程示例c#include stdio.h#include stdlib.h#include unistd.h#include signal.h#include sys/types.h#include sys/stat.h#include fcntl.hvoid daemonize() {pid_t pid;// 1. 创建子进程父进程退出 pid fork(); if (pid 0) { perror(fork); exit(1); } else if (pid 0) { exit(0); // 父进程退出 } // 2. 在子进程中创建新会话 if (setsid() 0) { perror(setsid); exit(1); } // 3. 改变当前工作目录为根目录 if (chdir(/) 0) { perror(chdir); exit(1); } // 4. 重设文件权限掩码 umask(0); // 5. 关闭标准输入、输出、错误输出 close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); // 6. 处理信号 signal(SIGCHLD, SIG_IGN); signal(SIGHUP, SIG_IGN);}int main() {daemonize();// 守护进程的具体工作 while (1) { // 在这里执行守护进程的任务 // 例如每隔一段时间执行某个操作 sleep(10); } return 0;}三、进程组和会话3.1 进程组Process Group进程组是一个或多个进程的集合每个进程组有一个唯一的进程组ID。进程组中的进程通常与同一个作业job相关联可以接收相同的信号。每个进程属于一个进程组。进程组ID等于组长的进程ID。组长进程可以创建新的进程组并将其他进程加入该组。3.2 会话Session会话是一个或多个进程组的集合通常由一次登录形成一个会话。每个会话有一个唯一的会话ID并且有一个会话首进程session leader即创建会话的进程。每个会话可以有一个控制终端controlling terminal。与控制终端建立连接的会话首进程称为控制进程controlling process。一个会话中的进程组可以分为一个前台进程组和多个后台进程组。3.3 相关函数setsid()创建一个新会话并成为会话首进程和进程组长同时脱离控制终端。setpgid(pid_t pid, pid_t pgid)将指定进程加入指定进程组或创建新的进程组。getpgrp()返回当前进程的进程组ID。getsid(pid_t pid)返回指定进程的会话ID。3.4 示例创建新会话和进程组c#include stdio.h#include unistd.h#include sys/types.hint main() {pid_t pid;// 创建子进程 pid fork(); if (pid 0) { perror(fork); return 1; } else if (pid 0) { // 子进程中创建新会话 if (setsid() 0) { perror(setsid); return 1; } printf(Child: PID%d, PGID%d, SID%d\n, getpid(), getpgrp(), getsid(0)); // 子进程的工作 sleep(10); } else { // 父进程 printf(Parent: PID%d, PGID%d, SID%d\n, getpid(), getpgrp(), getsid(0)); sleep(5); } return 0;}四、深入探讨工作原理和机制4.1 信号处理的底层机制当信号被发送给进程时内核会在进程的进程控制块PCB中设置一个标志位。当进程从内核态返回到用户态时内核会检查进程的未决信号并调用相应的信号处理函数。信号处理函数在用户态执行但内核为其设置了特殊的栈帧使得信号处理函数返回后进程可以继续原来的执行。4.2 守护进程与系统服务现代Linux系统使用systemd来管理守护进程。systemd提供了更强大的服务管理功能包括依赖关系、并行启动、按需启动等。编写systemd服务需要创建一个.service文件放在/etc/systemd/system/目录下。4.3 进程组和会话与终端的关系终端驱动程序会将输入和信号发送给前台进程组。当用户按下CtrlC时终端驱动程序会向前台进程组发送SIGINT信号。同样CtrlZ发送SIGTSTP信号。这使得用户可以通过终端控制作业的执行。4.4 实际应用实现一个简单的shell一个简单的shell需要管理作业jobs包括前台作业和后台作业。这需要使用进程组和会话。当shell运行一个前台作业时它会将作业放入一个新的进程组并设置为前台进程组。当作业结束时shell会重新获得控制权。下面对进程信号处理、守护进程、进程组与会话深度解析一、信号处理Signal深度解析1.1 信号的本质与分类1.1.1 信号的完整生命周期信号生命周期从产生到处理 ┌─────────────────────────────────────────┐ │ 信号产生Generation │ │ 1. 硬件异常除零、内存访问错误 │ │ 2. 软件事件定时器到期、子进程终止 │ │ 3. 终端事件CtrlC, CtrlZ │ │ 4. 其他进程发送kill, sigqueue │ └───────────────────┬─────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ 信号递送Delivery │ │ 内核检查目标进程的信号屏蔽字 │ │ 如果信号被阻塞标记为未决Pending │ │ 如果未被阻塞立即递送 │ └───────────────────┬─────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ 信号处理Handling │ │ 1. 忽略Ignore │ │ 2. 捕获Catch执行用户处理函数 │ │ 3. 默认Default执行系统默认动作 │ └─────────────────────────────────────────┘ 关键状态 - 产生Generated信号已发生但未处理 - 未决Pending信号已产生但被阻塞 - 递送Delivered信号已发送给进程 - 捕获Caught信号被用户处理函数处理1.1.2 Linux信号分类表// 标准信号1-31和实时信号34-64#define_NSIG65// 信号总数// 信号宏定义部分#defineSIGHUP1// 终端挂起或控制进程终止#defineSIGINT2// 键盘中断CtrlC#defineSIGQUIT3// 键盘退出Ctrl\#defineSIGILL4// 非法指令#defineSIGTRAP5// 跟踪/断点陷阱#defineSIGABRT6// 异常终止#defineSIGBUS7// 总线错误#defineSIGFPE8// 浮点异常#defineSIGKILL9// 强制终止不可捕获#defineSIGUSR110// 用户自定义信号1#defineSIGSEGV11// 段错误#defineSIGUSR212// 用户自定义信号2#defineSIGPIPE13// 管道破裂#defineSIGALRM14// 定时器超时#defineSIGTERM15// 终止信号#defineSIGCHLD17// 子进程状态改变#defineSIGCONT18// 继续执行如果停止#defineSIGSTOP19// 停止进程不可捕获#defineSIGTSTP20// 终端停止信号CtrlZ#defineSIGTTIN21// 后台进程尝试读终端#defineSIGTTOU22// 后台进程尝试写终端#defineSIGURG23// 紧急数据到达socket#defineSIGXCPU24// CPU时间超限#defineSIGXFSZ25// 文件大小超限#defineSIGVTALRM26// 虚拟定时器超时#defineSIGPROF27// 性能分析定时器超时#defineSIGWINCH28// 窗口大小改变#defineSIGIO29// I/O就绪#defineSIGPWR30// 电源故障#defineSIGSYS31// 非法系统调用// 实时信号34-64#defineSIGRTMIN34#defineSIGRTMAX64// 信号标志#defineSA_NOCLDSTOP0x00000001// SIGCHLD不报告停止#defineSA_NOCLDWAIT0x00000002// 不创建僵尸进程#defineSA_SIGINFO0x00000004// 使用sa_sigaction而不是sa_handler#defineSA_ONSTACK0x08000000// 使用备用信号栈#defineSA_RESTART0x10000000// 系统调用自动重启#defineSA_NODEFER0x40000000// 不阻塞当前信号#defineSA_RESETHAND0x80000000// 处理一次后恢复默认1.2 信号处理的内核机制1.2.1 内核中的信号数据结构// Linux内核信号相关数据结构// task_struct中的信号相关字段structtask_struct{// ... 其他字段/* Signal handlers: */structsignal_struct*signal;structsighand_struct*sighand;sigset_tblocked;// 阻塞的信号集sigset_treal_blocked;structsigpendingpending;// 未决信号队列// ... 其他字段};// 信号描述符每个进程共享structsignal_struct{atomic_tcount;// 引用计数structsigpendingshared_pending;// 共享未决信号// 资源限制unsignedlongrlim[RLIM_NLIMITS];// 进程组和会话structpid*leader_pid;structtty_struct*tty;// 统计信息unsignedlonglongcutime,cstime;// 子进程用户/系统时间unsignedlonglongutime,stime;// 本进程用户/系统时间// 信号处理intgroup_exit_code;intgroup_stop_count;unsignedintflags;};// 信号处理描述符structsighand_struct{atomic_tcount;// 引用计数structk_sigactionaction[_NSIG];// 信号处理数组spinlock_tsiglock;// 保护信号处理wait_queue_head_tsignalfd_wqh;};// 未决信号队列structsigpending{structlist_headlist;// 未决信号链表sigset_tsignal;// 信号位图};// 内核信号动作structk_sigaction{structsigactionsa;#ifdef__ARCH_HAS_KA_RESTORER__sigrestore_t ka_restorer;#endif};// 用户空间sigaction结构structsigaction{union{__sighandler_t sa_handler;// 简单处理函数void(*sa_sigaction)(int,siginfo_t*,void*);// 扩展处理函数}__sigaction_handler;unsignedlongsa_flags;__sigrestore_t sa_restorer;sigset_tsa_mask;// 执行处理函数时阻塞的信号};1.2.2 信号递送的核心流程// 内核信号递送核心代码简化版voidsignal_deliver(structtask_struct*tsk,structk_sigaction*ka,intsig,siginfo_t*info,sigset_t*oldset){structpt_regs*regstask_pt_regs(tsk);// 1. 设置用户栈帧if(ka-sa.sa_flagsSA_SIGINFO){// 使用siginfo版本if(setup_rt_frame(sig,ka,info,oldset,regs)0)return;}else{// 简单版本if(setup_frame(sig,ka,oldset,regs)0)return;}// 2. 设置信号处理函数地址regs-ARM_ip(unsignedlong)ka-sa.sa_handler;// 3. 设置返回地址从信号处理返回后执行的地址regs-ARM_lr(unsignedlong)ka-sa.sa_restorer;// 4. 设置程序计数器指向信号处理函数regs-ARM_pcregs-ARM_ip;// 5. 清除阻塞标志除非指定SA_NODEFERif(!(ka-sa.sa_flagsSA_NODEFER)){sigdelset(tsk-blocked,sig);}// 6. 如果指定SA_ONESHOT恢复默认处理if(ka-sa.sa_flagsSA_RESETHAND){ka-sa.sa_handlerSIG_DFL;}}// 设置信号栈帧x86-64架构示例intsetup_rt_frame(intsig,structk_sigaction*ka,siginfo_t*info,sigset_t*set,structpt_regs*regs){structrt_sigframe__user*frame;void__user*restorer;interr0;// 在用户栈上分配帧空间frameget_sigframe(ka,regs,sizeof(*frame));if(!access_ok(frame,sizeof(*frame)))return-EFAULT;// 设置ucontexterr|__put_user(0,frame-uc.uc_flags);err|__put_user(NULL,frame-uc.uc_link);err|save_altstack(frame-uc.uc_stack,regs-sp);// 保存寄存器状态err|setup_sigcontext(frame-uc.uc_mcontext,regs,set-sig[0]);// 保存siginfoerr|copy_siginfo_to_user(frame-info,info);// 设置返回地址restorerka-sa.sa_restorer;if(!restorer)restorerVDSO_SYMBOL(current-mm-context.vdso,rt_sigreturn);err|__put_user(restorer,frame-pretcode);// 设置用户栈指针和指令指针regs-sp(unsignedlong)frame;regs-ip(unsignedlong)ka-sa.sa_handler;regs-axsig;// 信号编号作为第一个参数regs-si(unsignedlong)frame-info;// siginfo作为第二个参数regs-dx(unsignedlong)frame-uc;// ucontext作为第三个参数returnerr;}1.3 高级信号处理技术1.3.1 信号掩码与阻塞// 信号掩码操作完整示例#includesignal.h#includestdio.h#includeunistd.h#includestring.hvoidprint_signal_mask(constchar*msg){sigset_tcurr_mask;// 获取当前信号掩码if(sigprocmask(SIG_BLOCK,NULL,curr_mask)-1){perror(sigprocmask);return;}printf(%s: ,msg);for(inti1;iNSIG;i){if(sigismember(curr_mask,i)){printf(%d ,i);}}printf(\n);}intmain(){sigset_tnew_mask,old_mask,pending_mask;printf(PID: %d\n,getpid());// 初始化信号集sigemptyset(new_mask);sigaddset(new_mask,SIGINT);sigaddset(new_mask,SIGQUIT);sigaddset(new_mask,SIGUSR1);// 阻塞SIGINT, SIGQUIT, SIGUSR1if(sigprocmask(SIG_BLOCK,new_mask,old_mask)-1){perror(sigprocmask);return1;}print_signal_mask(Blocked signals);// 睡眠期间发送的信号将被阻塞printf(Sleeping for 10 seconds...\n);printf(Try sending signals: kill -INT %d\n,getpid());printf( kill -QUIT %d\n,getpid());printf( kill -USR1 %d\n,getpid());sleep(10);// 检查未决信号sigpending(pending_mask);printf(Pending signals: );for(inti1;iNSIG;i){if(sigismember(pending_mask,i)){printf(%d ,i);}}printf(\n);// 恢复原来的信号掩码if(sigprocmask(SIG_SETMASK,old_mask,NULL)-1){perror(sigprocmask);return1;}print_signal_mask(Restored signal mask);// 现在信号将被递送printf(Signals will be delivered now...\n);sleep(5);return0;}1.3.2 信号处理函数的安全实践// 异步信号安全的信号处理函数#includesignal.h#includestdio.h#includestdlib.h#includeunistd.h#includeerrno.h#includestring.h// 全局标志由信号处理函数设置volatilesig_atomic_tflag0;// 异步信号安全的处理函数voidsignal_handler(intsig){// 只设置标志不做其他事情flag1;// 可以安全地使用writeconstcharmsg[]Signal received\n;write(STDOUT_FILENO,msg,sizeof(msg)-1);}// 非安全的处理函数演示问题voidunsafe_handler(intsig){// printf不是异步信号安全的printf(Received signal %d\n,sig);// 危险// malloc/free也不是安全的char*bufmalloc(100);// 危险if(buf){sprintf(buf,Signal %d,sig);// sprintf也不是安全的free(buf);// 危险}}// 主程序安全的信号处理模式intmain(){structsigactionsa;// 设置信号处理sa.sa_handlersignal_handler;sigemptyset(sa.sa_mask);sa.sa_flags0;if(sigaction(SIGINT,sa,NULL)-1){perror(sigaction);return1;}if(sigaction(SIGTERM,sa,NULL)-1){perror(sigaction);return1;}// 主循环检查标志而不是在信号处理函数中做复杂工作while(1){// 阻塞所有信号以避免竞态条件sigset_tall_signals,old_signals;sigfillset(all_signals);sigprocmask(SIG_BLOCK,all_signals,old_signals);if(flag){// 重置标志flag0;// 在这里执行实际工作在信号被阻塞的情况下printf(Processing signal...\n);// 可以安全地使用非异步安全的函数}// 恢复信号掩码sigprocmask(SIG_SETMASK,old_signals,NULL);// 休眠可能被信号中断pause();// 等待信号}return0;}1.3.3 实时信号与排队信号// 实时信号排队信号示例#includesignal.h#includestdio.h#includestdlib.h#includeunistd.h#includestring.h// 实时信号处理函数voidrt_signal_handler(intsig,siginfo_t*info,void*context){// 可以获取发送者的PID和数据printf(Received real-time signal %d\n,sig);printf( From PID: %d\n,info-si_pid);printf( Value: %d\n,info-si_value.sival_int);printf( Code: %d\n,info-si_code);// 可以使用用户数据if(info-si_codeSI_QUEUE){printf( This is a queued signal with data\n);}}intmain(){structsigactionsa;unionsigval value;printf(PID: %d\n,getpid());// 设置实时信号处理sa.sa_sigactionrt_signal_handler;sigemptyset(sa.sa_mask);sa.sa_flagsSA_SIGINFO|SA_RESTART;// 重要必须使用SA_SIGINFO// 注册实时信号处理if(sigaction(SIGRTMIN,sa,NULL)-1){perror(sigaction);return1;}if(sigaction(SIGRTMIN1,sa,NULL)-1){perror(sigaction);return1;}// 如果是父进程发送排队信号pid_tpidfork();if(pid-1){perror(fork);return1;}if(pid0){// 父进程发送多个排队信号sleep(1);// 给子进程时间设置信号处理for(inti0;i5;i){value.sival_inti*100;printf(Parent: sending signal with value %d\n,value.sival_int);// 发送排队信号实时信号可以排队if(sigqueue(pid,SIGRTMIN,value)-1){perror(sigqueue);}usleep(100000);// 100ms间隔}// 等待子进程wait(NULL);}else{// 子进程接收信号printf(Child: waiting for signals...\n);// 实时信号会被排队所以会按顺序处理while(1){pause();// 等待信号}}return0;}二、守护进程Daemon深度解析2.1 守护进程的完整创建流程2.1.1 传统UNIX守护进程创建// 完整的守护进程创建函数#includestdio.h#includestdlib.h#includeunistd.h#includesys/types.h#includesys/stat.h#includefcntl.h#includesignal.h#includesyslog.hintbecome_daemon(intflags){intmaxfd,fd;// 1. 创建子进程父进程退出switch(fork()){case-1:return-1;// 失败case0:break;// 子进程继续default:_exit(EXIT_SUCCESS);// 父进程退出}// 2. 成为新会话的首进程脱离控制终端if(setsid()-1)return-1;// 3. 确保不是会话首进程防止获取控制终端switch(fork()){case-1:return-1;case0:break;default:_exit(EXIT_SUCCESS);}// 4. 清除文件创建掩码if(!(flagsBD_NO_UMASK0))umask(0);// 5. 改变工作目录到根目录if(!(flagsBD_NO_CHDIR))if(chdir(/)-1)return-1;// 6. 关闭所有打开的文件描述符if(!(flagsBD_NO_CLOSE_FILES)){maxfdsysconf(_SC_OPEN_MAX);if(maxfd-1)// 如果限制不确定假设为1024maxfd1024;for(fd0;fdmaxfd;fd)close(fd);}// 7. 重新打开标准文件描述符到/dev/nullif(!(flagsBD_NO_REOPEN_STD_FDS)){close(STDIN_FILENO);fdopen(/dev/null,O_RDWR);if(fd!STDIN_FILENO)// fd应该是0return-1;if(dup2(STDIN_FILENO,STDOUT_FILENO)!STDOUT_FILENO)return-1;if(dup2(STDIN_FILENO,STDERR_FILENO)!STDERR_FILENO)return-1;}return0;}// 守护进程标志#defineBD_NO_CHDIR01// 不改变工作目录#defineBD_NO_CLOSE_FILES02// 不关闭所有打开的文件#defineBD_NO_REOPEN_STD_FDS04// 不重新打开stdin/stdout/stderr#defineBD_NO_UMASK0010// 不清除umask#defineBD_MAX_CLOSE8192// 如果sysconf返回不确定值2.1.2 现代守护进程的最佳实践// 使用双重fork和syslog的现代守护进程#includesys/types.h#includesys/stat.h#includesyslog.h#includefcntl.h#includesignal.h#includeunistd.h#includestdlib.h#includestdio.h#includestring.h#includeerrno.h// 信号处理函数staticvoidsignal_handler(intsig){switch(sig){caseSIGHUP:syslog(LOG_INFO,Received SIGHUP, reloading configuration);// 重新加载配置break;caseSIGTERM:syslog(LOG_INFO,Received SIGTERM, exiting);closelog();exit(EXIT_SUCCESS);default:syslog(LOG_WARNING,Received unexpected signal %d,sig);}}// 设置信号处理staticvoidsetup_signal_handlers(void){structsigactionsa;// 设置SIGHUP处理重新加载配置sa.sa_handlersignal_handler;sigemptyset(sa.sa_mask);sa.sa_flagsSA_RESTART;if(sigaction(SIGHUP,sa,NULL)-1){syslog(LOG_ERR,Failed to set up SIGHUP handler: %s,strerror(errno));exit(EXIT_FAILURE);}// 设置SIGTERM处理优雅退出if(sigaction(SIGTERM,sa,NULL)-1){syslog(LOG_ERR,Failed to set up SIGTERM handler: %s,strerror(errno));exit(EXIT_FAILURE);}// 忽略不必要的信号sa.sa_handlerSIG_IGN;if(sigaction(SIGPIPE,sa,NULL)-1){syslog(LOG_ERR,Failed to ignore SIGPIPE: %s,strerror(errno));exit(EXIT_FAILURE);}if(sigaction(SIGUSR1,sa,NULL)-1){syslog(LOG_ERR,Failed to ignore SIGUSR1: %s,strerror(errno));exit(EXIT_FAILURE);}if(sigaction(SIGUSR2,sa,NULL)-1){syslog(LOG_ERR,Failed to ignore SIGUSR2: %s,strerror(errno));exit(EXIT_FAILURE);}}// 创建PID文件staticintcreate_pidfile(constchar*pidfile){intfd;charpid_str[20];fdopen(pidfile,O_WRONLY|O_CREAT|O_TRUNC,0644);if(fd-1){syslog(LOG_ERR,Cannot open PID file %s: %s,pidfile,strerror(errno));return-1;}snprintf(pid_str,sizeof(pid_str),%ld\n,(long)getpid());if(write(fd,pid_str,strlen(pid_str))!(ssize_t)strlen(pid_str)){syslog(LOG_ERR,Cannot write to PID file %s: %s,pidfile,strerror(errno));close(fd);return-1;}close(fd);return0;}// 守护进程主函数intdaemonize(constchar*name,constchar*pidfile,intfacility){pid_tpid,sid;// 第一次forkpidfork();if(pid0){// fork失败return-1;}elseif(pid0){// 父进程退出exit(EXIT_SUCCESS);}// 子进程继续// 创建新会话脱离控制终端sidsetsid();if(sid0){return-1;}// 第二次fork确保不是会话首进程防止获取控制终端pidfork();if(pid0){return-1;}elseif(pid0){// 父进程退出exit(EXIT_SUCCESS);}// 孙子进程继续真正的守护进程// 清除文件创建掩码umask(0);// 改变工作目录到根目录if(chdir(/)0){return-1;}// 关闭标准文件描述符close(STDIN_FILENO);close(STDOUT_FILENO);close(STDERR_FILENO);// 重新打开stdin, stdout, stderr到/dev/nullopen(/dev/null,O_RDONLY);// stdinopen(/dev/null,O_RDWR);// stdoutopen(/dev/null,O_RDWR);// stderr// 初始化syslogopenlog(name,LOG_PID,facility);// 创建PID文件if(pidfilecreate_pidfile(pidfile)0){syslog(LOG_ERR,Cannot create PID file);return-1;}// 设置信号处理setup_signal_handlers();syslog(LOG_INFO,Daemon %s started with PID %ld,name,(long)getpid());return0;}// 示例守护进程主程序intmain(intargc,char*argv[]){constchar*daemon_namemydaemon;constchar*pidfile/var/run/mydaemon.pid;// 成为守护进程if(daemonize(daemon_name,pidfile,LOG_DAEMON)0){fprintf(stderr,Failed to daemonize\n);exit(EXIT_FAILURE);}// 守护进程主循环syslog(LOG_INFO,Daemon is running);while(1){// 守护进程的工作// 例如检查配置、处理请求等sleep(10);// 示例每10秒循环一次syslog(LOG_DEBUG,Daemon heartbeat);}// 理论上不会到达这里closelog();return0;}2.2 systemd时代的守护进程2.2.1 systemd服务单元文件# /etc/systemd/system/mydaemon.service [Unit] DescriptionMy Custom Daemon Documentationman:mydaemon(8) Afternetwork.target Requiresnetwork.target [Service] Typenotify # 使用sd_notify()通知systemd ExecStart/usr/sbin/mydaemon # 守护进程二进制文件 ExecReload/bin/kill -HUP $MAINPID ExecStop/bin/kill -TERM $MAINPID KillSignalSIGTERM KillModeprocess # 只杀死主进程 Restarton-failure # 失败时重启 RestartSec5s # 重启前等待5秒 TimeoutStopSec30s # 停止超时30秒 # 安全设置 Userdaemonuser Groupdaemongroup NoNewPrivilegestrue PrivateTmptrue ProtectSystemstrict ProtectHometrue ReadWritePaths/var/lib/mydaemon /var/log/mydaemon # 资源限制 LimitNOFILE65536 LimitNPROC512 LimitMEMLOCKinfinity # 环境变量 EnvironmentMY_DAEMON_DEBUG0 EnvironmentFile-/etc/default/mydaemon [Install] WantedBymulti-user.target2.2.2 使用sd-daemon库的现代守护进程// 使用systemd的sd-daemon库的守护进程#define_GNU_SOURCE#includesystemd/sd-daemon.h#includesystemd/sd-event.h#includestdio.h#includestdlib.h#includeunistd.h#includesignal.h#includesyslog.h#includeerrno.h#includestring.h// 事件回调函数staticintsignal_handler(sd_event_source*es,conststructsignalfd_siginfo*si,void*userdata){switch(si-ssi_signo){caseSIGTERM:sd_notify(0,STOPPING1);sd_event_exit(sd_event_source_get_event(es),0);break;caseSIGHUP:sd_notify(0,RELOADING1);// 重新加载配置sd_notify(0,READY1);break;default:break;}return0;}// 定时器回调函数staticinttimer_handler(sd_event_source*es,uint64_tusec,void*userdata){staticintcount0;count;syslog(LOG_INFO,Timer tick %d,count);// 发送watchdog通知如果启用了WatchdogSecsd_notify(0,WATCHDOG1);return0;}intmain(intargc,char*argv[]){sd_event*eventNULL;sd_event_source*signal_sourceNULL;sd_event_source*timer_sourceNULL;sigset_tss;intr;// 初始化syslogopenlog(systemd-daemon,LOG_PID,LOG_DAEMON);// 创建事件循环rsd_event_default(event);if(r0){syslog(LOG_ERR,Failed to create event loop: %s,strerror(-r));gotofinish;}// 设置信号处理sigemptyset(ss);sigaddset(ss,SIGTERM);sigaddset(ss,SIGHUP);sigaddset(ss,SIGINT);rsd_event_add_signal(event,signal_source,ss,signal_handler,NULL);if(r0){syslog(LOG_ERR,Failed to add signal handler: %s,strerror(-r));gotofinish;}// 添加定时器每秒触发一次rsd_event_add_time(event,timer_source,CLOCK_MONOTONIC,UINT64_MAX,1000000,timer_handler,NULL);if(r0){syslog(LOG_ERR,Failed to add timer: %s,strerror(-r));gotofinish;}// 通知systemd服务已启动sd_notify(0,READY1\nSTATUSDaemon is running\nMAINPID%lu,(unsignedlong)getpid());syslog(LOG_INFO,Daemon started with PID %ld,(long)getpid());// 运行事件循环rsd_event_loop(event);if(r0){syslog(LOG_ERR,Event loop failed: %s,strerror(-r));}finish:// 清理if(signal_source)sd_event_source_unref(signal_source);if(timer_source)sd_event_source_unref(timer_source);if(event)sd_event_unref(event);syslog(LOG_INFO,Daemon stopped);closelog();returnr0?EXIT_FAILURE:EXIT_SUCCESS;}三、进程组Process Group与会话Session3.1 进程组与会话的基本概念3.1.1 关系层次进程、进程组、会话、终端的关系 ┌─────────────────────────────────────────┐ │ 终端Terminal │ ← 物理或伪终端 │ /dev/tty1, pts/0, etc. │ └───────────────────┬─────────────────────┘ │ 控制关系 ▼ ┌─────────────────────────────────────────┐ │ 会话Session │ ← 一次登录形成一个会话 │ - 会话IDSID │ │ - 控制进程Session Leader │ │ - 控制终端Controlling Terminal │ │ - 前台进程组Foreground Process Group│ │ - 后台进程组Background Process Group│ └───────────────────┬─────────────────────┘ │ 包含关系 ▼ ┌─────────────────────────────────────────┐ │ 进程组Process Group │ ← 一个作业job │ - 进程组IDPGID │ │ - 组长进程Process Group Leader │ └───────────────────┬─────────────────────┘ │ 包含关系 ▼ ┌─────────────────────────────────────────┐ │ 进程Process │ │ - 进程IDPID │ │ - 父进程IDPPID │ │ - 实际用户IDRUID │ │ - 有效用户IDEUID │ └─────────────────────────────────────────┘3.1.2 内核数据结构// 内核中的进程组和会话数据结构// task_struct中的相关字段structtask_struct{// ... 其他字段pid_tpid;// 进程IDpid_ttgid;// 线程组IDPOSIX线程// 进程组和会话structpid_linkpids[PIDTYPE_MAX];// PID链接structtask_struct*group_leader;// 线程组领导者// ... 其他字段};// PID类型枚举enumpid_type{PIDTYPE_PID,// 进程IDPIDTYPE_TGID,// 线程组IDPIDTYPE_PGID,// 进程组IDPIDTYPE_SID,// 会话IDPIDTYPE_MAX};// PID结构structpid{atomic_tcount;unsignedintlevel;structhlist_headtasks[PIDTYPE_MAX];structrcu_headrcu;structupidnumbers[1];};// 用户空间可见的PIDstructupid{intnr;// PID数值structpid_namespace*ns;// 命名空间structhlist_nodepid_chain;};3.2 进程组操作与会话管理3.2.1 创建新会话和进程组// 创建新会话和进程组的完整示例#includestdio.h#includestdlib.h#includeunistd.h#includesys/types.h#includesys/wait.h#includesignal.hvoidprint_ids(constchar*name){printf(%s: PID%ld, PPID%ld, PGID%ld, SID%ld\n,name,(long)getpid(),(long)getppid(),(long)getpgrp(),(long)getsid(0));// 获取控制终端intttytcgetpgrp(STDIN_FILENO);if(tty-1){printf(%s: No controlling terminal\n,name);}else{printf(%s: Controlling terminal PGID%ld\n,name,(long)tty);}}intmain(){pid_tpid;printf(Original process:\n);print_ids(Parent);// 创建子进程pidfork();if(pid-1){perror(fork);return1;}if(pid0){// 子进程// 创建新会话if(setsid()-1){perror(setsid);exit(1);}printf(\nAfter setsid():\n);print_ids(Child (new session leader));// 创建孙子进程在新的会话中pid_tgrandchild_pidfork();if(grandchild_pid-1){perror(fork in child);exit(1);}if(grandchild_pid0){// 孙子进程// 创建新进程组孙子进程成为组长if(setpgid(0,0)-1){perror(setpgid);exit(1);}printf(\nGrandchild in new process group:\n);print_ids(Grandchild (new PG leader));// 孙子进程的工作sleep(5);exit(0);}else{// 子进程等待孙子进程wait(NULL);}exit(0);}else{// 父进程sleep(1);printf(\nParent after child created new session:\n);print_ids(Parent);// 父进程等待子进程wait(NULL);}return0;}3.2.2 作业控制Job Control实现// 简单的shell作业控制实现#includestdio.h#includestdlib.h#includeunistd.h#includesys/types.h#includesys/wait.h#includesignal.h#includetermios.h#includestring.h#defineMAX_JOBS100// 作业状态typedefenum{JOB_RUNNING,JOB_STOPPED,JOB_DONE}job_state_t;// 作业结构typedefstruct{pid_tpgid;// 进程组IDintjob_id;// 作业IDjob_state_tstate;// 状态char*command;// 命令字符串}job_t;job_tjobs[MAX_JOBS];intnext_job_id1;// 添加作业intadd_job(pid_tpgid,constchar*command){for(inti0;iMAX_JOBS;i){if(jobs[i].stateJOB_DONE||jobs[i].pgid0){jobs[i].pgidpgid;jobs[i].job_idnext_job_id;jobs[i].stateJOB_RUNNING;jobs[i].commandstrdup(command);returnjobs[i].job_id;}}return-1;}// 更新作业状态voidupdate_job_status(pid_tpgid,job_state_tstate){for(inti0;iMAX_JOBS;i){if(jobs[i].pgidpgid){jobs[i].statestate;break;}}}// 列出所有作业voidlist_jobs(){printf(Job List:\n);printf(ID\tPGID\tState\tCommand\n);for(inti0;iMAX_JOBS;i){if(jobs[i].pgid!0jobs[i].state!JOB_DONE){constchar*state_str;switch(jobs[i].state){caseJOB_RUNNING:state_strRunning;break;caseJOB_STOPPED:state_strStopped;break;default:state_strUnknown;break;}printf([%d]\t%ld\t%s\t%s\n,jobs[i].job_id,(long)jobs[i].pgid,state_str,jobs[i].command);}}}// 前台运行命令pid_trun_foreground(constchar*command){pid_tpidfork();if(pid0){// 子进程// 创建新进程组子进程成为组长setpgid(0,0);// 将新进程组设置为前台进程组tcsetpgrp(STDIN_FILENO,getpgrp());// 恢复默认信号处理signal(SIGINT,SIG_DFL);signal(SIGQUIT,SIG_DFL);signal(SIGTSTP,SIG_DFL);signal(SIGTTIN,SIG_DFL);signal(SIGTTOU,SIG_DFL);// 执行命令execl(/bin/sh,sh,-c,command,(char*)NULL);// 如果exec失败perror(execl);exit(1);}elseif(pid0){// 父进程shell// 等待子进程的进程组intstatus;waitpid(-pid,status,WUNTRACED);// 将控制终端返回给shelltcsetpgrp(STDIN_FILENO,getpgrp());// 检查子进程是否停止if(WIFSTOPPED(status)){// 子进程被停止如CtrlZprintf(\nJob stopped\n);add_job(pid,command);update_job_status(pid,JOB_STOPPED);}elseif(WIFSIGNALED(status)){// 子进程被信号终止printf(\nJob terminated by signal %d\n,WTERMSIG(status));}returnpid;}return-1;}// 后台运行命令pid_trun_background(constchar*command){pid_tpidfork();if(pid0){// 子进程// 创建新进程组setpgid(0,0);// 后台进程应该忽略终端信号signal(SIGINT,SIG_IGN);signal(SIGQUIT,SIG_IGN);signal(SIGTSTP,SIG_IGN);signal(SIGTTIN,SIG_IGN);signal(SIGTTOU,SIG_IGN);// 重定向标准输入从/dev/nullintnull_fdopen(/dev/null,O_RDONLY);if(null_fd!-1){dup2(null_fd,STDIN_FILENO);close(null_fd);}// 执行命令execl(/bin/sh,sh,-c,command,(char*)NULL);perror(execl);exit(1);}elseif(pid0){// 父进程shellintjob_idadd_job(pid,command);printf([%d] %ld\n,job_id,(long)pid);returnpid;}return-1;}// 继续运行作业前台或后台intcontinue_job(intjob_id,intforeground){job_t*jobNULL;// 查找作业for(inti0;iMAX_JOBS;i){if(jobs[i].job_idjob_idjobs[i].stateJOB_STOPPED){jobjobs[i];break;}}if(!job){printf(No such stopped job: %d\n,job_id);return-1;}// 发送SIGCONT信号继续作业if(kill(-job-pgid,SIGCONT)-1){perror(kill);return-1;}if(foreground){// 前台继续job-stateJOB_RUNNING;// 将作业的进程组设置为前台进程组tcsetpgrp(STDIN_FILENO,job-pgid);// 等待作业完成intstatus;waitpid(-job-pgid,status,WUNTRACED);// 将控制终端返回给shelltcsetpgrp(STDIN_FILENO,getpgrp());if(WIFSTOPPED(status)){job-stateJOB_STOPPED;printf(\nJob %d stopped again\n,job_id);}else{job-stateJOB_DONE;printf(\nJob %d completed\n,job_id);}}else{// 后台继续job-stateJOB_RUNNING;printf(Continued job %d in background\n,job_id);}return0;}intmain(){charcommand[256];structtermiosoriginal_termios;// 保存原始终端设置tcgetattr(STDIN_FILENO,original_termios);printf(Simple Shell with Job Control\n);printf(Commands:\n);printf( command - Run in background\n);printf( jobs - List jobs\n);printf( fg job_id - Bring job to foreground\n);printf( bg job_id - Continue job in background\n);printf( exit - Exit shell\n);while(1){printf(\nshell );fflush(stdout);if(!fgets(command,sizeof(command),stdin)){break;}// 去掉换行符command[strcspn(command,\n)]\0;if(strlen(command)0){continue;}if(strcmp(command,exit)0){break;}elseif(strcmp(command,jobs)0){list_jobs();}elseif(strncmp(command,fg ,3)0){intjob_idatoi(command3);continue_job(job_id,1);}elseif(strncmp(command,bg ,3)0){intjob_idatoi(command3);continue_job(job_id,0);}elseif(command[strlen(command)-1]){// 后台运行command[strlen(command)-1]\0;run_background(command);}else{// 前台运行run_foreground(command);}}// 恢复原始终端设置tcsetattr(STDIN_FILENO,TCSANOW,original_termios);return0;}3.3 终端与控制进程3.3.1 终端控制原语// 终端控制完整示例#includestdio.h#includestdlib.h#includeunistd.h#includetermios.h#includesignal.h#includesys/ioctl.h// 保存和恢复终端设置structtermiosoriginal_termios;voidrestore_terminal(){tcsetattr(STDIN_FILENO,TCSAFLUSH,original_termios);}voidsetup_terminal(){structtermiosnew_termios;// 获取当前终端设置if(tcgetattr(STDIN_FILENO,original_termios)-1){perror(tcgetattr);exit(1);}// 设置atexit处理函数atexit(restore_terminal);// 配置新终端设置new_termiosoriginal_termios;// 禁用规范模式逐行处理和回显new_termios.c_lflag~(ICANON|ECHO);// 设置最小读取字符数和超时new_termios.c_cc[VMIN]1;// 至少读取1个字符new_termios.c_cc[VTIME]0;// 无超时// 应用新设置if(tcsetattr(STDIN_FILENO,TCSAFLUSH,new_termios)-1){perror(tcsetattr);exit(1);}}// 获取终端大小voidget_terminal_size(int*rows,int*cols){structwinsizews;if(ioctl(STDIN_FILENO,TIOCGWINSZ,ws)-1){// 如果ioctl失败使用默认值*rows24;*cols80;}else{*rowsws.ws_row;*colsws.ws_col;}}// 终端信号处理voidsigwinch_handler(intsig){introws,cols;// 获取新的终端大小get_terminal_size(rows,cols);printf(\rTerminal resized: %dx%d\n,cols,rows);fflush(stdout);}// 简单的终端应用程序intmain(){charch;introws,cols;// 设置信号处理signal(SIGWINCH,sigwinch_handler);// 设置终端setup_terminal();// 获取初始终端大小get_terminal_size(rows,cols);printf(Terminal size: %dx%d\n,cols,rows);printf(Press q to quit, any other key to continue\n);while(1){// 读取单个字符非阻塞模式if(read(STDIN_FILENO,ch,1)1){if(chq||chQ){break;}printf(You pressed: %c (0x%02x)\r\n,isprint(ch)?ch: ,(unsignedchar)ch);// 如果是CtrlC不会中断程序因为我们处理了终端设置if(ch0x03){// CtrlCprintf(CtrlC pressed (but ignored)\r\n);}// 如果是CtrlZ发送SIGTSTP给自己if(ch0x1a){// CtrlZprintf(CtrlZ pressed, stopping...\r\n);fflush(stdout);kill(getpid(),SIGTSTP);// 当进程继续时从这里恢复printf(Process continued\r\n);}}}printf(\nExiting...\n);return0;}四、高级主题与最佳实践4.1 信号处理的最佳实践4.1.1 信号处理中的竞态条件// 避免信号处理中的竞态条件#includesignal.h#includestdio.h#includestdlib.h#includeunistd.h#includeerrno.h#includepthread.h// 使用sig_atomic_t保证原子性volatilesig_atomic_tflag0;volatilesig_atomic_tprocessed_flag1;// 初始为已处理// 信号处理函数 - 只设置标志voidsignal_handler(intsig){if(processed_flag){flag1;processed_flag0;}}// 线程安全的信号处理void*worker_thread(void*arg){sigset_tmask;// 在这个线程中阻塞所有信号sigfillset(mask);pthread_sigmask(SIG_BLOCK,mask,NULL);while(1){// 在这里执行工作不会被信号中断usleep(100000);// 100ms// 检查是否需要处理信号通过线程间通信// ...}returnNULL;}intmain(){structsigactionsa;pthread_tthread;sigset_tmask,oldmask;// 设置信号处理sa.sa_handlersignal_handler;sigemptyset(sa.sa_mask);sa.sa_flags0;if(sigaction(SIGINT,sa,NULL)-1){perror(sigaction);return1;}if(sigaction(SIGTERM,sa,NULL)-1){perror(sigaction);return1;}// 创建工作者线程pthread_create(thread,NULL,worker_thread,NULL);// 在主线程中处理信号sigemptyset(mask);sigaddset(mask,SIGINT);sigaddset(mask,SIGTERM);while(1){// 等待信号sigsuspend(oldmask);// 当信号处理函数返回后检查标志if(flag!processed_flag){// 处理信号printf(Processing signal...\n);// 重置标志flag0;processed_flag1;}}pthread_join(thread,NULL);return0;}4.2 现代守护进程架构4.2.1 基于事件循环的守护进程// 使用libevent的现代守护进程#includeevent2/event.h#includeevent2/listener.h#includeevent2/bufferevent.h#includesignal.h#includesyslog.h#includeunistd.h#includestdlib.h#includestring.hstaticvoidsignal_cb(evutil_socket_tfd,shortevent,void*arg){structevent_base*basearg;syslog(LOG_INFO,Received signal, shutting down);event_base_loopbreak(base);}staticvoidaccept_cb(structevconnlistener*listener,evutil_socket_tfd,structsockaddr*addr,intsocklen,void*arg){structevent_base*basearg;structbufferevent*bev;bevbufferevent_socket_new(base,fd,BEV_OPT_CLOSE_ON_FREE);if(!bev){syslog(LOG_ERR,Error creating bufferevent);return;}// 设置回调bufferevent_setcb(bev,NULL,NULL,NULL,NULL);bufferevent_enable(bev,EV_READ|EV_WRITE);}intmain(intargc,char*argv[]){structevent_base*base;structevconnlistener*listener;structevent*signal_event;structsockaddr_insin;// 成为守护进程daemon(1,0);// 打开syslogopenlog(libevent-daemon,LOG_PID,LOG_DAEMON);syslog(LOG_INFO,Daemon started);// 初始化libeventbaseevent_base_new();if(!base){syslog(LOG_ERR,Could not initialize libevent);return1;}// 设置信号处理signal_eventevsignal_new(base,SIGINT,signal_cb,base);evsignal_add(signal_event,NULL);signal_eventevsignal_new(base,SIGTERM,signal_cb,base);evsignal_add(signal_event,NULL);// 设置监听socketmemset(sin,0,sizeof(sin));sin.sin_familyAF_INET;sin.sin_porthtons(8888);listenerevconnlistener_new_bind(base,accept_cb,base,LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,-1,(structsockaddr*)sin,sizeof(sin));if(!listener){syslog(LOG_ERR,Could not create listener);return1;}syslog(LOG_INFO,Daemon listening on port 8888);// 运行事件循环event_base_dispatch(base);// 清理evconnlistener_free(listener);event_base_free(base);syslog(LOG_INFO,Daemon stopped);closelog();return0;}五、总结信号处理、守护进程、进程组和会话是Linux进程管理中的核心概念。理解这些概念对于编写健壮的、功能丰富的应用程序至关重要。在实际开发中我们经常需要处理信号、编写守护进程并通过进程组和会话来管理作业。