signal(SIGIO，XXXX)实例

信号  ( signal ) 机制是 UNIX 系统中最为古老的进程间通信机制，很多条件可以产生一个信号.

信号的产生：

          1，当用户按下某些按键时，产生信号.

          2，硬件异常产生信号：除数为 0 ，无效的存储访问等等.这些情况通常由硬件检测到，将其通知内核，

                然后内核产生适当的信号通知进程，例如，内核对正访问一个无效存储区的进程产生一个 SIGSEGV 信号.

          3，进程用 kill 函数 将信号发送给另一个进程.

          4，用户可用 kill 命令将信号发送给其他进程.

信号类型 - SIGHUP SIGINT  SIGKILL  SIGTERM  SIGCHLD  SIGSTOP：

          下面是几种常见的信号：
          SIGHUP ：从终端上发出的结束信号.

          SIGINT   ：来自键盘的中断信号 ( ctrl + c ) .

          SIGKILL ：该信号结束接收信号的进程 .

          SIGTERM：kill 命令发出 的信号.

          SIGCHLD：标识子进程停止或结束的信号.

          SIGSTOP：来自键盘 ( ctrl + z ) 或调试程序的停止执行信号.

          

信号处理：

          当某信号出现时，将按照下列三种方式中的一种进行处理.

          1，忽略此信号：

                    大多数信号都按照这种方式进行处理，但有两种信号却决不能被忽略.

                    它们是：SIGKILL 和 SIGSTOP . 这两种信号不能被忽略的原因是：它们向

                    超级用户提供了一种终止或停止进程的方法.

          2，执行用户希望的动作：

                    通知内核在某种信号发生时，调用一个用户函数，在用户函数中，执行用户希望的处理.

          3，执行系统默认动作：

                    对大多数信号的系统默认动作是终止该进程.

当系统捕捉到某个信号时，可以忽略该信号或是使用指定的处理函数来处理该信号，或者使用系统默认的方式.

信号处理的主要方法有两种，一种是使用简单的 signal 函数，另一个是使用信号集函数.

信号发送  -  kill 和 raise ：

          信号发送的主要函数有 kill 和 raise .

         区别：

          kill 既可以向自身发送信号，也可以向其他进程发送信号，与 kill 函数不同的是，raise 函数是向   自身   发送信号.

          函数：

                    #include < sys/types.h >

                    #include < signal.h >

                    int kill ( pid_t  pai, int signo )


                   int  raise ( int  signo )

kill 的 pid 参数有四种不同情况：

          1， pid  > 0

                    将信号发送给进程 ID 为 pid 的进程.

          2，pid = 0

                    将信号发送给同组的进程.

          3，pid < 0

                    将信号发送给其进程组 ID 等于 pid 绝对值的进程.

          4，pid = -1

                    将信号发送给所有进程.

Alarm信号闹钟  unsigned int alarm：

          使用 alarm 函数可以设置一个时间值 ( 闹钟时间 )，当所设置的时间到了时，产生 SIGALRM 信号，

          如果不能扑捉此信号，则默认动作是终止该进程.

          函数： unsigned int alarm  ( unsigned int seconds )

                              经过了指定的 seconds 秒后会产生信号 SIGALRM.

         每个进程只能有一个闹钟时间，如果在调用 alarm 时，以前已为该进程设置过闹钟时间，而且它还没有

          超时，以前等级的闹钟时间则被新值替换.

          如果有以前登记的尚未超时的闹钟时间，而这次 seconds 值是0 ，则表示取消以前的闹钟.

pause 函数  int   pause ( void )：

          pause 函数使调用进程挂起直至捕捉到一个信号.

          函数： int   pause ( void )

          只有执行了一个信号处理函数后，挂起才结束.

signal 函数  void ( *signal ( int signo  ,  
void ( *func ) ( int ) ) ) ( int )：

          #include < signal.h >

          void ( *signal ( int signo  ,   void ( *func ) ( int ) ) )
( int )

          如何理解：

          typedef  void  ( *sighandler_t ) ( int )

          sighandler_t  signal ( int  signum , sighandler_t  handler )

          Func 可能的值是：

          1，SIG_IGN  ：忽略此信号.

          2，SIG_DFL ：按照系统默认方式处理.

          3，信号处理函数名：使用该函数处理.

实例 --- 小测试：

[cpp] view
plain copy

#include <signal.h>  

#include <stdio.h>  

#include <stdlib.h>  

  

void my_func(int sign_no)  

{  

    if(sign_no==SIGINT)  

        printf("I have get SIGINT\n");  

    else if(sign_no==SIGQUIT)  

        printf("I have get SIGQUIT\n");  

}  

int main()  

{  

    printf("Waiting for signal SIGINT or SIGQUIT \n ");  

      

    /*注册信号处理函数*/  

    signal(SIGINT, my_func);  

    signal(SIGQUIT, my_func);  

      

    pause();  

    exit(0);  

}  

测试方法：在终端下将该进程运行起来，然后 进程pause 了，我们再用 kill 给进程发送信号，

在另一终端下ps aux  可以找到运行进程的进程号.

然后kill  -s  SIGQUIT  +进程号  我们可以在前一个终端下看到 I have get SIGQUIT.

SIGUSR1 ：

kill  -usr1 PID .

实例 --- 按键驱动异步通知：

驱动异步通知应用程序.

1，应用程序 注册信号处理函数  signal ( SIGIO ,  my_signal_fun ) ：

