Linux设备驱动中的并发控制总结

  自旋锁持有期间内核的抢占将被禁止。

  自旋锁可以保证临界区不受别的CPU和本CPU内的抢占进程打扰，但是得到锁的代码路径在执行临界区的时候还可能受到中断和底半部(BH)的影响。

  为防止这种影响，需要用到自旋锁的衍生：

spin_lock_irq() = spin_lock() + local_irq_disable()

spin_unlock_irq() = spin_unlock() + local_irq_enable()

spin_lock_irqsave() = spin_lock() + local_irq_save()

spin_unlock_irqrestore() = spin_unlock() + local_irq_restore()

spin_lock_bh() = spin_lock() + local_bh_disable()

spin_unlock_bh() = spin_unlock() + local_bh_enable()

  注意：自旋锁实际上是忙等待，只有在占用锁的时间极短的情况下，使用自旋锁才是合理的

          自旋锁可能导致死锁：递归使用一个自旋锁或进程获得自旋锁后阻塞。

  自旋锁使用实例，使设备只能被最多一个进程打开：

int xxx_count = 0; // 定义文件打开次数计数

static int xxx_open(struct inode *inode, struct file *filp)

{

...

spinlock(&xxx_lock);

if(xxx_count);  // 已经打开

{

spin_unlock(&xxx_lock);

return - EBUSY;

}

xxx_count++;  // 增加使用计数

spin_unlock(&xxx_lock);

...

return 0;  // 成功

}

static int xxx_release(struct inode *inode, struct file *filp)

{

...

spinlock(&xxx_lock);

xxx_count--; // 减少使用计数

spin_unlock(&xxx_lock);

return 0;

}

读写自旋锁(rwlock)允许读的并发。在写操作方面，只能最多有一个写进程，在读操作方面，同时可以有多个读执行单元。当然，读和写也不能同时进行。

// 定义和初始化读写自旋锁

rwlock_t my_rwlock = RW_LOCK_UNLOCKED;  // 静态初始化

rwlock_t my_rwlock;

rwlock)init(&my_rwlock);  // 动态初始化

// 读锁定：在对共享资源进行读取之前，应先调用读锁定函数，完成之后调用读解锁函数

void read_lock(rwlock_t *lock);

void read_lock_irqsave(rwlock_t *lock, unsigned long flags);

void read_lock_irq(rwlock_t *lock);

void read_lock_bh(rwlock_t *lock);

// 读解锁

void read_unlock(rwlock_t *lock);

void read_unlock_irqrestore(rwlock_t *lock, unsigned long flags);

void read_unlock_irq(rwlock_t *lock);

void read_unlock_bh(rwlock_t *lock);

// 写锁定：在对共享资源进行写之前，应先调用写锁定函数，完成之后调用写解锁函数

void write_lock(rwlock_t *lock);

void write_lock_irqsave(rwlock_t *lock, unsigned long flags);

void write_lock_irq(rwlock_t *lock);

void write_lock_bh(rwlock_t *lock);

int write_trylock(rwlock_t *lock);

// 写解锁

void write_unlock(rwlock_t *lock);

void write_unlock_irqsave(rwlock_t *lock, unsigned long flags);

void write_unlock_irq(rwlock_t *lock);

void write_unlock_bh(rwlock_t *lock);

  读写自旋锁一般用法：

rwlock_t lock;  // 定义rwlock

rwlock_init(&lock);  // 初始化rwlock

// 读时获取锁

read_lock(&lock);

...  // 临界资源

read_unlock(&lock);

// 写时获取锁

write_lock_irqsave(&lock, flags);

...  // 临界资源

write_unlock_irqrestore(&lock, flags);

 

  顺序锁(seqlock)是对读写锁的优化。

  使用顺序锁，读执行单元不会被写执行单元阻塞，即读执行单元可以在写执行单元对被顺序锁保护的共享资源进行写操作时仍然可以继续读，而不必等待写执行单元完成写操作，写执行单元也不需要等待所有读执行单元完成读操作才去进行写操作。

  写执行单元之间仍是互斥的。

  若读操作期间，发生了写操作，必须重新读取数据。

  顺序锁必须要求被保护的共享资源不含有指针。

  写执行单元操作：

// 获得顺序锁

void write_seqlock(seqlock_t *sl);

int write_tryseqlock(seqlock_t *sl);

write_seqlock_irqsave(lock, flags)

write_seqlock_irq(lock)

