【genius_platform软件平台开发】第九十七讲：linux设备驱动中信号（signal函数）的异步通知机制

1. 信号的异步通知

• 意思是:一旦设备就绪,则主动通知应用程序，这样应用程序根本就不需要查询设备状态，这一点非常类似于硬件上“中断”的概念，比较准确的称谓是“信号驱动的异步I/O”。信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上,进程也不知道信号到底什么时候到达。
• 

2. 信号的特点

• 一个进程收到一个信号与处理器收到一个中断请求可以说是一样的（软中断）。
• 信号是异步的，一个进程不必通过任何操作来等待信号的到达。
• 信号是内核定义的，当相应的事件产生时，内核发射相应的信号。

3. 信号头文件和函数

3.1 头文件：

#include <signal.h>

3.2 signal()函数：

typedef void (*__sighandler_t) (int);
__sighandler_t signal (int __sig, __sighandler_t __handler);

• 第一个参数是要捕捉的信号（linux下查看信号：kill -l，9号SIGKILL信号不能被捕捉 ）
• 第二个参数表示我们要对信号进行的处理方式。

4. 信号的处理

进程可以通过3种方式来响应一个信号

4.1 忽略信号（SIG_IGN）

• 即对信号不做任何处理，其中，有两个信号不能被忽略：SIGKLL-9和SIGSTOP-19。接收到了，但是什么都不做。

#include <stdio.h>
#include <signal.h>
 
int main()
{
	// 忽略SIGINT信号
    signal(SIGINT, SIG_IGN);
    while(1)
    {
        printf("hello\n");
        sleep(1);
    }
    return 0;
}

• 对SIGINT信号进行忽略，所以按下Ctrl+c后进程不会停止，若要停止，可用Ctrl+(SIGQUIT);

3.2 默认操作

• 对每种信号都规定了默认操作，如 kill -l 查看到的命令

#include <stdio.h>
#include <signal.h>
 
int main()
{
	//SIGINT默认操作
    signal(SIGINT, SIG_DFL);
    while(1)
    {
        printf("hello\n");
        sleep(1);
    }
    return 0;
}

• 对SIGINT信号进行默认动作处理，当按下Ctrl+c后进程会终止。

3.3 捕捉信号

• 定义信号处理函数，当信号发生时，执行相应的处理函数。提供一个信号处理函数，要求内核在处理该信号时切换到用户态执行这个处理函数，这个方式称为捕捉(catch)一个信号。

3.3.1 信号注册函数signal()

#include <signal.h>
#include <stdio.h> 
//typedef void (*sighandler_t)(int);//定义sighandler_t为void *(int)无返回值的函数指针类型
//sighandler_t signal(int signum, sighandler_t handler);//第二个参数是函数指针类型，目的是传入函数地址。函数名相当于指针，存放着指向函数空间的地址。
void handler(int signum)
{
        printf("signum is:%d\n",signum);
        printf("don't quit\n");
}
 
int main()
{
        signal(SIGINT,handler);//信号处理函数的注册，当Ctrl+C信号出现，内核调用handler函数处理 ，也可以用宏（SIG_IGN）忽略        
        while(1);
 
        return 0;
}

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>
 
void handler_sign(int sign)
{
    printf("catch a signal:%d\n", sign);
}
 
int main()
{
	//SIGINT定义信号处理函数handler_sign
    signal(SIGINT, handler_sign);
    while(1)
    {
        printf("hello\n");
        sleep(1);
    }
    return 0;
}

• 执行程序时，按下Ctrl+c后，接收到信号，执行handler_sign函数，打印信息。

3.3.2 kill函数和system函数发送信号

• 通过kill发送信号给其他进程：

#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
 
int main(int argc,int **argv[])
{
        int signum;
        int pid;
        char cmd[128] ={0};
 
        signum = atoi(argv[1]);//字符转换成整形
        pid = atoi(argv[2]);
 
        printf("signum:%d,pid:%d\n",signum,pid);
 
		/*发送指令*/
        /*方法一*/
        /*
        kill(pid,signum);//执行命令
        printf("send kill\n");      
        */
        /*方法二*/
        sprintf(cmd,"kill -%d %d",signum,pid);//构建字符串
        system(cmd);//创建子进程执行
        printf("system work\n");
        return 0;
}

3.3.3 信号注册函数2 sigaction()

• 信号安装函数sigaction(int signum,const struct sigaction *act,struct sigaction *oldact)的第二个参数是一个指向sigaction结构的指针（结构体名称与函数名一样，千万别弄混淆了）。在结构sigaction的实例中，指定了对特定信号的处理，信号所传递的信息，信号处理函数执行过程中应屏蔽掉哪些函数等。当然，此指针也可以为NULL，进程会以默认方式处理信号。以下就简单介绍一下sigaction结构以及一般的用法。

