《APUE》读书笔记—第十章信号（下）

　　接着昨天学习Unix信号机制，信号内容挺多了，发了两天的时间才了解各大概，日后遇到问题需要多看几遍，掌握核心应用。

7、sigaction函数

sigaction函数的功能是检查或修改与指定信号相关联的处理动作或同时执行这两种操作，可以用sigaction函数实现signal函数。函数原型及结构参数如下：

　　int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

　　struct sigaction {
   　　 void     (*sa_handler)(int);
   　　 void     (*sa_sigaction)(int, siginfo_t *, void *);
    　　sigset_t   sa_mask;
   　　 int        sa_flags;
    　　void     (*sa_restorer)(void);
　　};

现用sigaction函数实现signal函数，被信号中断的系统调用都能够重启。程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>

typedef void Sigfunc(int);

Sigfunc* mysignal(int signo,Sigfunc *func)
{
    struct sigaction    act,oact;
    act.sa_handler = func;  //设置中断处理程序
    sigemptyset(&act.sa_mask);  //初始化信号集
    act.sa_flags = 0;
    if(signo == SIGALRM)   //将SIGALRM信号设置为系统调用不会自动重启
    {
    #ifdef SA_INTERRUPT
        act.sa_flags |= SA_INTERRUPT;
    #endif
    }
    else   //其余信号设置为系统调用自动重启
    {
    #ifdef  SA_RESTART
        act.sa_flags |= SA_RESTART;
    #endif
    }
    if(sigaction(signo,&act,&oact)<0)
        return (SIG_ERR);
    return (oact.sa_handler);
}

static void sig_func(int signo)
{
    printf("Recevied a SIGALRM signal.\n");
}

int main()
{
    printf("Starting.\n");
    mysignal(SIGALRM,sig_func);
    alarm(2);
    pause();  //等待信号出现
    exit(0);
}

程序执行结果如下：

8、sigsetjmp和siglongjmp函数

　这两个函数是对非局部转移的setjmp和longjmp函数的改进，在信号处理程序中进行非局部转移时应当使用这两个函数。函数原型如下：　　

   int sigsetjmp(sigjmp_buf env, int savesigs);
   void siglongjmp(sigjmp_buf env, int val);

在sigsetjmp函数中，如果savesigs非0，则sigsetjmp在env中保存进程的当前信号屏蔽字，调用siglongjmp从其中恢复保存的信号屏蔽字。

写个程序练习一下，程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <signal.h>

static void printcharacter(const char* str);
static void sig_usr(int signo);
void TELL_WAIT(void);
void TELL_PARENT(pid_t pid);
void TELL_CHILD(pid_t pid);
void WAIT_PARENT(void);
void WAIT_CHILD(void);
static volatile sig_atomic_t sigflag;
static sigset_t newmask,oldmask,zeromask;

int main()
{
    pid_t   pid;
    TELL_WAIT();
    pid = fork();
    switch(pid)
    {
    case -1:
        perror("fork() error");
        exit(-1);
    case 0:   //让子进程优先执行
        //WAIT_PARENT();
        printcharacter("output from child prcess.\n");
        TELL_PARENT(getppid());
        break;
    default:
        WAIT_CHILD();
        printcharacter("output from parent prcess.\n");
        //TELL_CHILD(pid);
    }
    exit(0);
}

static void printcharacter(const char* str)
{
    const char *ptr;
    setbuf(stdout,NULL);
    for(ptr=str;*ptr!='\0';ptr++)
        putc(*ptr,stdout);
}
static void sig_usr(int signo)  //信号处理程序
{
    sigflag = 1;
}
void TELL_WAIT(void)
{
    signal(SIGUSR1,sig_usr);
    signal(SIGUSR2,sig_usr);
    sigemptyset(&zeromask);
    sigemptyset(&newmask);
    //添加信号集
    sigaddset(&newmask,SIGUSR1);
    sigaddset(&newmask,SIGUSR2);
    sigprocmask(SIG_BLOCK,&newmask,&oldmask);  //设置信号为阻塞
}
void TELL_PARENT(pid_t pid)
{ 
    kill(pid,SIGUSR2); //向子进程发送信号
}
void TELL_CHILD(pid_t pid)
{
    kill(pid,SIGUSR1);//向父进程发送信号
}    
void WAIT_PARENT(void)
{
    while(sigflag == 0)
      sigsuspend(&zeromask);
    sigflag = 0;
    sigprocmask(SIG_SETMASK,&oldmask,NULL);
}
void WAIT_CHILD(void)
{
    while(sigflag == 0)
      sigsuspend(&zeromask); //阻塞进程
    sigflag = 0;
    sigprocmask(SIG_SETMASK,&oldmask,NULL);
}

程序执行结果如下：

 当调用一个信号处理程序时，被捕捉到的信号添加到进程的当前信号屏蔽字中，当从信号处理程序返回时，恢复原来的屏蔽字，siglongjmp恢复了有sigsetjmp保存的信号屏蔽字。

9、sigsuspend函数

　　该函数在一个原子操作中先恢复信号屏蔽字，然后使进程休眠。函数原型如下：

