字符设备驱动同步之互斥阻塞

最新推荐文章于 2023-01-02 16:27:50 发布
最新推荐文章于 2023-01-02 16:27:50 发布
阅读量1.6k 收藏
点赞数
分类专栏： Linux 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clb1609158506/article/details/44603809
版权
先了解几个概念：
临界资源： 一次只允许一个执行单元使用的资源称为临界资源。比如多台电脑都可以使用同一台打印机，但是，一个时刻只能有一台电脑来控制他进行打印，所以打印机在这里就是临界资源。
临界区： 访问共享资源的代码区域。就是执行单元访问共享资源的那段代码就对啦。
并发： 就是几个进程一起执行。
竞态： 几个进程同时访问共享资源时发生
（上面之所以说是执行单元，不说进程是因为还有线程的存在）
什么叫进程的同步？
百度一下：我们把异步环境下的一组并发进程因直接制约而互相发送消息、进行互相合作、互相等待，使得各进程按一定的速度执行的过程称为进程间的同步。
我的理解就是： 进程之间步伐一致，他们之间能够有配合的工作。
进程之间同步的实现需要一些规则来协调，通常比如：互斥、阻塞。
一、互斥：同一时刻只能有一个App打开某个设备或访问某个资源
实现互斥的技巧：
(1)原子操作
驱动程序的任务：
①设置原子变量的值
atomic_t v = ATOMIC_INIT(1);//定义原子变量v初始化为1
②在即将访问临界资源前设定“使用中”标记，通常是：
if (!atomic_dec_and_test(&canopen))
{
atomic_inc(&canopen);
 printk("Using now!\n");
 return -EBUSY;
}
③在不使用资源时要将标记改成“未使用”
atomic_inc(&canopen);//释放原子变量
代码实现：

atomic.c文件

#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/module.h>
#include <linux/device.h> 		//class_create
#include <mach/regs-gpio.h>		//S3C2410_GPF1 
#include <mach/hardware.h>
#include <linux/interrupt.h>  //wait_event_interruptible
#include <linux/fs.h>
#include <arch/arm/include/asm/atomic.h>

/* 定义并初始化等待队列头 */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);


static atomic_t canopen = ATOMIC_INIT(1);     //定义原子变量并初始化为1


static struct class *buttondev_class;
static struct device *buttons_device;

static struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};

static struct pin_desc pins_desc[4] = {
		{S3C2410_GPF1,0x01}, //S3C2410_GPF1是对GPF1引脚这种“设备”的编号dev_id
		{S3C2410_GPF4,0x02},
		{S3C2410_GPF2,0x03},
		{S3C2410_GPF0,0x04},
}; 
static int ev_press = 0;
static unsigned char key_val;
int major;

/* 中断处理函数 */
static irqreturn_t handle_irq(int irq, void *dev_id)
{
	struct pin_desc *irq_pindesc = (struct pin_desc *)dev_id;//
	unsigned int pinval;
		
	pinval = s3c2410_gpio_getpin(irq_pindesc->pin);//获取按键值:有按键按下返回按键值0
	/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
	/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
	if(pinval)
	{
		/* 松开 */
		key_val = 0x80 | (irq_pindesc->key_val);
	}
	else
	{
		/* 按下 */
		key_val = irq_pindesc->key_val;
	}

	ev_press = 1;							/* 表示中断已经发生 */
	wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
	return IRQ_HANDLED;
}

static int buttons_dev_open(struct inode * inode, struct file * filp)
{
	///
	//实现互斥：原子操作
	if (!atomic_dec_and_test(&canopen))
	{
		atomic_inc(&canopen);
		printk("dev is using now!\n");
		return -EBUSY;
	}
	///
	request_irq(IRQ_EINT1, handle_irq, IRQ_TYPE_EDGE_FALLING, "K1",&pins_desc[0]);
	request_irq(IRQ_EINT4, handle_irq, IRQ_TYPE_EDGE_FALLING, "K2",&pins_desc[1]);
	request_irq(IRQ_EINT2, handle_irq, IRQ_TYPE_EDGE_FALLING, "K3",&pins_desc[2]);
	request_irq(IRQ_EINT0, handle_irq, IRQ_TYPE_EDGE_FALLING, "K4",&pins_desc[3]);
	return 0;
}

