内核驱动系列--中断和定时器

最新推荐文章于 2025-06-09 14:27:50 发布

转载最新推荐文章于 2025-06-09 14:27:50 发布 · 629 阅读

linux 文档专栏收录该内容

12 篇文章

订阅专栏

本文介绍了Linux中的中断处理机制，包括顶半部和底半部的概念，并详细解释了中断编程中的申请、释放、使能及屏蔽操作。同时，文章探讨了实现底半部机制的方法，如tasklet、工作队列和软中断等。此外，还介绍了Linux中的定时器机制，包括定时器的数据结构、函数及其应用实例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、中断

1 概述：

　　Linux 的中断处理分为顶半部和底半部，顶半部完成尽可能少得的比较紧急的功能，往往只是简单的完成“登记中断”的工作，

　　就是就是将底半部处理程序挂到该设备的底半部处理队列中去。但是，也不能僵化的认为linux设备驱动中的中断处理一定分

　　为两个半部，如果中断要处理的工作本身就很少，则完全可以在顶半部全部完成。查看/proc/interrupts文件可以获得系统

　　中断的统计信息。

2 中断编程：

　　1 申请和释放中断

　　　　（1）申请irq

　　　　　　int request_irq (unsigned int irq, irq_handler_t handler, unsigned long irqflags, const char *devname,

　　　　　　　　　　　　　　　　void *dev_id)

　　　　　　irq 是要申请的中断号，handler是向系统登记的中断处理函数，irq_flags是中断处理的属性，可以指定中断的触发

　　　　　　方式机处理方式。dev_id 在中断共享时会用到，一般设置为这个设备的结构体或者NULL.

　　　　（2）释放irq

　　　　　　void free_irq (unsigned int irq, void *dev_id); 参数定义与request_irq()相同。

　　　2 使能和屏蔽中断

　　　　 (1)　屏蔽：void disable_irq (int irq);

　　　　　　　　　void disable_irq_nosync (ing irq);//立即返回

　　　　　　　　　void enable_irq (int irq);

　　　　　　　　　#define local_irq_save (flags)//屏蔽本cpu所有

　　　　　　　　　void local_irq_disable (void) //屏蔽本cpu所有中断

