Linux信号和信号处理

最新推荐文章于 2023-07-11 15:13:32 发布

hai836045106

最新推荐文章于 2023-07-11 15:13:32 发布

阅读量2.4k

点赞数 1

分类专栏： Unix系统编程文章标签： linux signal action command input struct

本文链接：https://blog.csdn.net/hai836045106/article/details/6619405

版权

Unix系统编程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Linux信号列表

名称默认动作说明

　　SIGHUP 终止进程终端线路挂断

　　SIGINT 终止进程中断进程

　　SIGQUIT 建立CORE文件终止进程，并且生成core文件

　　SIGILL 建立CORE文件非法指令

　　SIGTRAP 建立CORE文件跟踪自陷

　　SIGBUS 建立CORE文件总线错误

　　SIGSEGV 建立CORE文件段非法错误

　　SIGFPE 建立CORE文件浮点异常

　　SIGIOT 建立CORE文件执行I/O自陷

　　SIGKILL 终止进程杀死进程

　　SIGPIPE 终止进程向一个没有读进程的管道写数据

　　SIGALARM 终止进程计时器到时

　　SIGTERM 终止进程软件终止信号

　　SIGSTOP 停止进程非终端来的停止信号

　　SIGTSTP 停止进程终端来的停止信号

　　SIGCONT 忽略信号继续执行一个停止的进程

　　SIGURG 忽略信号 I/O紧急信号

　　SIGIO 忽略信号描述符上能进行I/O

　　SIGCHLD 忽略信号当子进程停止或退出时通知父进程

　　SIGTTOU 停止进程后台进程写终端

　　SIGTTIN 停止进程后台进程读终端

　　SIGXGPU 终止进程 CPU时限超时

　　SIGXFSZ 终止进程文件长度过长

　　SIGWINCH 忽略信号窗口大小发生变化

　　SIGPROF 终止进程统计分布图用计时器到时

　　SIGUSR1 终止进程用户定义信号1

　　SIGUSR2 终止进程用户定义信号2

　　SIGVTALRM 终止进程虚拟计时器到时

信号处理：

进程在收到信号以后，有三种方法处理所接收到的信号：
1接受默认动作，通常是终止进程的执行。
2彻底忽略信号的发生，并继续执行程序。
3接受用户自定义的默认动作。

信号集：

信号集是与处理信号的系统调用相关的主要参数，指明你想处理的一些信号列表。
#include<signal.h>
初始化：应用程序在使用信号集之前应该至少调用一次sigemptyset或sigfillset.
int sigemptyset(sigset_t *set);清空信号集中的所有信号量
int sigfillset (sigset_t *set);设置信号集中的所有信号量

操作:
int sigaddset(sigset_t *set,int signo);添加信号量到信号集中

int sigdelset(sigset_t *set,int signo);删除信号量到信号集中

例如：
#include<signal.h>

sigset_t mask1,mask2;
.
.
.
/*create empty set */
sigemptyset(&mask1);
/*add signal*/
sigaddset(&mask1,SIGINT);

/*create full set */
sigfillset(&mask2);

/*del signal*/
sigdelset(&mask2,SIGCHLD);
.
.
.

设置信号处理动作：sigaction

#include<singal.h>

int sigaction(int signo,const struct sigaction *act,
                               struct sigaction *oact);
          第一个参数signo指定需要处理的特定信号，应该在signo类型信号收到之前就调用sigaction。
          第二个参数act设定signo信号的处理动作。
          第三个参数oact返回的是此信号的当前设置值。act和oact的值都可能是NULL.

头文件<signal.h>中定义的sigaction结构：
struct sigaction
{
    void (*sa_handler)(int);
    sigset_t sa_mask

    int sa_flags;

    void (*s_sigaction)(int ,siginfo_t *,void*);
};

void (*sa_handler)(int):
sa_handler指定接收到信号signo后的处理函数。它可以为三种值：
1 SIG_DEL是一个比较特殊的符号值，它表示恢复系统定义的默认处理函数（通常是终止进程）
2 SIG_IGN表示忽略此信号.SIGKILL和SIGSTOP不能忽略
3 一个函数地址，该函数只有一个整型参数。只要该参数声明在调用sigaction之前，sa_handler就
可以设为该函数的名字，当进程接收到信号signo时，就会以signo为参数执行这个函数。也就是说，当进程
收到signo信号时，不管它在执行什么程序，控制立即转向sigaction所设的处理函数。当该函数返回时，
控制返回到进程中断的位置。

    sigset_t sa_mask:
    在执行处理函数sa_handler时，系统会阻塞sa_mask所指定的信号量。但这并不意味着它们被系统忽略了，
    这些信号只不过被系统延迟到处理函数执行完之后再处理。

    int sa_flags:
    用来改变signo信号的行为属性。比如把sa_flags设为SA_RESETHAND,使得在执行完该信号处理函数后，
