20150518 Linux设备驱动中的并发控制

中断屏蔽的使用方法为:

local_irq_disable() //屏蔽中断

...

critical section //临界区

...

local_irq_enable() //开中断

1.设置原子变量的值

void atomic_set(atomic_t *v, int i); //设置原子变量的值为 i

atomic_t v = ATOMIC_INIT(0); //定义原子变量 v 并初始化为 0

//--------------------------------------------------------------------------

2.获取原子变量的值

atomic_read(atomic_t *v); //返回原子变量的值

//--------------------------------------------------------------------------

3.原子变量加/减

void atomic_add(int i, atomic_t *v); //原子变量增加 i

void atomic_sub(int i, atomic_t *v); //原子变量减少 I

//--------------------------------------------------------------------------

4.原子变量自增/自减

void atomic_inc(atomic_t *v); //原子变量增加 1

void atomic_dec(atomic_t *v); //原子变量减少 1

//--------------------------------------------------------------------------

5.操作并测试

int atomic_inc_and_test(atomic_t *v);

int atomic_dec_and_test(atomic_t *v);

int atomic_sub_and_test(int i, atomic_t *v);

上述操作对原子变量执行自增、自减和减操作后(注意没有加)测试其是否为 0,为 0 则返回 true,否则返回 false。

//--------------------------------------------------------------------------

6.操作并返回

int atomic_add_return(int i, atomic_t *v);

int atomic_sub_return(int i, atomic_t *v);

int atomic_inc_return(atomic_t *v);

int atomic_dec_return(atomic_t *v);

上述操作对原子变量进行加/减和自增/自减操作,并返回新的值。

1.设置位

void set_bit(nr, void *addr);

上述操作设置 addr 地址的第 nr 位,所谓设置位即将位写为 1。

//--------------------------------------------------------------------------

2.清除位

void clear_bit(nr, void *addr);

上述操作清除 addr 地址的第 nr 位,所谓清除位即将位写为 0。

//--------------------------------------------------------------------------

3.改变位

void change_bit(nr, void *addr);

上述操作对 addr 地址的第 nr 位进行反置。

---------------------------------------------------------------------------

4.测试位

test_bit(nr, void *addr);

上述操作返回 addr 地址的第 nr 位。

//--------------------------------------------------------------------------

5.测试并操作位

int test_and_set_bit(nr, void *addr);

int test_and_clear_bit(nr, void *addr);

int test_and_change_bit(nr, void *addr);

上述 test_and_xxx_bit ( nr, void *addr) 操作等同于执行 test_bit (nr, void *addr) 后再执行 xxx_bit(nr, void *addr) 。

1.定义自旋锁

spinlock_t spin;

//--------------------------------------------------------------------------

2.初始化自旋锁

spin_lock_init(lock)

该宏用于动态初始化自旋锁 lock

//--------------------------------------------------------------------------

3.获得自旋锁

spin_lock(lock)

该宏用于获得自旋锁 lock,如果能够立即获得锁,它就马上返回,否则,它将自

旋在那里,直到该自旋锁的保持者释放;

spin_trylock(lock)

该宏尝试获得自旋锁 lock,如果能立即获得锁,它获得锁并返回真,否则立即返回假,实际上不再“在原地打转”;

//--------------------------------------------------------------------------

4.释放自旋锁

spin_unlock(lock)

该宏释放自旋锁一般这样被使用,如下所示:

//定义一个自旋锁

spinlock_t lock;

spin_lock_init(&lock);

spin_lock (&lock) ; //获取自旋锁,保护临界区

...//临界区

spin_unlock (&lock) ; //解锁自旋锁 lock,它与 spin_trylock 或 spin_lock 配对使用。

//--------------------------------------------------------------------------

自旋锁一般这样被使用,如下所示:

//定义一个自旋锁

spinlock_t lock;

spin_lock_init(&lock);

spin_lock (&lock) ; //获取自旋锁,保护临界区

...//临界区

spin_unlock (&lock) ; //解锁

spin_lock_irq() = spin_lock() + local_irq_disable()

spin_unlock_irq() = spin_unlock() + local_irq_enable()