write_seqlock_bh()

// 释放顺序锁

void write_sequnlock(seqlock_t *sl);

write_sequnlock_irqrestore(lock, flags)

write_sequnlock_irq(lock)

write_sequnlock_bh()

// 写执行单元使用顺序锁的模式如下：

write_seqlock(&seqlock_a);

...  // 写操作代码块

write_sequnlock(&seqlock_a);

  读执行单元操作：

// 读开始：返回顺序锁sl当前顺序号

unsigned read_seqbegin(const seqlock_t *sl);

read_seqbegin_irqsave(lock, flags)

// 重读：读执行单元在访问完被顺序锁sl保护的共享资源后需要调用该函数来检查，在读访问期间是否有写操作。若有写操作，重读

int read_seqretry(const seqlock_t *sl, unsigned iv);

read_seqretry_irqrestore(lock, iv, flags)

// 读执行单元使用顺序锁的模式如下：

do{

seqnum = read_seqbegin(&seqlock_a);

// 读操作代码块

...

}while(read_seqretry(&seqlock_a, seqnum));

 

  RCU(Read-Copy Update 读-拷贝-更新)

  RCU可看作读写锁的高性能版本，既允许多个读执行单元同时访问被保护的数据，又允许多个读执行单元和多个写执行单元同时访问被保护的数据。

  但是RCU不能替代读写锁。因为如果写操作比较多时，对读执行单元的性能提高不能弥补写执行单元导致的损失。因为使用RCU时，写执行单元之间的同步开销会比较大，它需要延迟数据结构的释放，复制被修改的数据结构，它也必须使用某种锁机制同步并行的其他写执行单元的修改操作。

  RCU操作：

// 读锁定

rcu_read_lock()

rcu_read_lock_bh()

// 读解锁

rcu_read_unlock()

rcu_read_unlock_bh()

// 使用RCU进行读的模式如下：

rcu_read_lock()

...  // 读临界区

rcu_read_unlock()

  rcu_read_lock() 和rcu_read_unlock()实质是禁止和使能内核的抢占调度：

#define rcu_read_lock()  preempt_disable()

#define rcu_read_unlock()  preempt_enable()

  rcu_read_lock_bh()、rcu_read_unlock_bh()定义为：

#define rcu_read_lock_bh()  local_bh_disable()

#define rcu_read_unlock_bh()  local_bh_enable()

  同步RCU

synchronize_rcu()

  由RCU写执行单元调用，保证所有CPU都处理完正在运行的读执行单元临界区。

 

 

 

  信号量的使用

    信号量(semaphore)与自旋锁相同，只有得到信号量才能执行临界区代码，但，当获取不到信号量时，进程不会原地打转而是进入休眠等待状态。

    信号量的操作：

// 定义信号量

struct semaphore sem;

// 初始化信号量:

// 初始化信号量，并设置sem的值为val

void sema_init(struct semaphore *sem, int val);

// 初始化一个用于互斥的信号量，sem的值设置为1。等同于sema_init(struct semaphore *sem, 1)

void init_MUTEX(struct semaphore *sem);

// 等同于sema_init(struct semaphore *sem, 0)

void init_MUTEX_LOCKED(struct semaphore *sem);

// 下面两个宏是定义并初始化信号量的“快捷方式”：

DECLEAR_MUTEX(name)

DECLEAR_MUTEX_LOCKED(name)

//  获得信号量：

//  用于获得信号量，它会导致睡眠，不能在中断上下文使用

void down(struct semaphore *sem);

// 类似down(),因为down()而进入休眠的进程不能被信号打断，而因为down_interruptible()而进入休眠的进程能被信号打断， // 信号也会导致该函数返回，此时返回值非0

void down_interruptible(struct semaphore *sem);

// 尝试获得信号量sem，若立即获得，它就获得该信号量并返回0，否则，返回非0.它不会导致调用者睡眠，可在中断上下文使用

int down_trylock(struct semaphore *sem);

//  使用down_interruptible()获取信号量时，对返回值一般会进行检查，若非0，通常立即返回-ERESTARTSYS，如：

if(down_interruptible(&sem))

{

return - ERESTARTSYS;

}

// 释放信号量

// 释放信号量sem, 唤醒等待者

void up(struct semaphore *sem);

// 信号量一般这样被使用：

DECLARE_MUTEX(mount_sem);

down(&mount_sem);  // 获取信号量，保护临界区

...

critical section  // 临界区

...

