别人的经验,我们的阶梯!
大家好,我是道哥,今天我为大伙儿解说的技术知识点是:【中断程序如何发送信号给应用层】。
最近分享的几篇文章都比较基础,关于字符类设备的驱动程序,以及中断处理程序。
也许在现代的项目是用不到这样的技术,但是万丈高楼平地起。
只有明白了这些最基础的知识点之后,再去看那些进化出来的高级玩意,才会有一步一个脚印的获得感。
如果缺少了这些基础的环节,很多深层次的东西,学起来就有点空中楼阁的感觉。
就好比研究Linux内核,如果一上来就从Linux 4.x/5.x内核版本开始研究,可以看到很多“历史遗留”代码。
这些代码就见证着Linux一步一步的发展历史,甚至有些人还会专门去研究 Linux 0.11 版本的内核源码,因为很多基本思想都是一样的。
今天这篇文章,主要还是以代码实例为主,把之前的两个知识点结合起来:
在中断处理函数中,发送信号给应用层,以此来通知应用层处理响应的中断业务。
驱动程序
示例代码全貌
所有的操作都是在 ~/tmp/linux-4.15/drivers 目录下完成的。
首先创建驱动模块目录:
- $ cd ~/tmp/linux-4.15/drivers
- $ mkdir my_driver_interrupt_signal
- $ touch my_driver_interrupt_signal.c
文件内容如下:
- #include
- #include
- #include
- #include
- #include
-
- #include
- #include
- #include
- #include
- #include
- #include
-
- // 中断号
- #define IRQ_NUM 1
-
- // 定义驱动程序的 ID,在中断处理函数中用来判断是否需要处理
- #define IRQ_DRIVER_ID 1234
-
- // 设备名称
- #define MYDEV_NAME "mydev"
-
- // 驱动程序数据结构
- struct myirq
- {
- int devid;
- };
-
- struct myirq mydev ={ IRQ_DRIVER_ID };
-
- #define KBD_DATA_REG 0x60
- #define KBD_STATUS_REG 0x64
- #define KBD_SCANCODE_MASK 0x7f
- #define KBD_STATUS_MASK 0x80
-
- // 设备类
- static struct class *my_class;
-
- // 用来保存设备
- struct cdev my_cdev;
-
- // 用来保存设备号
- int mydev_major = 0;
- int mydev_minor = 0;
-
- // 用来保存向谁发送信号,应用程序通过 ioctl 把自己的进程 ID 设置进来。
- static int g_pid = 0;
-
- // 用来发送信号给应用程序
- static void send_signal(int sig_no)
- {
- int ret;
- struct siginfo info;
- struct task_struct *my_task = NULL;
- if (0 == g_pid)
- {
- // 说明应用程序没有设置自己的 PID
- printk("pid[%d] is not valid! \n", g_pid);
- return;
- }
-
- printk("send signal %d to pid %d \n", sig_no, g_pid);
-
- // 构造信号结构体
- memset(&info, 0, sizeof(struct siginfo));
- info.si_signo = sig_no;
- info.si_errno = 100;
- info.si_code = 200;
-
- // 获取自己的任务信息,使用的是 RCU 锁
- rcu_read_lock();
- my_task = pid_task(find_vpid(g_pid), PIDTYPE_PID);
- rcu_read_unlock();
-
- if (my_task == NULL)
- {
- printk("get pid_task failed! \n");
- return;
- }
-
- // 发送信号
- ret = send_sig_info(sig_no, &info, my_task);
- if (ret < 0)
- {
- printk("send signal failed! \n");
- }
- }
-
- //中断处理函数
- static irqreturn_t myirq_handler(int irq, void * dev)
- {
- struct myirq mydev;
- unsigned char key_code;
- mydev = *(struct myirq*)dev;
-
- // 检查设备 id,只有当相等的时候才需要处理
- if (IRQ_DRIVER_ID == mydev.devid)
- {
- // 读取键盘扫描码
- key_code = inb(KBD_DATA_REG);
-
- if (key_code == 0x01)
- {
- printk("EXC key is pressed! \n");
- send_signal(SIGUSR1);
- }
- }
-
- return IRQ_HANDLED;
- }
-
- // 驱动模块初始化函数
- static void myirq_init(void)
- {
- printk("myirq_init is called. \n");
-
- // 注册中断处理函数
- if(request_irq(IRQ_NUM, myirq_handler, IRQF_SHARED, MYDEV_NAME, &mydev)!=0)
- {
- printk("register irq[%d] handler failed. \n", IRQ_NUM);
- return -1;
- }
-
- printk("register irq[%d] handler success. \n", IRQ_NUM);
- }
-
- // 当应用程序打开设备的时候被调用
- static int mydev_open(struct inode *inode, struct file *file)
- {
-
- printk("mydev_open is called. \n");
- return 0;
- }
-
- static long mydev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
- {
- void __user *pArg;
- printk("mydev_ioctl is called. cmd = %d \n", cmd);
- if (100 == cmd)
- {
- // 说明应用程序设置进程的 PID
- pArg = (void *)arg;
- if (!access_ok(VERIFY_READ, pArg, sizeof(int)))
- {
- printk("access failed! \n");
- return -EACCES;
- }
-
- // 把用户空间的数据复制到内核空间
- if (copy_from_user(&g_pid, pArg, sizeof(int)))
- {
- printk("copy_from_user failed! \n");
- return -EFAULT;
- }
- }
-
- return 0;
- }
-
- static const struct file_operations mydev_ops={
- .owner = THIS_MODULE,
- .open = mydev_open,
- .unlocked_ioctl = mydev_ioctl
- };
-
- static int __init mydev_driver_init(void)
- {
- int devno;
- dev_t num_dev;
-
- printk("mydev_driver_init is called. \n");
-
- // 注册中断处理函数
- if(request_irq(IRQ_NUM, myirq_handler, IRQF_SHARED, MYDEV_NAME, &mydev)!=0)
- {
- printk("register irq[%d] handler failed. \n", IRQ_NUM);
- return -1;
- }
-
- // 动态申请设备号(严谨点的话,应该检查函数返回值)
- alloc_chrdev_region(&num_dev, mydev_minor, 1, MYDEV_NAME);
-
- // 获取主设备号
- mydev_major = MAJOR(num_dev);
- printk("mydev_major = %d. \n", mydev_major);
-
- // 创建设备类
- my_class = class_create(THIS_MODULE, MYDEV_NAME);
-
- // 创建设备节点
- devno = MKDEV(mydev_major, mydev_minor);
-
- // 初始化cdev结构
- cdev_init(&my_cdev, &mydev_ops);
-
- // 注册字符设备
- cdev_add(&my_cdev, devno, 1);
-
- // 创建设备节点
- device_create(my_class, NULL, devno, NULL, MYDEV_NAME);
-
- return 0;
- }
-
- static void __exit mydev_driver_exit(void)
- {
- printk("mydev_driver_exit is called. \n");
-
- // 删除设备节点
- cdev_del(&my_cdev);
- device_destroy(my_class, MKDEV(mydev_major, mydev_minor));
-
- // 释放设备类
- class_destroy(my_class);
-
- // 注销设备号
- unregister_chrdev_region(MKDEV(mydev_major, mydev_minor), 1);
-
- // 注销中断处理函数
- free_irq(IRQ_NUM, &mydev);
- }
-
- MODULE_LICENSE("GPL");
- module_init(mydev_driver_init);
- module_exit(mydev_driver_exit);
以上代码主要做了两件事情:
- 注册中断号 1 的处理函数:myirq_handler();
- 创建设备节点 /dev/mydev;
这里的中断号1,是键盘中断。
因为它是共享的中断,因此当键盘被按下的时候,操作系统就会依次调用所有的中断处理函数,当然就包括我们的驱动程序所注册的这个函数。
中断处理部分相关的几处关键代码如下:
- //中断处理函数
- static irqreturn_t myirq_handler(int irq, void * dev)
- {
- ...
- }
-
- // 驱动模块初始化函数
- static void myirq_init(void)
- {
- ...
- request_irq(IRQ_NUM, myirq_handler, IRQF_SHARED, MYDEV_NAME, &mydev);
- ...
- }
在中断处理函数中,目标是发送信号 SIGUSR1 到应用层,因此驱动程序需要知道应用程序的进程号(PID)。
根据之前的文章Linux驱动实践:驱动程序如何发送【信号】给应用程序?,应用程序必须主动把自己的 PID 告诉驱动模块才可以。这可以通过 write 或者ioctl函数来实现,
驱动程序用来接收 PID 的相关代码是:
- static long mydev_ioctl(struct file* file, unsigned int cmd, unsigned long arg)
- {
- ...
- if (100 == cmd)
- {
- pArg = (void *)arg;
- ...
- copy_from_user(&g_pid, pArg, sizeof(int));
- }
- }
知道了应用程序的 PID,驱动程序就可以在中断发生的时候(按下键盘ESC键),发送信号出去了:
- static void send_signal(int sig_no)
- {
- struct siginfo info;
- ...
- send_sig_info(...);
- }
-
- static irqreturn_t myirq_handler(int irq, void * dev)
- {
- ...
- send_signal(SIGUSR1);
- }
Makefile 文件
- ifneq ($(KERNELRELEASE),)
- obj-m := my_driver_interrupt_signal.o
- else
- KERNELDIR ?= /lib/modules/$(shell uname -r)/build
- PWD := $(shell pwd)
- default:
- $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
- clean:
- rm -rf *.o *.ko *.mod.* modules.* Module.*
- $(MAKE) -C $(KERNEL_PATH) M=$(PWD) clean
- endif
编译、测试
首先查看一下加载驱动模块之前,1号中断的所有驱动程序:
再看一下设备号:
- $ cat /proc/devices
因为驱动注册在创建设备节点的时候,是动态请求系统分配的。
根据之前的几篇文章可以知道,系统一般会分配244这个主设备号给我们,此刻还不存在这个设备号。
编译、加载驱动模块:
- $ make
- $ sudo insmod my_driver_interrupt_signal.ko
首先看一下 dmesg 的输出信息:
然后看一下中断驱动程序:
可以看到我们的驱动程序( mydev )已经登记在1号中断的最右面。
最后看一下设备节点情况:
驱动模块已经准备妥当,下面就是应用程序了。
应用程序
应用程序的主要功能就是两部分:
通过 ioctl 函数把自己的 PID 告诉驱动程序;
注册信号 SIGUSR1 的处理函数;
示例代码全貌
- #include
- #include
- #include
- #include
- #include
- #include
- #include
-
-
- char *dev_name = "/dev/mydev";
-
- // 信号处理函数
- static void signal_handler(int signum, siginfo_t *info, void *context)
- {
- // 打印接收到的信号值
- printf("signal_handler: signum = %d \n", signum);
- printf("signo = %d, code = %d, errno = %d \n",
- info->si_signo,
- info->si_code,
- info->si_errno);
- }
-
- int main(int argc, char *argv[])
- {
- int fd, count = 0;
- int pid = getpid();
-
- // 打开GPIO
- if((fd = open(dev_name, O_RDWR | O_NDELAY)) < 0){
- printf("open dev failed! \n");
- return -1;
- }
-
- printf("open dev success! \n");
-
- // 注册信号处理函数
- struct sigaction sa;
- sigemptyset(&sa.sa_mask);
- sa.sa_sigaction = &signal_handler;
- sa.sa_flags = SA_SIGINFO;
-
- sigaction(SIGUSR1, &sa, NULL);
-
- // set PID
- printf("call ioctl. pid = %d \n", pid);
- ioctl(fd, 100, &pid);
-
- // 死循环,等待接收信号
- while (1)
- sleep(1);
-
- // 关闭设备
- close(fd);
- }
在应用程序的最后,是一个 while(1) 死循环。因为只有在按下键盘上的ESC按键时,驱动程序才会发送信号上来,因此应用程序需要一直存活着。
编译、测试
新开一个中断窗口,编译、执行应用程序:
- $ gcc my_interrupt_singal.c -o my_interrupt_singal
- $ sudo ./my_interrupt_singal
- open dev success!
- call ioctl. pid = 12907
-
- // 这里进入 while 循环
由于应用程序调用了 open 和 ioctl 这两个函数,因此,驱动程序中两个对应的函数就会被执行。
这可以通过 dmesg 命令的输出信息看出来:
这个时候,按下键盘上的 ESC 键,此时驱动程序中打印如下信息:
说明:驱动程序捕获到了键盘上的 ESC 键,并且发送信号给应用程序了。
在执行应用程序的终端窗口中,可以看到如下输出信息:
说明:应用程序接收到了驱动程序发来的信号!