信号处理函数重新设为SIG_DFL.设置为SA_RESTART的情况：在大多数情况下，如果进程在做系统调用时
收到信号，那么直到系统调用完成之前，信号都不会起作用。然而有些系统调用却是例外，它们可以被
信号中断，例如在慢速设备（终端）上的read,write或open调用。通过设置sa_flags=SA_RESTART可以重新启动
被中断系统调用。

捕获SIGINT信号

sigex.c:

/* sigex----------shows how sigaction works */
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>
#include<stdio.h>

int main(void)
{
    static struct sigaction act;//设置为静态变量，使得系统把结构的各个成员初始化为零

    /*declare catchint,later to be use as the handler */
    void catchint(int);//信号处理函数

    /*set up the action to be taken on receipt of SIGINT */
    act.sa_handler=catchint;

    /* create a full mask */
    sigfillset(&(act.sa_mask));//设置所有的信号，意味着阻塞所有的信号，除了signo参数的信号
    
    /* before sigaction call,SIGINT will 
     * terminate process (default action) */




//未调用信号处理函数之前
    printf("no sigaction call:#1\n");
   sleep(1);
    printf("no sigaction call:#2\n");
    sleep(1);
    printf("no sigaction call:#3\n");
  sleep(1);

    printf("no sigaction call:#4\n");
    sleep(1);
    printf("use sigaction call\n");


//调用信号处理函数
    sigaction(SIGINT,&act,NULL);

    /*on receipt of SIGINT control will be passed
     * to catchint
     */

    printf("sleep call #1\n");
    sleep(1);
    printf("sleep call #2\n");
    sleep(1);
    printf("sleep call #3\n");
    sleep(1);
    printf("sleep call #4\n");
    sleep(1);

    printf("Exiting...\n");
    exit(0);
}

/*trivial function to handler SIGINT */

void catchint(int signo)
{
    printf("\nCATCHINT:signo=%d\n",signo);

    printf("CATCHINT :returning \n\n");
}

运行结果：
//未调用信号处理函数之前被中断，程序简单的终止
jiang@jiang-linux:~/unixprog/2011-3-18$ ./sigex.o
no sigaction call:#1
no sigaction call:#2
no sigaction call:#3
^C

//调用信号处理函数后被中断，控制转入信号处理函数，函数终止后控制还回到程序被中断的那一点上。
jiang@jiang-linux:~/unixprog/2011-3-18$ ./sigex.o
no sigaction call:#1
no sigaction call:#2
no sigaction call:#3
no sigaction call:#4
use sigaction call
sleep call #1
sleep call #2
^C
CATCHINT:signo=2
CATCHINT :returning

sleep call #3
sleep call #4
Exiting...

忽略SIGINT

如果一个进程想忽略中断信号SIGINT，把程序下面的这一行：
act.sa_handler=catchint;
改为
act.sa_handler=SIG_IGN;
执行该语句之后，中断键对该程序无效。

也可以再次打开信息的处理：
act.sa_handler=SIG_DEF;//表示恢复系统定义的默认处理函数
sigaction(SIGINT,&act,NULL);

可以很好的同时忽略几种信号，例如：
act.sa_handler=SIG_IGN;
sigcation(SIGINT,&act,NULL);
sigcation(SIGQUIT,&act,NULL);
同时处理SIGINT和SIGQUIT信号。
对于一个已经忽略了某些信号的进程来说，它将在exec后继续忽略这些信号。所以命令
解释程序可以调用sigcation以确保忽略SIGQUIT和SIGINT信号，然后执行新的程序。

恢复到先前的动作

sigcation可以填充第三个参数ocat，使得用户可以保存并恢复信号之前的状态。如：
#include<signal.h>

static struct sigcation act,oact;

/* save the old action for SIGTERM*/
sigcation(SIGTERM,NULL,&oact);

/*set new action for SIGTERM */
act.sa_handler=SIG_IGN;
sigcation(SIGTERM,&act,NULL);//忽略信号

/* do the work here....*/

/*now restore the old action */
sigcation(SIGTERM,&oact,NULL);

一个完美的退出

假设一个程序使用了临时工作文件，下面这段代码的作用是删除这个文件：
/*exit from program gracefully*/
#include<stdio.h>
#include<stdlib.h>