up(&mount_sem);  // 释放信号量

 

    Linux自旋锁和信号量锁采用的“获取锁-访问临界区-释放锁”的方式存在于几乎所有的多任务操作系统之中。

    用信号量实现设备只能被一个进程打开的例子：

static DECLEAR_MUTEX(xxx_lock)  // 定义互斥锁

static int xxx_open(struct inode *inode, struct file *filp)

{

...

if(down_trylock(&xxx_lock))  // 获得打开锁

return - EBUSY;  // 设备忙

...

return 0;  // 成功

}

static int xxx_release(struct inode *inode, struct file *filp)

{

up(&xxx_lock);  // 释放打开锁

return 0;

}

  信号量用于同步

    若信号量被初始化为0，则它可以用于同步，同步意味着一个执行单元的继续执行需等待另一执行单元完成某事，保证执行的先后顺序。

  完成量用于同步

    完成量(completion)提供了一种比信号量更好的同步机制，它用于一个执行单元等待另一个执行单元执行完某事。

    completion相关操作：

// 定义完成量

struct completion my_completion;

// 初始化completion

init_completion(&my_completion);

// 定义和初始化快捷方式：

DECLEAR_COMPLETION(my_completion);

// 等待一个completion被唤醒

void wait_for_completion(struct completion *c);

// 唤醒完成量

void cmplete(struct completion *c);

void cmplete_all(struct completion *c);

  自旋锁和信号量的选择

    当锁不能被获取时，使用信号量的开销是进程上下文切换时间Tsw，使用自旋锁的开销是等待获取自旋锁(由临界区执行时间决定)Tcs，若Tcs较小，应使用自旋锁，若Tcs较大，应使用信号量。

    信号量保护的临界区可包含可能引起阻塞的代码，而自旋锁则绝对要避免用来保护包含这样代码的临界区。因为阻塞意味着要进行进程切换，若进程被切换出去后，另一个进程企图获取本自旋锁，死锁就会发生。

    信号量存在于进程上下文，因此，若被保护的共享资源需要在中断或软中断情况下使用，则在信号量和自旋锁之间只能选择自旋锁。若一定要使用信号量，则只能通过down_trylock()方式进行，不能获取就立即返回避免阻塞。

  读写信号量

    读写信号量与信号量的关系与读写自旋锁和自旋锁的关系类似，读写信号量可能引起进程阻塞，但它可允许N个读执行单元同事访问共享资源，而最多只能有一个写执行单元。

    读写自旋锁的操作：

// 定义和初始化读写信号量

struct rw_semaphore my_res;  // 定义

void init_rwsem(struct rw_semaphore *sem);  // 初始化

// 读信号量获取

void down_read(struct rw_semaphore *sem);

void down_read_trylock(struct rw_semaphore *sem);

// 读信号量释放

void up_read(struct rw_semaphore *sem);

// 写信号量获取

void down_write(struct rw_semaphore *sem);

int down_write_trylock(struct rw_semaphore *sem);

// 写信号量释放

void up_write(struct rw_semaphore *sem);

// 读写信号量的使用：

rw_semaphore rw_sem;  // 定义

init_rwsem(&rw_sem);  // 初始化

// 读时获取信号量

down_read(&rw_sem);

...  // 临街资源

up_read(&rw_sem);

// 写时获取信号量

down_write(&rw_sem);

...  // 临界资源

up_writer(&rw_sem);

相关阅读 更多 +

• 
  逆战未来收藏室解锁方法 游戏攻略 2026-01-25
• 
  原神月之四版本幽境危战速通攻略 游戏攻略 2026-01-25
• 
  明日方舟终末地修复大型起重机任务完成攻略 游戏攻略 2026-01-25
• 
  创造与魔法避难所全部刷新点位图一览 游戏攻略 2026-01-25
• 
  第五人格斗牛士玩法指南 游戏攻略 2026-01-25

排行榜 更多 +

牛仔战争

飞行射击 下载

街头打架

动作格斗 下载

错误化探险活宝

冒险解谜 下载

• 4
  群英打三国

  454.85M · 96℃

  1970-01-01

  下载
• 5
  昆虫入侵者

  131.72M · 98℃

  1970-01-01

  下载
• 6
  开拍电视制作物语

  61.22MB · 98℃

  1970-01-01

  下载

Copyright 2006-2020 (phpxiu.com) All Rights Reserved.

本站为非盈利性网站，不接受任何广告。php爱好者