spin_lock_irqsave() = spin_unlock() + 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()

1.定义和初始化读写自旋锁

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

rwlock_t my_rwlock;

rwlock_init(&my_rwlock); /* 动态初始化 */

//--------------------------------------------------------------------------

2.读锁定

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);

//--------------------------------------------------------------------------

3.读解锁

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);

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

read_lock_irqsave()、read_lock_irq()和 read_lock_bh()分别是 read_lock()分别与local_irq_save()、local_irq_disable()和local_bh_disable()的组合 ,读解锁函数read_unlock_irqrestore()、read_unlock_ irq()、read_unlock_bh()的情况与此类似。

//--------------------------------------------------------------------------

4.写锁定

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);

//--------------------------------------------------------------------------

5.写解锁

void write_unlock(rwlock_t *lock);

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

void write_unlock_irq(rwlock_t *lock);

void write_unlock_bh(rwlock_t *lock);

write_lock_irqsave()、write_lock_irq()、write_lock_bh()分别是 write_lock() 与local_irq_save()、local_irq_disable()和local_bh_disable()的组合,写解锁函数

write_unlock_irqrestore()、write_unlock_irq()、write_unlock_bh()的情况与此类似

读写自旋锁一般这样被使用,如下所示:

rwlock_t lock; //定义 rwlock

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

//读时获取锁

read_lock(&lock);

... //临界资源

read_unlock(&lock);

//写时获取锁

write_lock_irqsave(&lock, flags);

... //临界资源

write_unlock_irqrestore(&lock, flags);

1.获得顺序锁

void write_seqlock(seqlock_t *sl);

int write_tryseqlock(seqlock_t *sl);

write_seqlock_irqsave(lock, flags)

write_seqlock_irq(lock)

write_seqlock_bh(lock)

其中:

write_seqlock_irqsave() = loal_irq_save() + write_seqlock()

write_seqlock_irq() = local_irq_disable() + write_seqlock()

write_seqlock_bh() = local_bh_disable() + write_seqlock()

2.释放顺序锁

void write_sequnlock(seqlock_t *sl);

write_sequnlock_irqrestore(lock, flags)

write_sequnlock_irq(lock)

write_sequnlock_bh(lock)

其中:

write_sequnlock_irqrestore() = write_sequnlock() + local_irq_restore()

write_sequnlock_irq() = write_sequnlock() + local_irq_enable()

write_sequnlock_bh() = write_sequnlock() + local_bh_enable()

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

write_seqlock(&seqlock_a);

...//写操作代码块

write_sequnlock(&seqlock_a);

因此,对写执行单元而言,它的使用与 spinlock 相同。

1.读开始

unsigned read_seqbegin(const seqlock_t *sl);

read_seqbegin_irqsave(lock, flags)

读执行单元在对被顺序锁 s1 保护的共享资源进行访问前需要调用该函数, 该函数

仅返回顺序锁 s1 的当前顺序号。其中:

read_seqbegin_irqsave() = local_irq_save() + read_seqbegin()

2.重读

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

read_seqretry_irqrestore(lock, iv, flags)

读执行单元在访问完被顺序锁 s1 保护的共享资源后需要调用该函数来检查, 在读

访问期间是否有写操作。如果有写操作,读执行单元就需要重新进行读操作。其中:

read_seqretry_irqrestore() = read_seqretry() + local_irq_restore()

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