static int buttons_dev_close(struct inode *inode, struct file *file)
{
	//
	atomic_inc(&canopen);//释放原子变量
	//
	free_irq(IRQ_EINT1,&pins_desc[0]);
	free_irq(IRQ_EINT4,&pins_desc[1]);
	free_irq(IRQ_EINT2,&pins_desc[2]);
	free_irq(IRQ_EINT0,&pins_desc[3]);
	
	return 0;
}

static ssize_t buttons_dev_read(struct file *file, char __user *user, size_t size,loff_t *ppos)
{
	if (size != 1)
			return -EINVAL;
	wait_event_interruptible(button_waitq, ev_press);//没有按键就进入休眠
	copy_to_user(user, &key_val, 1);
	/* 将ev_press清零 */
	ev_press = 0;
	return 1;
}

/* File operations struct for character device */
static const struct file_operations buttons_dev_fops = {
	.owner		= THIS_MODULE,
	.open		= buttons_dev_open,
	.read		= buttons_dev_read,
	.release    = buttons_dev_close,
};

/* 驱动入口函数 */
static int buttons_dev_init(void)
{
	/* 主设备号设置为0表示由系统自动分配主设备号 */
	major = register_chrdev(0, "buttons_dev", &buttons_dev_fops);

	/* 创建buttondev类 */
	buttondev_class = class_create(THIS_MODULE, "buttondev");

	/* 在buttondev类下创建buttons设备，供应用程序打开设备*/
	buttons_device = device_create(buttondev_class, NULL, MKDEV(major, 0), NULL, "buttons");//

	return 0;
}

/* 驱动出口函数 */
static void buttons_dev_exit(void)
{
	unregister_chrdev(major, "buttons_dev");
	device_unregister(buttons_device);  //卸载类下的设备
	class_destroy(buttondev_class);		//卸载类
}

/* 模块加载和卸载函数的修饰 */
module_init(buttons_dev_init);  
module_exit(buttons_dev_exit); 

MODULE_AUTHOR("CLBIAO");
MODULE_DESCRIPTION("Just for Demon");
MODULE_LICENSE("GPL");  //遵循GPL协议
测试程序：

app_atomic.c

/* 文件的编译指令是arm-linux-gcc -static -o app_irq app_atomic.c */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>   //sleep 
#include <stdio.h>

int main(int argc, char **argv)
{
	int flag,fd; 
	unsigned char key_val;
	
	fd = open("/dev/buttons", O_RDWR); //申请外部引脚中断服务
	if (fd < 0)
	{
		printf("can't open!\n");//打开失败
		return -1;//返回
	}
	while(1)
	{
		read(fd,&key_val,1); 
   		printf("key_val = 0x%x\n",key_val); 
		sleep(3);
	}
	return 0;
}

运行结果：

(2)信号量： 只有得到信号量的进程才能执行临界区的代码。得不到的进程进入休眠状态，直到有条件获取信号量，或者被其他进程终止。
驱动程序的任务：
①定义信号量&初始化，通常使用下面的宏
DECLARE_MUTEX(name);//定义一个名为name的信号量，并初始化为1
②获取信号量

void down(struct semaphore * sem);//获得信号量sem，如果获取不到，这个函数会导致休眠，休眠 不可以被信号打断，即使是“kill -9 pid”也不能将他退出，不要在中断上下文中使用，因为它太固执了！

void down_interruptible(struct semaphore * sem);//进入睡眠状态的进程能被信号打断
 void down_trylock(struct semaphore * sem);//尝试去获取信号量，成功返回0，失败返回非零，不会导致调用进程休眠，可用于中断上下文
“down”往下，让我想到：在资源上插一支旗子，获取他的人就把它拿下来，其他人就呵呵了^_^
③释放信号量
int up(struct semaphore * sem);//把信号插回去，然后唤醒沉睡的人
代码实现： 
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/module.h>
#include <linux/device.h> 		//class_create
#include <mach/regs-gpio.h>		//S3C2410_GPF1 
#include <mach/hardware.h>
#include <linux/interrupt.h>  //wait_event_interruptible
#include <linux/fs.h>
#include <linux/semaphore.h>

/* 定义并初始化等待队列头 */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);


static DECLARE_MUTEX(button_lock);//(1)获取信号量量并初始化为1


static struct class *buttondev_class;
static struct device *buttons_device;

static struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};

static struct pin_desc pins_desc[4] = {
		{S3C2410_GPF1,0x01}, //S3C2410_GPF1是对GPF1引脚这种“设备”的编号dev_id
		{S3C2410_GPF4,0x02},
		{S3C2410_GPF2,0x03},
		{S3C2410_GPF0,0x04},
}; 
static int ev_press = 0;
static unsigned char key_val;
int major;