• 对于内核头文件而言，struct sigaction 结构体定义在kernel/include/asm/signal.h,此头文件又被kernel/include/linux/signal.h包含。

• 对于用户空间的头文件而言，struct sigaction定义在 /usr/include/bits/sigaction.h,此头文件又被/usr/include/signal.h包含，所以应用程序中如果用到此结构，只要#include <signal.h>即可。注意内核中的定义和应用程序中的定义是不一样的，内核空间的sigaction结构只支持函数类型为__sighandler_t的信号处理函数，不能处理信号传递的额外信息。具体定义如下：

struct sigaction
{
         __sighandler_t sa_handler;
        unsigned long sa_flags;
        void (*sa_restorer)(void);
        sigset_t sa_mask;   /* mask last for extensibility */
};

sa_handler的原型是一个参数为int，返回类型为void的函数指针。参数即为信号值，所以信号不能传递除信号值之外的任何信息;
sa_sigaction的原型是一个带三个参数，类型分别为int，struct siginfo *，void *,返回类型为void的函数指针。第一个参数为信号值;第二个参数是一个指向struct siginfo结构的指针，此结构中包含信号携带的数据值，第三个参数没有使用。
sa_mask指定在信号处理程序执行过程中，哪些信号应当被阻塞。默认当前信号本身被阻塞。
sa_flags包含了许多标志位，比较重要的一个是SA_SIGINFO，当设定了该标志位时，表示信号附带的参数可以传递到信号处理函数中。即使sa_sigaction指定信号处理函数，如果不设置SA_SIGINFO，信号处理函数同样不能得到信号传递过来的数据，在信号处理函数中对这些信息的访问都将导致段错误。

#include <signal.h>
void sig_handler_with_arg(int sig,siginfo_t *sig_info,void *unused){……}
    
int main(int argc,char **argv)
{
         struct sigaction sig_act;
         ……
         sigemptyset(&sig_act.sa_mask);
         sig_act.sa_sigaction=sig_handler_with_arg;
         sig_act.sa_flags=SA_SIGINFO;

          ……
}

• 如果你的应用程序只需要接收信号，而不需要接收额外信息，那你需要的设置的是sa_handler,而不是sa_sigaction,你的程序可能类似下面的代码：

#include <signal.h>
 void sig_handler(int sig){……}

 int main(int argc,char **argv)
 {
          struct sigaction sig_act;
          ……
          sigemptyset(&sig_act.sa_mask);
          sig_act.sa_handler=sig_handler;
          sig_act.sa_flags=0; 
           ……
  }

• 可以携带信息，发信号用sigqueque()，注册信号函数用sigaction()。
• 注册信号处理函数：

int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
 
struct sigaction
 {
   void       (*sa_handler)(int); //信号处理程序
   void       (*sa_sigaction)(int, siginfo_t *, void *); //信号处理程序，能够接受额外数据和sigqueue配合使用
   sigset_t   sa_mask;//阻塞关键字的信号集，在调用捕捉函数之前，把信号添加到信号阻塞字，信号捕捉函数返回之前恢复为原先的值。
   int        sa_flags;//SA_SIGINFO表示能够接受数据
 };
 

• 关于void(sa_sigaction)(int, siginfo_t, void );处理函数来说还需要有一些说明。void 是接收到信号所携带的额外数据；而struct siginfo这个结构体主要适用于记录接收信号的一些相关信息。

 siginfo_t {
               int      si_signo;    /* Signal number */
               int      si_errno;    /* An errno value */
               int      si_code;     /* Signal code */
               int      si_trapno;   /* Trap number that caused
                                        hardware-generated signal
                                        (unused on most architectures) */
               pid_t    si_pid;      /* Sending process ID */
               uid_t    si_uid;      /* Real user ID of sending process */
               int      si_status;   /* Exit value or signal */
               clock_t  si_utime;    /* User time consumed */
               clock_t  si_stime;    /* System time consumed */
               sigval_t si_value;    /* Signal value */
               int      si_int;      /* POSIX.1b signal */
               void    *si_ptr;      /* POSIX.1b signal */
               int      si_overrun;  /* Timer overrun count; POSIX.1b timers */
               int      si_timerid;  /* Timer ID; POSIX.1b timers */
               void    *si_addr;     /* Memory location which caused fault */
               int      si_band;     /* Band event */
               int      si_fd;       /* File descriptor */
}

发送信号，并携带信息

int sigqueue(pid_t pid, int sig, const union sigval value);
union sigval {
   int   sival_int;
   void *sival_ptr;
 };

例程文章来源地址https://www.toymoban.com/news/detail-474388.html

/*信号处理函数注册*/
 
#include <signal.h>
#include <stdio.h>
 
 //int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
 