do {

    seqnum = read_seqbegin(&seqlock_a);

    //读操作代码块

    ...

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

1.读锁定

rcu_read_lock()

rcu_read_lock_bh()

2.读解锁

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()

3.同步 RCU

synchronize_rcu()

该函数由 RCU 写执行单元调用,它将阻塞写执行单元,直到所有的读执行单元已经完成读执行单元临界区,写执行单元才可以继续下一步操作。如果有多个 RCU写执行单元调用该函数,它们将在一个 grace period (即所有的读执行单元已经完成对临界区的访问)之后全部被唤醒。synchronize_rcu()保证所有 CPU 都处理完正在运行的读执行单元临界区。

synchronize_kernel()

内核代码使用该函数来等待所有 CPU 处于可抢占状态,目前功能等同于synchronize_rcu(),但现在已经不建议使用,而是使用 synchronize_sched(),该函数用于等待所有 CPU 都处在可抢占状态,它能保证正在运行的中断处理函数处理完毕,但不能保证正在运行的软中断处理完毕。

4.挂接回调

void fastcall call_rcu(struct rcu_head *head,void (*func)(struct rcu_head *rcu));

函数 call_rcu()也由 RCU 写执行单元调用,它不会使写执行单元阻塞,因而可以在中断上下文或软中断中使用。该函数将把函数 func 挂接到 RCU 回调函数链上,然后立即返回。函数 synchronize_rcu()的实现实际上使用了 call_rcu()函数。

void fastcall call_rcu_bh(struct rcu_head *head,void (*func)(struct rcu_head *rcu));

call_ruc_bh()函数的功能几乎与 call_rcu()完全相同,唯一差别就是它把软中断的完成也当做经历一个 quiescent state(静默状态),因此如果写执行单元使用了该函数,在进程上下文的读执行单元必须使用 rcu_read_lock_bh()。

static inline void list_add_rcu(struct list_head *new, struct list_head

*head);

该函数把链表元素 new 插入到 RCU 保护的链表 head 的开头,内存栅保证了在引用这个新插入的链表元素之前,新链表元素的链接指针的修改对所有读执行单元是可见的。

static inline void list_add_tail_rcu(struct list_head *new,

struct list_head *head);

该函数类似于 list_add_rcu(),它将把新的链表元素 new 添加到被 RCU 保护的链表的末尾。

static inline void list_del_rcu(struct list_head *entry);

该函数从 RCU 保护的链表中删除指定的链表元素 entry。

static inline void list_replace_rcu(struct list_head *old, struct

list_head *new);

该函数是 RCU 新添加的函数,并不存在非 RCU 版本。它使用新的链表元素 new取代旧的链表元素 old,内存栅保证在引用新的链表元素之前,它对链接指针的修正对所有读行单元是可见的。

list_for_each_rcu(pos, head)

该宏用于遍历由 RCU 保护的链表 head,只要在读执行单元临界区使用该函数,它就可以安全地和其他_rcu 链表操作函数并发运行如 list_add_rcu()。

list_for_each_safe_rcu(pos, n, head)

该宏类似于 list_for_each_rcu,不同之处在于它允许安全地删除当前链表元素 pos。

list_for_each_entry_rcu(pos, head, member)

该宏类似于 list_for_each_rcu,不同之处在于它用于遍历指定类型的数据结构链表,当前链表元素 pos 为一个包含 struct list_head 结构的特定的数据结构。

static inline void hlist_del_rcu(struct hlist_node *n)

它从由 RCU 保护的哈希链表中移走链表元素 n。

static inline void hlist_add_head_rcu(struct hlist_node *n,

struct hlist_head *h);

该函数用于把链表元素 n 插入到被 RCU 保护的哈希链表的开头,但同时允许读执行单元对该哈希链表的遍历。内存栅确保在引用新链表元素之前, 它对指针的修改对所有读执行单元可见。

hlist_for_each_rcu(pos, head)

该宏用于遍历由 RCU 保护的哈希链表 head,只要在读端临界区使用该函数,它就可以安全地和其他_rcu 哈希链表操作函数(如 hlist_add_rcu)并发运行。

hlist_for_each_entry_rcu(tpos, pos, head, member)

类似于 hlist_for_each_rcu(),不同之处在于它用于遍历指定类型的数据结构哈希链表,当前链表元素 pos 为一个包含 struct list_head 结构的特定的数据结构。

1.定义信号量

下列代码定义名称为 sem 的信号量。

struct semaphore sem;

2.初始化信号量

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

该函数初始化信号量,并设置信号量 sem 的值为 val。尽管信号量可以被初始化为大于 1 的值从而成为一个计数信号量,但是它通常不被这样使用。

void init_MUTEX(struct semaphore *sem);

该函数用于初始化一个用于互斥的信号量,它把信号量 sem 的值设置为 1,等同于

sema_init (struct semaphore *sem, 1)。

void init_MUTEX_LOCKED (struct semaphore *sem);

该函数也用于初始化一个信号量,但它把信号量 sem 的值设置为 0,等同于

sema_init (struct semaphore *sem, 0)。

此外,下面两个宏是定义并初始化信号量的“快捷方式”。

DECLARE_MUTEX(name)

DECLARE_MUTEX_LOCKED(name)

前者定义一个名为 name 的信号量并初始化为 1,后者定义一个名为 name 的信号量并初始化为 0。

3.获得信号量

void down(struct semaphore * sem);

该函数用于获得信号量 sem,它会导致睡眠,因此不能在中断上下文使用。

int down_interruptible(struct semaphore * sem);

该函数功能与 down()类似,不同之处为,因为 down()而进入睡眠状态的进程不能被信号打断,而因为 down_interruptible()而进入睡眠状态的进程能被信号打断,信号也会导致该函数返回,这时候函数的返回值非 0。

int down_trylock(struct semaphore * sem);

该函数尝试获得信号量 sem,如果能够立刻获得,它就获得该信号量并返回 0,否则,返回非 0 值。它不会导致调用者睡眠,可以在中断上下文使用。在使用 down_interruptible()获取信号量时,对返回值一般会进行检查,如果非 0,通常立即返回-ERESTARTSYS,如:

if (down_interruptible(&sem)){

return - ERESTARTSYS;

}

4.释放信号量

void up(struct semaphore * sem);

该函数释放信号量 sem,唤醒等待者。

信号量一般这样被使用,如下所示:

//定义信号量

DECLARE_MUTEX(mount_sem);

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

...

critical section //临界区

...

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

1.定义完成量

下列代码定义名为 my_completion 的完成量。

struct completion my_completion;

2.初始化 completion

下列代码初始化 my_completion 这个完成量。

init_completion(&my_completion);

对 my_completion 的定义和初始化可以通过如下快捷方式实现。

DECLARE_COMPLETION(my_completion);

3.等待完成量

下列函数用于等待一个 completion 被唤醒。

void wait_for_completion(struct completion *c);

4.唤醒完成量

下面两个函数用于唤醒完成量。

void complete(struct completion *c);

void complete_all(struct completion *c);

前者只唤醒一个等待的执行单元,后者释放所有等待同一完成量的执行单元。

使用的三项原则:

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

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

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

1.定义和初始化读写信号量

struct rw_semaphore my_rws; /*定义读写信号量*/

void init_rwsem(struct rw_semaphore *sem); /*初始化读写信号量*/

2.读信号量获取

void down_read(struct rw_semaphore *sem);

int down_read_trylock(struct rw_semaphore *sem);

3.读信号量释放

void up_read(struct rw_semaphore *sem);

4.写信号量获取

void down_write(struct rw_semaphore *sem);

int down_write_trylock(struct rw_semaphore *sem);

5.写信号量释放

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_write(&rw_sem);

struct mutex my_mutex;

mutex_init(&my_mutex);

下面的两个函数用于获取互斥体。

void fastcall mutex_lock(struct mutex *lock); 引起的睡眠不能被信号打断

int fastcall mutex_lock_interruptible(struct mutex *lock); 引起的睡眠能被信号打断

int fastcall mutex_trylock(struct mutex *lock); 尝试获得 mutex,获取不到 mutex 时不会引起进程睡眠

下列函数用于释放互斥体。

void fastcall mutex_unlock(struct mutex *lock);

使用方法:

struct mutex my_mutex; //定义 mutex

mutex_init(&my_mutex); //初始化 mutex

mutex_lock(&my_mutex); //获取 mutex

...//临界资源

mutex_unlock(&my_mutex); //释放 mutex

root@EasyARM-iMX257 /mnt/nfs/module/48_mutex_globalmem# echo "hello,LoverXueEr" > /dev/globalmem

written 17 bytes(s) from 0

root@EasyARM-iMX257 /mnt/nfs/module/48_mutex_globalmem# cat /dev/globalmem

hello,LoverXueEr