Chinaunix首页 | 论坛 | 博客
  • 博客访问: 6036115
  • 博文数量: 579
  • 博客积分: 1548
  • 博客等级: 上尉
  • 技术积分: 16632
  • 用 户 组: 普通用户
  • 注册时间: 2012-12-12 15:29
个人简介

http://www.csdn.net/ http://www.arm.com/zh/ https://www.kernel.org/ http://www.linuxpk.com/ http://www.51develop.net/ http://linux.chinaitlab.com/ http://www.embeddedlinux.org.cn http://bbs.pediy.com/

文章分类

全部博文(579)

文章存档

2018年(18)

2015年(91)

2014年(159)

2013年(231)

2012年(80)

分类: LINUX

2014-10-14 10:19:22

信号  ( 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,信号处理函数名:使用该函数处理.


实例 --- 小测试:

  1. #include   
  2. #include   
  3. #include   
  4.   
  5. void my_func(int sign_no)  
  6. {  
  7.     if(sign_no==SIGINT)  
  8.         printf("I have get SIGINT\n");  
  9.     else if(sign_no==SIGQUIT)  
  10.         printf("I have get SIGQUIT\n");  
  11. }  
  12. int main()  
  13. {  
  14.     printf("Waiting for signal SIGINT or SIGQUIT \n ");  
  15.       
  16.     /*注册信号处理函数*/  
  17.     signal(SIGINT, my_func);  
  18.     signal(SIGQUIT, my_func);  
  19.       
  20.     pause();  
  21.     exit(0);  
  22. }  


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


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

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

SIGUSR1 :

kill  -usr1 PID .


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


驱动异步通知应用程序.


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


  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5. #include   
  6. #include   
  7. #include   
  8. #include   
  9. #include   
  10.   
  11. int fd;        //全局变量;  
  12.   
  13. /* 
  14.  
  15. 应用程序 不会主动 的去读键值; 
  16. my_signal_fun 什么时候被调用呢? 
  17.  
  18. 在驱动程序的中断处理函数 static irqreturn_t buttons_irq(int irq, void *dev_id) 中, 
  19. 有信号发送函数 kill_fasync (&button_async, SIGIO, POLL_IN) ; 
  20. 当有按键按下时候,就会给应用程序发送一个信号; 
  21. 这个信号就会触发 应用程序 调用信号处理函数 signal(SIGIO, my_signal_fun);  
  22. 信号处理函数指向了 void my_signal_fun(int signum) 函数; 
  23.  
  24. */  
  25.   
  26. void my_signal_fun(int signum)  
  27. {  
  28.     unsigned char key_val;  
  29.     read(fd, &key_val, 1);    //读取键值;  
  30.     printf("key_val: 0x%x\n", key_val);    
  31. }  
  32.   
  33. int main(int argc, char **argv)  
  34. {  
  35.     int Oflags;  
  36.   
  37.     signal(SIGIO, my_signal_fun);   /* 应用程序注册信号处理函数 */  
  38.                     //  SIGIO 表示 Io 有数据可供读取;  
  39.       
  40.     fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);  
  41.     if (fd < 0)  
  42.     {  
  43.         printf("can't open!\n");  
  44.         return -1;  
  45.     }  
  46.                     /* 驱动程序发信号 */  
  47.     fcntl(fd, F_SETOWN, getpid());   /* 信号发给谁,是通过这段程序告诉内核的 */  
  48.                     /* getpid() 获取应用程序PID */  
  49.       
  50.                     /* 改变 Oflags 为异步通知 FASYNC*/  
  51.     Oflags = fcntl(fd, F_GETFL);    //读取 Oflags;  
  52.                     //改变 Oflags;  
  53.     fcntl(fd, F_SETFL, Oflags | FASYNC);  //这样,驱动程序里面的 .fasync  =  sixth_drv_fasync, 函数指针就会被调用;  
  54.                          // 改变 FASYNC标志, 最终调用到驱动的 fasync -> fasync_helper   
  55.                         //来初始化/或/释放 fasync_struct;  
  56.     while (1)  
  57.     {  
  58.         sleep(1000);  
  59.     }  
  60.       
  61.     return 0;  
  62. }  


2,谁发信号:驱动程序:


3,发给谁:应用程序  ;  应用程序要告诉驱动程序 其PID:


4,驱动程序怎么发信号:调用函数:kill_fasync :



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


  1. 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)  能用的到;


  1. static int sixth_drv_fasync (int fd, struct file *filp, int on)  
  2. {  
  3.     printk("driver: sixth_drv_fasync\n");  
  4.     return fasync_helper (fd, filp, on, &button_async);  /* 初始化结构体 */  
  5. }  
  6.   
  7. static struct file_operations sencod_drv_fops = {  
  8.     .owner   =  THIS_MODULE,    /* 这是一个宏,推向编译模块时自动创建的__this_module变量 */  
  9.     .open    =  sixth_drv_open,       
  10.     .read    =  sixth_drv_read,      
  11.     .release =  sixth_drv_close,  
  12.     .poll    =  sixth_drv_poll,  
  13.     .fasync  =  sixth_drv_fasync,   /****************************  FASYNC  ********************************/  
  14. };  



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

kill_fasync 需要三个参数:

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

第二个:  发什么,发  SIGIO 这个信号,SIGIO 表示 Io 有数据可供读取;

第三个:POLL_IN , 原因, 表示有数据在等待读取;


  1. static irqreturn_t buttons_irq(int irq, void *dev_id)  
  2. {  
  3.     struct pin_desc * pindesc = (struct pin_desc *)dev_id;  
  4.     unsigned int pinval;  
  5.       
  6.     pinval = s3c2410_gpio_getpin(pindesc->pin);  
  7.   
  8.     if (pinval)  
  9.     {  
  10.         /* 松开 */  
  11.         key_val = 0x80 | pindesc->key_val;  
  12.     }  
  13.     else  
  14.     {  
  15.         /* 按下 */  
  16.         key_val = pindesc->key_val;  
  17.     }  
  18.   
  19.         ev_press = 1;                  /* 表示中断发生了 */  
  20.         wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */  
  21.       
  22.     kill_fasync (&button_async, SIGIO, POLL_IN);                      /********  kill_fasync 发送信号  *********/  
  23.       
  24.     return IRQ_RETVAL(IRQ_HANDLED);  
  25. }  



总结:

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

1,支持 F_SETOWN 命令 :

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

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

2,支持 F_SETFL 命令的处理:

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

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

3,调用 kill_fasync () 函数:

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



参考引用:
1,http://blog.csdn.net/yikai2009/article/details/8643818
阅读(1961) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~