　　int sigsuspend(const sigset_t *mask); //返回-1，并将errno设置为EINTR

　　将信号屏蔽字设置为mask指向的值，在捕捉到一个信号或发生一个会终止该进程的信号之前，该进程被挂起。如果捕捉到一个信号而且从该信号程序返回，则sigsuspend返回，并且该进程的信号屏蔽字设置为调用sigsuspend之前的值。该函数可以保护不希望由信号中断的代码临界区，写个程序，使用该函数保护临界区，使其不被特定信号中断，程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include <setjmp.h>
void pr_mask(const char *str);
static void sig_int(int);

int main()
{
    sigset_t    newmask,oldmask,waitmask;
    pr_mask("program start: ");
    signal(SIGINT,sig_int);
    sigemptyset(&waitmask);
    sigaddset(&waitmask,SIGUSR1);
    sigemptyset(&newmask);
    sigaddset(&newmask,SIGINT);
    sigprocmask(SIG_BLOCK,&newmask,&oldmask);
    pr_mask("in critical region");
    //修改进程屏蔽字，在捕捉信号之前，将进程挂起
    sigsuspend(&waitmask);
    pr_mask("after return form sigsuspend: ");
    sigprocmask(SIG_SETMASK,&oldmask,NULL);
    pr_mask("program exit: ");
    exit(0);
}

void pr_mask(const char *str)
{
    sigset_t sigset;
    int errno_save;
    errno_save = errno;
    if(sigprocmask(0,NULL,&sigset)<0)
    {
        perror("sigprocmask() error");
        exit(-1);
    }
    printf("%s\n",str);
    if(sigismember(&sigset,SIGINT))
        printf("SIGINT \n");
    if(sigismember(&sigset,SIGQUIT))
        printf("SIGQUIT \n");
    if(sigismember(&sigset,SIGUSR1))
        printf("SIGUSR1 \n");
    if(sigismember(&sigset,SIGALRM))
        printf("SIGALRM \n");
    errno = errno_save;
}

static void sig_int(int signo)
{
    pr_mask("\nin sig_int: ");
}

 程序执行结果如下：

从结果可以看出在调用sigsuspend函数，将SIGUSR1信号添加到进程信号屏蔽字中，当从sissuspend返回时，信号屏蔽字恢复为调用它之前的值。

进程之间存在资源竞争，程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>

static void printcharacter(const char* str)
{
    const char *ptr;
    setbuf(stdout,NULL);
    for(ptr=str;*ptr!='\0';ptr++)
        putc(*ptr,stdout);
}

int main()
{
    pid_t   pid;
    pid = fork();
    switch(pid)
    {
    case -1:
        perror("fork() error");
        exit(-1);
    case 0:
        printcharacter("output from child prcess.\n");
        break;
    default:
        printcharacter("output from parent prcess.\n");
    }
    exit(0);
}

 程序执行结果如下：

　　从结果看出，父子进程之间存在资源竞争，导致输出结果是随机的。接下来采用信号机制实现父子进程之间的同步实现TELL_WAIT、TELL_PARENT、TELL_CHILD、  WAIT_PARENT和WAIT_CHILD。程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <signal.h>

static void printcharacter(const char* str);
static void sig_usr(int signo);
void TELL_WAIT(void);
void TELL_PARENT(pid_t pid);
void TELL_CHILD(pid_t pid);
void WAIT_PARENT(void);
void WAIT_CHILD(void);
static volatile sig_atomic_t sigflag;
static sigset_t newmask,oldmask,zeromask;

int main()
{
    pid_t   pid;
    TELL_WAIT();
    pid = fork();
    switch(pid)
    {
    case -1:
        perror("fork() error");
        exit(-1);
    case 0:
        //WAIT_PARENT();
        printcharacter("output from child prcess.\n");
        TELL_PARENT(getppid());
        break;
    default:
        WAIT_CHILD();
        printcharacter("output from parent prcess.\n");
        //TELL_CHILD(pid);
    }
    exit(0);
}

static void printcharacter(const char* str)
{
    const char *ptr;
    setbuf(stdout,NULL);
    for(ptr=str;*ptr!='\0';ptr++)
        putc(*ptr,stdout);
}
static void sig_usr(int signo)
{
    sigflag = 1;
}
void TELL_WAIT(void)
{
    signal(SIGUSR1,sig_usr);  //设置信号
    signal(SIGUSR2,sig_usr);
    sigemptyset(&zeromask);
    sigemptyset(&newmask);
    sigaddset(&zeromask,SIGUSR1);
    sigaddset(&newmask,SIGUSR2);
    sigprocmask(SIG_BLOCK,&newmask,&oldmask);  //将信号设置为阻塞
}
void TELL_PARENT(pid_t pid)
{
    kill(pid,SIGUSR2); //向子进程发生信号
}
void TELL_CHILD(pid_t pid)
{
    kill(pid,SIGUSR1); //想父进程发送信号
}
void WAIT_PARENT(void)
{
    while(sigflag == 0)
      sigsuspend(&zeromask);//将进程挂起。等待信号处理程序返回
    sigflag = 0;
    sigprocmask(SIG_SETMASK,&oldmask,NULL);
}
void WAIT_CHILD(void)
{
    while(sigflag == 0)
      sigsuspend(&zeromask);  //将进程挂起。等待信号处理程序返回
    sigflag = 0;
    sigprocmask(SIG_SETMASK,&oldmask,NULL);
}

 程序执行结果如下：