void g_exit(int s)
{
unlink("tempfile");
fprintf(stderr,"Interrupted---exiting\n"）；
exit(1);
}

可以把这段代码与一个特定的信号联系起来：
extern void g_exit(int s);
.
.
.
static struct sigcation act;
act.sa_handler=g_exit;
sigcation(SIGINT,&act,NULL);
当程序运行时，一旦用户按下中断键，控制就自动从主程序转向g_exit.从而完成清理工作。

发送信号到其他进程中：kill

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<signal.h>

int ntime=0;

int main(void)
{
    pid_t pid,ppid;
    static struct sigaction pact,cact;
    void p_action(int signo);//parent signal action
    void c_action(int signo);//chile signal action

    /*set SIGUSR1 action for parent */
    pact.sa_handler=p_action;
    sigaction(SIGUSR1,&pact,NULL);

    switch(pid=fork())
    {
        case-1://error
            perror("synchor");
            exit(1);
        case 0://child
            /*set action for child*/
            cact.sa_handler=c_action;
            sigaction(SIGUSR1,&cact,NULL);

            /*get parent pid*/
            ppid=getppid();

            for(;;)
            {
                sleep(1);
                kill(ppid,SIGUSR1);
                pause();
            }
        default:/*parent*/
            for(;;)
            {
                pause();
                sleep(1);
                kill(pid,SIGUSR1);
            }
    }
}

void p_action(int sig)
{
    printf("Parent caught signal # %d\n",ntime);
}

void c_action(int sig)
{
    printf("Child caught signal # %d\n",++ntime);
}

结果：

jiang@jiang-linux:~/unixprog/2011-3-19$ gcc synchro.c -o synchro.o;./synchro.o
Parent caught signal # 0
Child caught signal # 1
Parent caught signal # 0
Child caught signal # 2
Parent caught signal # 0
Child caught signal # 3
Parent caught signal # 0
Child caught signal # 4
Parent caught signal # 0
Child caught signal # 5
Parent caught signal # 0
^C
//同时也说明了父进程和子进程有不同的变量，

alarm系统调用

#include<unistd.h>

unsigned int alarm(unsigned int secs);
在alarm调用中，secs给出了定时器超时的时间，当给定时间超时后，进程将收到一个SIGALRM信号，
可以捕获该信号进行处理。

#include<stdio.h>
#include<stdlib.h>
#include<signal.h>

#define    TIMEOUT    5  /*in seconds*/
#define    MAXTRIES    5
#define LINESIZE    100
#define CTRL_G '\007'
#define TRUE 1
#define    FALSE    0

/* used to see if timeout has occured*/
static int time_out;

/* will hold input file */
static char answer[LINESIZE];

char *quickreply(char *prompt)
{
    void catch(int signo);
    int ntries;
    static struct sigaction act,oact;

    /*catch SIGALRM+save previous action */
    act.sa_handler=catch;
    sigaction(SIGALRM,&act,&oact);

    for(ntries=0;ntries<MAXTRIES;ntries++)
    {
      time_out=FALSE;
        printf("\n%s>",prompt);

        /*set alarm clock*/
        alarm(TIMEOUT);

        /*get input file*/
    fgets(answer,100,stdin);

        /*turn off alarm*/
        alarm(0);

        /*if time_out TRUE,then no reple*/
        if(!time_out)
        {
            break;
        }
    }
    /*restore old action*/
    sigaction(SIGALRM,&oact,NULL);
    /*return appropriate value*/
    return (ntries==MAXTRIES?((char *)0):answer);

}

/*executed when SIGALRM received*/
void catch(int signo)
{
    /*set timeout flag*/
    time_out=TRUE;

    /*ring bell*/
    putchar(CTRL_G);
}

int main(void)
{
  char *p="Please input command:";
  char *result;
    result=quickreply(p);
    if(result==NULL)
    {
        printf("input command time out!\n");
        return -1;

    }
    else
    {
        printf("input command successful!\n");
    }

    return 0;
}

结果：
jiang@jiang-linux:~/unixprog/2011-3-19$ ./alarm.o

Please input command:>jiang
input command successful!
jiang@jiang-linux:~/unixprog/2011-3-19$ ./alarm.o

Please input command:>
Please input command:>
Please input command:>
Please input command:>
Please input command:>input command time out!

hai836045106

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Linux信号和信号处理

Linux信号列表名称默认动作说明　　SIGHUP 终止进程终端线路挂断　　SIGINT 终止进程中断进程　　SIGQUIT 建立CORE文件终止进程，并且生成core文件　　SIGILL 建立CORE文件非法指令　　SI
复制链接

扫一扫