/* 中断处理函数 */
static irqreturn_t handle_irq(int irq, void *dev_id)
{
	struct pin_desc *irq_pindesc = (struct pin_desc *)dev_id;//
	unsigned int pinval;
		
	pinval = s3c2410_gpio_getpin(irq_pindesc->pin);//获取按键值:有按键按下返回按键值0
	/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
	/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
	if(pinval)
	{
		/* 松开 */
		key_val = 0x80 | (irq_pindesc->key_val);
	}
	else
	{
		/* 按下 */
		key_val = irq_pindesc->key_val;
	}

	ev_press = 1;							/* 表示中断已经发生 */
	wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
	return IRQ_HANDLED;
}

static int buttons_dev_open(struct inode * inode, struct file * filp)
{
	/
	down(&button_lock);//(2)获取信号量
	
	request_irq(IRQ_EINT1, handle_irq, IRQ_TYPE_EDGE_FALLING, "K1",&pins_desc[0]);
	request_irq(IRQ_EINT4, handle_irq, IRQ_TYPE_EDGE_FALLING, "K2",&pins_desc[1]);
	request_irq(IRQ_EINT2, handle_irq, IRQ_TYPE_EDGE_FALLING, "K3",&pins_desc[2]);
	request_irq(IRQ_EINT0, handle_irq, IRQ_TYPE_EDGE_FALLING, "K4",&pins_desc[3]);
	return 0;
}

static int buttons_dev_close(struct inode *inode, struct file *file)
{
	/
	up(&button_lock);//(3)释放信号量
	
	free_irq(IRQ_EINT1,&pins_desc[0]);
	free_irq(IRQ_EINT4,&pins_desc[1]);
	free_irq(IRQ_EINT2,&pins_desc[2]);
	free_irq(IRQ_EINT0,&pins_desc[3]);
	
	return 0;
}

static ssize_t buttons_dev_read(struct file *file, char __user *user, size_t size,loff_t *ppos)
{
	if (size != 1)
			return -EINVAL;
	wait_event_interruptible(button_waitq, ev_press);//没有按键就进入休眠
	copy_to_user(user, &key_val, 1);
	/* 将ev_press清零 */
	ev_press = 0;
	return 1;
}

/* File operations struct for character device */
static const struct file_operations buttons_dev_fops = {
	.owner		= THIS_MODULE,
	.open		= buttons_dev_open,
	.read		= buttons_dev_read,
	.release    = buttons_dev_close,
};

/* 驱动入口函数 */
static int buttons_dev_init(void)
{
	/* 主设备号设置为0表示由系统自动分配主设备号 */
	major = register_chrdev(0, "buttons_dev", &buttons_dev_fops);

	/* 创建buttondev类 */
	buttondev_class = class_create(THIS_MODULE, "buttondev");

	/* 在buttondev类下创建buttons设备，供应用程序打开设备*/
	buttons_device = device_create(buttondev_class, NULL, MKDEV(major, 0), NULL, "buttons");//

	return 0;
}

/* 驱动出口函数 */
static void buttons_dev_exit(void)
{
	unregister_chrdev(major, "buttons_dev");
	device_unregister(buttons_device);  //卸载类下的设备
	class_destroy(buttondev_class);		//卸载类
}

/* 模块加载和卸载函数的修饰 */
module_init(buttons_dev_init);  
module_exit(buttons_dev_exit); 

MODULE_AUTHOR("CLBIAO");
MODULE_DESCRIPTION("Just for Demon");
MODULE_LICENSE("GPL");  //遵循GPL协议

测试程序和前面一个一样。

运行结果：

      

(3)自旋锁：就是得不到自旋锁就“原地打转”，进程一直跑不过是原地循环
使用和信号量很相似，主要有：定义、初始化、获得、释放操作。
(4)中断屏蔽：让系统不能进行中断，这样就不会切换到其他进程来抢夺资源了。
使用方法：
①屏蔽中断
local_irq_disable();
②临界区安安心心地访问资源
③开中断
local_irq_enable();
二、阻塞和非阻塞
阻塞：不能获得资源时挂起进程并进入睡眠状态，直到资源到来。之前的驱动都是阻塞方式打开的。这里不再进行列举程序。
app：open("...",O_RDWR);//open默认就是阻塞的方式打开
非阻塞：无资源不挂起进程，之后放弃或不停的查询。通常和信号量配合使用。