10、abort函数

　　abort函数的功能是使异常终止，此函数将SIGABRT信号发送给调用进程，让进程捕捉SIGABRT信号目的是在进程终止之前由其执行所需的清理操作。默认情况是终止调用进程。可以采用sigaction和kill函数来实现abort，程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <signal.h>

void myabort()
{
    sigset_t  mask;
    struct sigaction action;
    sigaction(SIGABRT,NULL,&action);
    if(action.sa_handler == SIG_IGN)
    {
        action.sa_handler = SIG_DFL;
        sigaction(SIGABRT,&action,NULL);
    }
    if(action.sa_handler == SIG_DFL)
        fflush(NULL);
    sigfillset(&mask);
    sigdelset(&mask,SIGABRT);
    sigprocmask(SIG_SETMASK,&mask,NULL);
    kill(getpid(),SIGABRT);
    fflush(NULL);
    action.sa_handler = SIG_DFL;
    sigaction(SIGABRT,&action,NULL);
    sigprocmask(SIG_SETMASK,&mask,NULL);
    kill(getpid(),SIGABRT);
    exit(1);
}
static void sig_abort(int signo)
{
    printf("abort signal.\n");
}

int main()
{
    signal(SIGABRT,sig_abort);
    myabort();
    pause();
    exit(0);
}

执行结果如下：

11、system函数

　　POSIX.1要求system函数忽略SIGINT和SITQUIT信号，阻塞SIGCHLD。采用信号实现一个system函数，程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <signal.h>

int mysystem(const char*cmdstring)
{
    pid_t   pid;
    int     status;
    struct  sigaction   ignore,saveintr,savequit;
    sigset_t    chldmask,savemask;

    if(cmdstring == NULL)
        return 1;
    ignore.sa_handler = SIG_IGN;
    sigemptyset(&ignore.sa_mask);
    ignore.sa_flags = 0;
    if(sigaction(SIGINT,&ignore,&savequit)<0)
    {
        perror("sigaction() error");
        exit(-1);
    }
    if(sigaction(SIGQUIT,&ignore,&savequit) <0)
    {
        perror("sigaction() error");
        exit(-1);
    }
    sigemptyset(&chldmask);
    sigaddset(&chldmask,SIGCHLD);
    if(sigprocmask(SIG_BLOCK,&chldmask,&savemask) < 0)
    {
        perror("sigprocmask() error");
        exit(-1);
    }
    if((pid = fork()) == -1)
    {
        perror("fork() error");
        exit(-1);
    }
    else if(pid == 0)
    {
        sigaction(SIGINT,&saveintr,NULL);
        sigaction(SIGQUIT,&savequit,NULL);
        sigprocmask(SIG_SETMASK,&savemask,NULL);
        execl("/bin/sh","sh","-c",cmdstring,(char *)0);
        _exit(-127);
    }
    else
    {
        while(waitpid(pid,&status,0) < 0)
        {
            if(errno != EINTR)
            {
                status = -1;
                break;
            }
        }
    }
    if (sigaction(SIGINT,&saveintr,NULL)<0)
        return -1;
}

int main()
{
    printf("Pint date:\n");
    mysystem("date");
    printf("Print process:\n");
    mysystem("ps");
    exit(0);
}

程序执行结果如下：

12、sleep函数

此函数使调用进程被挂起，直到满足下列条件之一：（1）已经经过seconds所指定的墙上时钟时间（2）调用进程捕捉到一个信号并从信号处理程序返回。sleep的可靠实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <signal.h>

static void sig_alrm(int signo)
{

}

unsigned int mysleep(unsigned int nsecs)
{
    struct sigaction    newact,oldact;
    sigset_t            newmask,oldmask,suspmask;
    unsigned int        unslept;

    newact.sa_handler = sig_alrm;
    sigemptyset(&newact.sa_mask);
    newact.sa_flags = 0;
    sigaction(SIGALRM,&newact,&oldact);
    sigemptyset(&newmask);
    sigaddset(&newmask,SIGALRM);
    sigprocmask(SIG_BLOCK,&newmask,&oldmask);
    alarm(nsecs);
    suspmask = oldmask;
    sigdelset(&suspmask,SIGALRM);
    sigsuspend(&suspmask);
    unslept = alarm(0);
    sigprocmask(SIG_SETMASK,&oldmask,NULL);
    return unslept;
}

int main()
{
    int i;
    printf("Program starting.\n");
    printf("sleep 5 seconds.....\n");
    for(i=1;i<=5;++i)
    {
        printf("The %dth second.\n",i);
        mysleep(1);
    }
    printf("wake up.\n");
    exit(0);
}

程序执行结果如下：