linux内核同步机制之中断屏蔽

定义：

         在进入临界区之前屏蔽系统的中断。可保证正在执行的内核执行路径不被中断处理程序抢占，（linux的进程调度都依赖于中断）

中断屏蔽相关函数：

local_irq_disable(); //屏蔽所有中断
...... //临界区代码
local_irq_enable(); //开放所有中断

注：使用该函数有时会出现问题，如果有些中断在屏蔽中断前就是关闭的，那么在开放所有中断时就是被之前默认处于关闭状态的中断给打开了。

我们可以通过下面的方法避免这种情况：

unsigned long flag;
local_irq_save(flag);//保存中断状态，关闭所有中断
...... //临界区代码
local_irq_restore();//打开中断，恢复关闭前中断状态

应用层代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>


/*Linux内核是抢占式内核，在一个系统调用未结束前，另一个系统调用也可以进入进程上下文，访问同一缓冲区*/
int main(void)
{ 
    int status;
    pid_t pid;

    //打开文件raceStation
    int fd_driver;
    if((fd_driver = open("/dev/key_eint_race", O_RDWR)) < 0){
        printf("file open error\n");
        exit(1);
    }
    //创建子进程
    if((pid = fork()) < 0){
        perror("fork:");
        exit(1);
    }
    else if(pid == 0){             //判断如果是子进程
        int num;
        while(1){
            read(fd_driver,&num,sizeof(num)); 
            printf("the num value is <son-%d>: %d\n",getpid(), num);
            // usleep(50*1000);
        }
        close(fd_driver);
    }else{                         //判断如果是父进程
        int num;
        while(1){ 
            read(fd_driver,&num,sizeof(num)); 
            printf("the num value is <father-%d>: %d\n",getpid(), num);
            // usleep(50*1000);
        }
        pid = wait(&status);
        close(fd_driver);
    }
}

驱动代码：

#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <mach/gpio.h>
#include <linux/delay.h>
#include <mach/regs-gpio.h>  /*S5PV210_GPH3_BASE*/
 
#define EINT_DEVICE_ID			1
 
#define DRIVER_NAME				"key_eint_race"
#define err(msg) 				printk(KERN_ERR "%s: " msg "\n", DRIVER_NAME)
#define __debug(fmt, arg...)	printk(KERN_DEBUG fmt, ##arg)
 
#define GPH3CON					(unsigned long)(S5PV210_GPH3_BASE+ 0x00)
#define GPH3DAT					(unsigned long)(S5PV210_GPH3_BASE + 0x04)
#define GPH2UP					(unsigned long)(S5PV210_GPH2_BASE + 0x08)
 
static int major = 0;		/* Driver Major Number */
static int minor = 0;		/* Driver Minor Number */
struct class *key_class;
static struct device *key_device;
 
static unsigned int key;
 
 
static unsigned int deal_key_value(unsigned int data)
{
	key = data;
	udelay(1000);
	return key;
}
 
irqreturn_t buttons_interrupt(int irq, void *dev_id)
{	
	deal_key_value((unsigned int)dev_id);
	//__debug("in eint function...\n");
	return IRQ_HANDLED;
}
 
static void key_io_port_init(void)
{
	unsigned long reg_val;
	
	reg_val = readl(GPH3CON);
	reg_val &= ~((0x0f<<0) | (0x0f<<4));
	reg_val |= ((0x01<<0) | (0x01<<4));
	writel(reg_val, GPH3CON);
 
	reg_val = readl(GPH3DAT);
	reg_val &= ~((0x01<<0) | (0x01<<1));
	writel(reg_val, GPH3DAT);
 
	reg_val = readl(GPH2UP);
	reg_val &= ~(0x03<<8);
	reg_val |= 0x02<<8;
	writel(reg_val, GPH2UP);
}
 
static ssize_t key_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
	int key_num;
	int cpy_len;
	int retval;
	unsigned long flag;
	/*
	*	仅对单处理器进程抢占、中断函数引发的并发操作有作用
	*	竞态区处理前禁止所有中断即可，在禁止中断之前我们将中断状态进行保存
	*   便于退出临界区的中断状态恢复
	*/
	local_irq_save(flag);		//关中断
	key_num =deal_key_value(current->pid);
	local_irq_restore(flag);	//开中断
	
	cpy_len = min(sizeof(key_num), count);
	retval = copy_to_user(buf, &key_num, cpy_len);
	
	return (cpy_len - retval);
}
 
/* Driver Operation structure */
static struct file_operations key_fops = {
	.owner = THIS_MODULE,
	.read = key_read,
};
 
 
static int __init key_eint_init(void)
{
	int retval;
	
	key_io_port_init();
	//__debug("in key_eint_init\n");
	
	retval = set_irq_type(IRQ_EINT(20),IRQ_TYPE_EDGE_FALLING);
	if(retval){
		err("IRQ_EINT20 set irq type failed");
		goto error;
	}
	
	retval = request_irq(IRQ_EINT(20), buttons_interrupt, IRQF_DISABLED, 
			"KEY1", (void *)EINT_DEVICE_ID);
	if(retval){
		err("request eint20 failed");
		goto error;
	}
	
	/* Driver register */
	major = register_chrdev(major, DRIVER_NAME, &key_fops);
	if(major < 0){
		err("register char device fail");
		retval = major;
		goto error_register;
	}
	key_class=class_create(THIS_MODULE,DRIVER_NAME);
	if(IS_ERR(key_class)){
		err("class create failed!");
		retval =  PTR_ERR(key_class);
		goto error_class;
	}
	key_device=device_create(key_class,NULL, MKDEV(major, minor), NULL,DRIVER_NAME);
	if(IS_ERR(key_device)){
		err("device create failed!");
		retval = PTR_ERR(key_device);
		goto error_device;
	}
	__debug("register myDriver OK! Major = %d\n", major);
	return 0;
 
error_device:
	class_destroy(key_class);
error_class:
	unregister_chrdev(major, DRIVER_NAME);
error_register:
	free_irq(IRQ_EINT(20), (void *)EINT_DEVICE_ID);
error:
	return retval;
}
 
static void __exit key_eint_exit(void)
{
	//__debug("in key_eint_exit\n");
	
	free_irq(IRQ_EINT(20), (void *)EINT_DEVICE_ID);
 
	unregister_chrdev(major, DRIVER_NAME);
	device_destroy(key_class,MKDEV(major, minor));
	class_destroy(key_class);
 
	return;
}
 
module_init(key_eint_init);
module_exit(key_eint_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZH");

在PC端的ARM linux内核中编译，生成.ko可执行文件，下载到ARM板上，挂载即可使用该内核模块。