/* struct sigaction {
               void     (*sa_handler)(int);
               void     (*sa_sigaction)(int, siginfo_t *, void *);//与上一个2选1，此可携带信息
               sigset_t   sa_mask;
               int        sa_flags;
               void     (*sa_restorer)(void);
};*/
 
void handle(int signum, siginfo_t *info, void *content)
{
        printf("signum:%d\n",signum);
        if(content != NULL)
        {
                printf("si_pid:%d\n",info->si_pid);
                printf("si_int:%d\n",info->si_int);
                printf("sival_int: %d\n",info->si_value.sival_int);//读取结构体里面的由sigqueue函数发送的联>
合体si_value里面的数据
        }
}
 
int main()
{
        printf("pid:%d\n",getpid());
        struct sigaction act;
        act.sa_sigaction = handle;//绑定操作函数
        act.sa_flags = SA_SIGINFO;//表示能接受数据
 
        sigaction(SIGUSR1, &act, NULL);//注册信号函数，接受该信号后采取结构体act里面的操作，第三个参数做数据备
份，不用则NULL      
        while(1);
        return 0;
}

/*信号发送*/
 
#include <signal.h>
#include <stdio.h>
 
//int sigqueue(pid_t pid, int sig, const union sigval value);
/* union sigval {
               int   sival_int;
               void *sival_ptr;
           };*/
 
int main(int argc,int **argv)
{
        int pid;
        int signum;
        signum = atoi(argv[1]);
        pid = atoi(argv[2]);
 
        union sigval value;
        value.sival_int = 10;
 
        sigqueue(pid, signum, value);
        printf("pid:%d,done\n",getpid());
        return 0;
}
 

5. Linux下信号的定义：

• 前31个为传统UNIX支持的信号，是不可靠信号（非实时的），后33个是后来扩充的，是可靠信号（实时信号）。不可靠信号和可靠信号的区别在于前者不支持排队，可能会造成信号丢失，而后者不会。

• pl2ps_intr.h

/*
 * @Author: fliu
 */

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

#define FRAME_SIZE ((648*360*2 + 1024)*5)
#define DEVICE_NAME "/dev/pl_irq_drv"

void init_env(int fd, __sighandler_t handler, pid_t pid);

• pl2ps_intr.c

 /*
 * @Author: fliu
 */


#include "pl2ps_intr.h"

void init_env(int fd, __sighandler_t handler, pid_t pid)
{
		int flags = 0;
        //https://blog.csdn.net/xiadeliang1111/article/details/84348006
        //https://blog.csdn.net/qq_41936794/article/details/105273059
        // 实现异步通知机制,用户程序涉及2项工作，指定一个进程作为文件的“属主（owner）”.
        // 当应用程序使用fcntl系统调用执行F_SETOWN命令时,属主进程的进程ID号就被保存在filp->f_owner中.
        // 这一步是必需的,目的是告诉内核将信号发给谁,也就是发给哪个进程.
        // 然后为了真正启动异步通知机制,用户程序还必须在设备中设置FASYNC标志,这通过fcntl的F_SETFL命令完成的,
        // 文件打开时,FASYNC标志被默认为是清除的.,每当FASYNC标志改变时,驱动程序中的fasync()函数将得以执行。
        // 执行完这两个步骤之后,内核就可以在新数据到达时通过调用kill_fasync()函数请求发送一个SIGIO信号给应用层,
        // 该信号被发送到存放在filp->f_owner中的进程(如果是负值就是进程组)
		signal(SIGIO, handler);

		fcntl(fd, F_SETOWN, pid);		
		flags = fcntl(fd, F_GETFL);		
		fcntl(fd, F_SETFL, flags | FASYNC);	
}

• demo_app.c

/*
 * @Author: your name
 */

#include "pl2ps_intr.h"

static int fd = 0;	

static void sigio_signal_func(int signum)
{
	int err = 0;
	char buf[FRAME_SIZE + 1];
	FILE* fp = NULL;

	printf("-------------in void sigio_signal_func. \n");

#if 1

	err = read(fd, buf, FRAME_SIZE);

	if(err < 0) {
		printf("read device error! \n");
	} else {
		printf("sigio signal! \n");
	}

#endif

}

int main(int argc, char *argv[])
{
	int flags = 0;
	char *filename;

	if (argc != 2) {

		printf("Error Usage!\r\n");
		return -1;

	}
	
	filename = argv[1];
	fd = open(filename, O_RDWR);

	if (fd < 0) {
		printf("Can't open file %s\n", filename);
		return -1;
	}

	init_env(fd, sigio_signal_func, getpid());

	while(1) {

		sleep(2);

	}

	close(fd);

	return 0;
}

到了这里，关于【genius_platform软件平台开发】第九十七讲：linux设备驱动中信号（signal函数）的异步通知机制的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！