　　　　 (2）恢复中断

　　　　　　#define local_irq_restore (flags)

　　　　　　void local_irq_enable (void);

　　3 底半部机制--实现机制主要有tasklet, 工作队列和软中断。

　　　　（1） tasklet

　　　　　　void my_tasklet_func (unsigned long);

　　　　　　DECLARE_TASKLET (my_tasklet, my_tasklet_func, data);

　　　　　　/*定义一个tasklet结构my_tasklet, 与my_tasklet_func(data)函数相关联*/

　　　　　　tasklet_schedule (&my_tasklet);

　　　　　　/*使系统在适当的时候调度tasklet注册的函数*/

　　　　（2）工作队列

　　　　　　struct work_struct my_wq;

　　　　　　void my_wq_func (unsigned long);

　　　　　　INIT_WORK (&my_wq, (void（＊）（ｖｏｉｄ　＊））ｍｙ＿ｗｑ＿ｆｕｎｃ，　ＮＵＬＬ）；

　　　　　　／＊初始化工作队列并将其与处理函数绑定＊／

　　　　　　schedule_work (&my_wq); /*调度工作队列执行*/

　　　　（3）软中断（与通常说的软中断（软件指令引发的中断），比如arm的swi是完全不同的概念）

　　　　　　在linux内核中，用softirq_action结构体表征一个软中断，这个结构体包含软中断处理函数指针和传递给该

　　　　　　函数的参数。使用open_softirq()函数可以注册软中断对应的处理函数，而raise_softirq()函数可以触发一

　　　　　　个软中断。

　　　　　　软中断和tasklet 运行与软中断上下文，仍属于原子上下文的一种，而工作队列则运行与进程上下文。因此，

　　　　　　软中断和tasklet处理函数中不能睡眠，而工作队列处理函数中允许睡眠。

　　　　　　local_bh_disable() 和 local_bh_enable()是内核中用于禁止和使能软中断和tasklet底半部机制的函数。

3 实例--s3c2410实时钟中断

　　参考linux模块，在/drivers/rtc/rtc-s3c.c 和/drivers/rtc/interface.c文件中。

二、时钟

1 概述：

　　软件意义上的定时器最终依赖硬件定时器来实现，内核在时钟中断发生后检测个定时器释放到期，到期后的定时器处理函数

　　将作为软中断底半部执行。驱动编程中，可以利用一组函数和数据结构来完成定时器触发工作或者某些周期性任务。

2 用到的数据结构和函数

　　（1) 一个timer_list 结构体的实例对应一个定时器，其定义如下：

　　　　struct timer_list {

　　　　　　struct list_head entry, /*定时器列表*/

　　　　　　unsigned long expires, /*定时器到期时间*/

　　　　　　void (*function) (unsigned long), /*定时器处理函数*/

　　　　　　unsigned long data,/*作为参数被传入定时器处理函数*/

　　　　　　struct timer_base_s *base,

　　　　　　...

　　　　};

　　　　实例化 struct timer_list my_timer;

　　　(2) 初始化定时器

　　　　void init_timer (struct timer_list *timer);

　　　　TIMER_INITIALIZER (_function, _expires, _data)

　　　　DEFINE_TIMER (_name, _function, _expires, _data)

　　　　setup_timer ();

　　　(3) 增加定时器

　　　　void add_timer (struct timer_list *timer);

　　　(4) 删除定时器

　　　　int del_timer (struct timer_list *timer);

　　　(5) 修改定时器的expire

　　　　int mod_timer (struct timer_list *timer, unsigned long expires);

　　　(6) 对于周期性的任务，linux内核还提供了一种delayed_work机制来完成，本质上用工作队列和定时器实现。

3 实例--秒字符设备

second_drv.c

  1 #include <linux/module.h>
  2 #include <linux/types.h>
  3 #include <linux/fs.h>
  4 #include <linux/errno.h>
  5 #include <linux/mm.h>
  6 #include <linux/sched.h>
  7 #include <linux/init.h>
  8 #include <linux/cdev.h>
  9 #include <asm/io.h>
 10 #include <asm/system.h>
 11 #include <asm/uaccess.h>
 12 #include <linux/slab.h>
 13 
 14 #define SECOND_MAJOR 248
 15 
 16 static int second_major = SECOND_MAJOR;
 17 
 18 struct second_dev {
 19     struct cdev cdev;
 20     atomic_t counter;
 21     struct timer_list s_timer;
 22 };
 23 
 24 struct second_dev *second_devp;
 25 static void second_timer_handle (unsigned long arg)
 26 {
 27     mod_timer (&second_devp->s_timer, jiffies + HZ);
 28     atomic_inc (&second_devp->counter);
 29     printk (KERN_NOTICE "current jiffies is %ld\n", jiffies);
 30 }
 31 int second_open (struct inode *inode, struct file *filp)
 32 {
 33     init_timer (&second_devp->s_timer);
 34     second_devp->s_timer.function = &second_timer_handle;
 35     second_devp->s_timer.expires = jiffies + HZ;
 36     add_timer (&second_devp->s_timer);
 37     atomic_set (&second_devp->counter, 0);
 38     return 0;
 39 }
 40 int second_release (struct inode *inode, struct file *filp)
 41 {
 42     del_timer (&second_devp->s_timer);
 43     return 0;
 44 }
 45 static ssize_t second_read (struct file *filp, char __user *buf,
 46         size_t count, loff_t *ppos)
 47 {
 48     int counter;
 49     counter = atomic_read (&second_devp->counter);
 50     if (put_user (counter, (int *)buf))
 51         return -EFAULT;
 52     else
 53         return sizeof (unsigned int);
 54 }
 55 static const struct file_operations second_fops = {
 56     .owner = THIS_MODULE,
 57     .open = second_open,
 58     .release = second_release,
 59     .read = second_read,
 60 };
 61 static void second_setup_cdev (struct second_dev *dev, int index)
 62 {
 63     int err, devno = MKDEV (second_major, index);
 64     cdev_init (&dev->cdev, &second_fops);
 65     dev->cdev.owner = THIS_MODULE;
 66     err = cdev_add (&dev->cdev, devno, 1);
 67     if (err)
 68         printk (KERN_NOTICE "Error %d adding CDEV %d", err, index);
 69 }
 70 int second_init (void)
 71 {
 72     int ret;
 73     dev_t devno = MKDEV (second_major, 0);
 74     if (second_major)
 75         ret = register_chrdev_region (devno, 1, "second");
 76     else {
 77         return alloc_chrdev_region (&devno, 0, 1, "second");
 78         second_major = MAJOR (devno);
 79     }
 80     if (ret < 0)
 81         return ret;
 82     second_devp = kmalloc (sizeof (struct second_dev), GFP_KERNEL);
 83     if (!second_devp) {
 84         ret = -ENOMEM;
 85         goto fail_malloc;
 86     }
 87     memset (second_devp, 0, sizeof (struct second_dev));
 88     second_setup_cdev (second_devp, 0);
 89     return 0;
 90 fail_malloc:
 91     unregister_chrdev_region (devno, 1);
 92     return ret;
 93 }
 94 void second_exit (void)
 95 {
 96     cdev_del (&second_devp->cdev);
 97     kfree (second_devp);
 98     unregister_chrdev_region (MKDEV (second_major, 0), 1);
 99 }
100 MODULE_AUTHOR ("Ljia-----Ljia");
101 MODULE_LICENSE ("Dual BSD/GPL");
102 module_param (second_major, int, S_IRUGO);
103 module_init (second_init);
104 module_exit (second_exit);

second_test.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

int main (void)
{
    int fd;
    int counter = 0;
    int old_counter = 0;

    fd = open ("/dev/second", O_RDONLY);
    if (fd != -1) {
        while (1) {
            read (fd, &counter, sizeof (unsigned int));
            if (counter != old_counter) {
                printf ("seconds after open /dev/second: %d\n", 
                        counter);
                old_counter = counter;
            }
        }
    } else {
        printf ("Device open failure\n");
    }
    return 0;
}