app：open("...",O_RDWR|O_NONBLOCK);

非阻塞方式例程序：

nonblock.c文件

#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/module.h>
#include <linux/device.h> 		//class_create
#include <mach/regs-gpio.h>		//S3C2410_GPF1 
#include <mach/hardware.h>
#include <linux/interrupt.h>  //wait_event_interruptible
#include <linux/fs.h>
#include <linux/semaphore.h>

/* 定义并初始化等待队列头 */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);


static DECLARE_MUTEX(button_lock);//(1)获取信号量量并初始化为1


static struct class *buttondev_class;
static struct device *buttons_device;

static struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};

static struct pin_desc pins_desc[4] = {
		{S3C2410_GPF1,0x01}, //S3C2410_GPF1是对GPF1引脚这种“设备”的编号dev_id
		{S3C2410_GPF4,0x02},
		{S3C2410_GPF2,0x03},
		{S3C2410_GPF0,0x04},
}; 
static int ev_press = 0;
static unsigned char key_val;
int major;

/* 中断处理函数 */
static irqreturn_t handle_irq(int irq, void *dev_id)
{
	struct pin_desc *irq_pindesc = (struct pin_desc *)dev_id;//
	unsigned int pinval;
		
	pinval = s3c2410_gpio_getpin(irq_pindesc->pin);//获取按键值:有按键按下返回按键值0
	/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
	/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
	if(pinval)
	{
		/* 松开 */
		key_val = 0x80 | (irq_pindesc->key_val);
	}
	else
	{
		/* 按下 */
		key_val = irq_pindesc->key_val;
	}

	ev_press = 1;							/* 表示中断已经发生 */
	wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
	return IRQ_HANDLED;
}

static int buttons_dev_open(struct inode * inode, struct file * filp)
{
	/
	if (file->f_flags & O_NONBLOCK)//判断是不是非阻塞方式
	{
		if (down_trylock(&button_lock))//尝试获取信号量，没有就走人，不等待！
			return -EBUSY;
	}
	else  //是阻塞方式就使用down函数，这样可以进入睡眠
	{
		/* 获取信号量 */
		down(&button_lock);
	}
	
	request_irq(IRQ_EINT1, handle_irq, IRQ_TYPE_EDGE_FALLING, "K1",&pins_desc[0]);
	request_irq(IRQ_EINT4, handle_irq, IRQ_TYPE_EDGE_FALLING, "K2",&pins_desc[1]);
	request_irq(IRQ_EINT2, handle_irq, IRQ_TYPE_EDGE_FALLING, "K3",&pins_desc[2]);
	request_irq(IRQ_EINT0, handle_irq, IRQ_TYPE_EDGE_FALLING, "K4",&pins_desc[3]);
	return 0;
}

static int buttons_dev_close(struct inode *inode, struct file *file)
{
	/
	up(&button_lock);//(3)释放信号量
	
	free_irq(IRQ_EINT1,&pins_desc[0]);
	free_irq(IRQ_EINT4,&pins_desc[1]);
	free_irq(IRQ_EINT2,&pins_desc[2]);
	free_irq(IRQ_EINT0,&pins_desc[3]);
	
	return 0;
}

static ssize_t buttons_dev_read(struct file *file, char __user *user, size_t size,loff_t *ppos)
{
	if (size != 1)
			return -EINVAL;
	/
	if (file->f_flags & O_NONBLOCK) //读不到按键值立马返回，不睡眠！
	{
		if (!ev_press)
			return -EAGAIN;
	}
	else
		wait_event_interruptible(button_waitq, ev_press);//没有按键就进入休眠
	///
	copy_to_user(user, &key_val, 1);
	/* 将ev_press清零 */
	ev_press = 0;
	
	return 1;
}

/* File operations struct for character device */
static const struct file_operations buttons_dev_fops = {
	.owner		= THIS_MODULE,
	.open		= buttons_dev_open,
	.read		= buttons_dev_read,
	.release    = buttons_dev_close,
};

/* 驱动入口函数 */
static int buttons_dev_init(void)
{
	/* 主设备号设置为0表示由系统自动分配主设备号 */
	major = register_chrdev(0, "buttons_dev", &buttons_dev_fops);

	/* 创建buttondev类 */
	buttondev_class = class_create(THIS_MODULE, "buttondev");

	/* 在buttondev类下创建buttons设备，供应用程序打开设备*/
	buttons_device = device_create(buttondev_class, NULL, MKDEV(major, 0), NULL, "buttons");//

	return 0;
}