[cpp] view
plain copy

#include <sys/types.h>  

#include <sys/stat.h>  

#include <fcntl.h>  

#include <stdio.h>  

#include <poll.h>  

#include <signal.h>  

#include <sys/types.h>  

#include <unistd.h>  

#include <fcntl.h>  

  

int fd;        //全局变量；  

  

/* 

 

应用程序 不会主动 的去读键值； 

my_signal_fun 什么时候被调用呢? 

 

在驱动程序的中断处理函数 static irqreturn_t buttons_irq(int irq, void *dev_id) 中， 

有信号发送函数 kill_fasync (&button_async, SIGIO, POLL_IN) ； 

当有按键按下时候，就会给应用程序发送一个信号; 

这个信号就会触发 应用程序 调用信号处理函数 signal(SIGIO, my_signal_fun);  

信号处理函数指向了 void my_signal_fun(int signum) 函数； 

 

*/  

  

void my_signal_fun(int signum)  

{  

    unsigned char key_val;  

    read(fd, &key_val, 1);    //读取键值；  

    printf("key_val: 0x%x\n", key_val);    

}  

  

int main(int argc, char **argv)  

{  

    int Oflags;  

  

    signal(SIGIO, my_signal_fun);   /* 应用程序注册信号处理函数 */  

                    //  SIGIO 表示 Io 有数据可供读取；  

      

    fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);  

    if (fd < 0)  

    {  

        printf("can't open!\n");  

        return -1;  

    }  

                    /* 驱动程序发信号 */  

    fcntl(fd, F_SETOWN, getpid());   /* 信号发给谁，是通过这段程序告诉内核的 */  

                    /* getpid() 获取应用程序PID */  

      

                    /* 改变 Oflags 为异步通知 FASYNC*/  

    Oflags = fcntl(fd, F_GETFL);    //读取 Oflags；  

                    //改变 Oflags；  

    fcntl(fd, F_SETFL, Oflags | FASYNC);  //这样，驱动程序里面的 .fasync  =  sixth_drv_fasync, 函数指针就会被调用；  

                         // 改变 FASYNC标志， 最终调用到驱动的 fasync -> fasync_helper   

                        //来初始化/或/释放 fasync_struct；  

    while (1)  

    {  

        sleep(1000);  

    }  

      

    return 0;  

}  

2，谁发信号：驱动程序：

3，发给谁：应用程序  ；  应用程序要告诉驱动程序 其PID：

4，驱动程序怎么发信号：调用函数：kill_fasync ：

在驱动程序开头 定义结构 fasync_struct ：

[cpp] view
plain copy

static struct fasync_struct *button_async;  

初始化 fasync_struct 结构体 使用 fasync_helper ：

在应用程序调用 .fasync  =  sixth_drv_fasync, 时候，调用 fasync_helper 函数 来初始化  struct fasync_struct *button_async  结构体；

struct fasync_struct *button_async  这个结构在 发信号的时候 kill_fasync (&button_async, SIGIO, POLL_IN)  能用的到；

[cpp] view
plain copy

static int sixth_drv_fasync (int fd, struct file *filp, int on)  

{  

    printk("driver: sixth_drv_fasync\n");  

    return fasync_helper (fd, filp, on, &button_async);  /* 初始化结构体 */  

}  

  

static struct file_operations sencod_drv_fops = {  

    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */  

    .open    =  sixth_drv_open,       

    .read    =  sixth_drv_read,      

    .release =  sixth_drv_close,  

    .poll    =  sixth_drv_poll,  

    .fasync  =  sixth_drv_fasync,   /****************************  FASYNC  ********************************/  

};  

在按键驱动 服务程序 中发送信号 kill_fasync ：

kill_fasync 需要三个参数：

第一个：&button_async 包含进程 ID ， 也就是 发给谁，

第二个：  发什么，发  SIGIO 这个信号，SIGIO 表示 Io 有数据可供读取；

第三个：POLL_IN ， 原因， 表示有数据在等待读取；

[cpp] view
plain copy

static irqreturn_t buttons_irq(int irq, void *dev_id)  

{  

    struct pin_desc * pindesc = (struct pin_desc *)dev_id;  

    unsigned int pinval;  

      

    pinval = s3c2410_gpio_getpin(pindesc->pin);  

  

    if (pinval)  

    {  

        /* 松开 */  

        key_val = 0x80 | pindesc->key_val;  

    }  

    else  

    {  

        /* 按下 */  

        key_val = pindesc->key_val;  

    }  

  

        ev_press = 1;                  /* 表示中断发生了 */  

        wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */  

      

    kill_fasync (&button_async, SIGIO, POLL_IN);                      /********  kill_fasync 发送信号  *********/  

      

    return IRQ_RETVAL(IRQ_HANDLED);  

}  

总结：

为了使得设备支持异步通知机制，驱动程序最终涉及以下 3 项工作：

1，支持 F_SETOWN 命令 ：

能在这个控制命令处理中设置 filp->f_owner 为对应进程 ID；

此项操作由内核完成，设备驱动无须处理；

2，支持 F_SETFL 命令的处理：

当 FASYNC 标志改变的时候，驱动操作中的 fasync () 函数将得以执行；

驱动程序实现 fasync ()  函数；

3，调用 kill_fasync () 函数：

在设备资源可获得时， 调用 kill_fasync () 函数激发相应的信号.