/* 驱动出口函数 */
static void buttons_dev_exit(void)
{
	unregister_chrdev(major, "buttons_dev");
	device_unregister(buttons_device);  //卸载类下的设备
	class_destroy(buttondev_class);		//卸载类
}

/* 模块加载和卸载函数的修饰 */
module_init(buttons_dev_init);  
module_exit(buttons_dev_exit); 

MODULE_AUTHOR("CLBIAO");
MODULE_DESCRIPTION("Just for Demon");
MODULE_LICENSE("GPL");  //遵循GPL协议

加油！更上一层楼！生气































clbiao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
驱动程序之同步阻塞互斥的源码
07-25
使得同时只有一个应用程序可以打开驱动程序。
字符设备驱动程序之按键——同步互斥阻塞
RubyBoss的专栏
07-09 733
我们知道在之前的应用程序中，如果我们同时运行两次应用程序的话，则两次都可以同时打开设备，这就是说我们的按键资源同时被两个进程使用。显然这不是我们想要的，那么下面我们就要引入互斥的概念。 关于互斥其实其实现很简单，就是采用一些标志，当文件被一个进程打开后，就会设置该标志，使其他进程无法打开设备文件。下面，我们就完全靠自己去实现一个互斥，代码修改如下： 首先定义一个全局变量： static
S3C2440 字符设备驱动程序之同步互斥阻塞（十）
Tim的嵌入式之旅
05-17 407
  字符设备驱动程序之同步互斥阻塞     原子操作 目的：同一时刻只能有一个应用程序app打开/dev/buttons。   读出、修改、写回 并不是很快就结束的，有可能被打断。因为linux是多任务，在A执行过程中，有可能换成B程序来执行。     原子操作函数：(原子：不可再分) 原子变量操作是Linux的一种简单的同步机制，在操作过程中不会被打断的操作。 原子变量...
字符设备驱动的同步互斥阻塞
weixin_43898067的博客
03-13 149
目的在同一时刻,只能有一个app打开驱动文件,有三种方法 1原子操作 原子操作指的是在执行过程中不会被别的代码路径所中断的操作。 常用原子操作函数举例： atomic_t v = ATOMIC_INIT(0); //定义原子变量 v 并初始化为 0 atomic_read(atomic_t *v); //返回原子变量的值 void atomic_inc(atomic_t *v); //原子变量增加...
字符设备中的同步、互斥和阻塞操作
lee_jimmy的博客
10-14 388
下面的内容对学习过程中做一个简单的总结，方便以后回忆，内容可能过于简陋 1. 原子操作 如果我们希望字符驱动程序每次只能给一个应用程序打开，就需要加锁，比如在驱动程序中加一个整型的全局变量canopen：     1代表可以open，0代表不能open。 但是我们不能简单的给整型变量canopen++或者canopen--，因为代码中简单的自加动作，在汇编代码中就要分成3步完成：     ld...
字符设备驱动程序之同步互斥阻塞
ymangu的专栏
09-22 794
这一节要达到的目的---同一时刻，只能要一个app 打开 /dev/keys 设备文件。
Linux线程同步之互斥量（mutex）
01-09
互斥量（也称为互斥锁）出自POSIX线程标准，可以用来同步同一进程中的各个线程。当然如果一个互斥量存放在多个进程共享的某个内存区中，那么还可以通过互斥量来进行进程间的同步。 　互斥量，从字面上可以知道是...
Linux设备驱动中的互斥机制.pdf
09-06
Linux设备驱动中的互斥机制.pdf
同步互斥和 Linux 内核模块之C语言【100012226】
最新发布
05-18
实验一：有两条道路双向两个车道，即每条路每个方向只有一个车道，两条道路十字交叉。假设车辆只能向前直行，而不允许转弯和后退。如果有 4 辆车几乎同时到达这个十字路口，如图（a）所示；相互交叉地停下来，如图...
进程的同步与互斥习题(含部分题目的参考答案).doc
01-03
进程的同步与互斥习题(含部分题目的参考答案).doc
linux字符设备驱动-同步互斥阻塞笔记
时光左an的博客
03-08 760
一、开发环境 1、内核：Linux 2.6.22.6； 2、JZ2440 3、ubuntu 9.10 二、互斥 为了实现同一时绝对的只能有一个进程使用某个设备需要互斥机制，linux互斥机制有多种，如原子变量、互斥锁、信号量、自旋锁、读写锁等等。 1、原子操作。指执行的过程中不会被别的代码路径所中断的操作。实现原子操作过程：  1.1 其常使用的函
阻塞型字符设备
CoderChe
05-30 1067
阻塞型字符设备是驱动中的一个重点。 一、问题：当一个设备无法立刻满足用户的读写请求时应当如何处理？ 解答：应用程序通常不关心这种问题，应用程序只是调用 read 或 write 并得到返回值。驱动程序应当(缺省地)阻塞进程，使它进入睡眠，直到请求可以得到满足。 二、阻塞方式 在阻塞型驱动程序中，Read实现方式如下：如果进程调用read，但设备没有数据或数据不足，进程阻塞。当新数据到达后，
并发和竞态
wuyuwei45的专栏
04-19 826
并发及其管理 1、并发（concurrency）指的是多个执行单元同时、并行被执行，而并发的执行单元对共享资源（硬件资源和软件上的全局变量、静态变量等）的访问则很容易导致竞态（race condition）。 2、在设计自己的驱动程序时，第一个要记住的规则是，只要可能，就应该避免资源的共享。如果没有并发的访问，也就不会有竞态的产生。因此，仔细编写的内核代码应具有最少的共享。这种思想的最
linux内核阻塞字符设备,阻塞型字符设备驱动 - Linux高级字符设备驱动_Linux编程_Linux公社-Linux系统门户网站...
weixin_33293612的博客
05-02 116
#include #include #include #include #include #include #include #include #include #include #include #include "memdev.h"static mem_major = MEMDEV_MAJOR;bool have_data = false; /*表明设备有足够的数据可供读*/module_pa...
Linux设备驱动第七篇：高级字符驱动操作之阻塞IO
haomcu的专栏
07-31 2088
我们之前介绍过简单的read，write操作，那么会有一个问题：当驱动无法立即响应请求该怎么办？比如一个进程调用read读取数据，当没有数据可读时该怎么办，是立即返回还是等到有数据的时候；另一种情况是进程调用write向设备写数据，如果缓冲区满了或者设备正忙的时候怎么办，是立即返回还是继续等待直到设备可写？这种情况下，一般的缺省做法是使进程睡眠直到请求可以满足为止。本篇就介绍遇到这类问题驱动的处理
驱动学习（七）驱动互斥
a834605978的博客
07-12 326
一类设备对应一个驱动程序，一类设备可以有多个子设备，当多个子设备同时访问一个驱动程序时，会造成竞态。简单来说就是厕所只有一个，不可以同时上。
驱动的互斥
m0_57128077的博客
01-02 105
驱动互斥 ，信号量，互斥锁，自旋锁，原子变量
5.字符设备驱动------同步互斥阻塞
weixin_30646315的博客
12-13 112
引入　 当设备被一个程序打开时，存在被另一个程序打开的可能，如果两个或多个程序同时对设备文件进行写操作，这就是说我们的设备资源同时被多个进程使用,对共享资源（硬件资源、和软件上的全局变量、静态变量等）的访问则很容易导致竞态。 显然这不是我们想要的,所以本节引入互斥的概念:实现同一时刻,只能一个应用程序使用驱动程序 互斥其实现很简单，就是采用一些标志，当文件被一个进程打开后，就会设置该标志，使...
驱动学习之互斥与同步
zj82448191的博客
09-16 272
一、并发的来源 中断处理路径 调度器的可抢占性 多处理器的并发执行 二、解决竟态的办法 2.1 中断屏蔽 对于单cpu范围来说，解决竟态的简单方法就是屏蔽系统的中断，屏蔽中断使得中断与进程之间的并发不会发生，并且由于Linux内核进程调度等操作都是依赖于中断来实现，内核抢占之间的并发也就可以避免了。 local _ irq _ disable() //屏蔽中 local _ irq _ enable() //开中断 下面这两个宏是上面的变体，目的是为了防止在关闭中断的环境中使用上面两个宏之后，最后的环
Linux线程同步之互斥量加锁解锁
05-17
在多线程编程中，为了防止多个线程同时访问共享资源而导致的数据竞争问题，需要使用同步机制来实现线程间的协调和互斥。而互斥量是一种常用的同步机制，在多线程编程中被广泛使用。 互斥量是一种线程同步原语，用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值