内核同步方法

1.原子操作

原子整数操作

描述

ATOMIC_INIT(int i)

  在声明一个atomic_t变量时，将它初始化为i

int atomic_read(atomic_t *v)

  原子地读取整数变量v

void atomic_set(atomic_t *v, int i)

  原子地设置v值为i

void atomic_add(int i, atomic_t *v)

  原子地给v加i

void atomic_sub(int i, atomic_t *v)

  原子地从v减i

void atomic_inc(atomic_t *v)

  原子地给v加1

void atomic_dec(atomic_t *v)

  原子地给v减1

int atomic_sub_and_test(int i, atomic_t *v)

  原子地从v减i，若结果等于0返回真，否则返回假

int atomic_add_negative(int i, atomic_t *v)

  原子地从v加i，若结果是负数返回真，否则返回假

int atomic_dec_and_test(atomic_t *v)

原子地从v减1，若结果等于0返回真，否则返回假

int atomic_inc_and_test(atomic_t *v)

  原子地从v加1，若结果等于0返回真，否则返回假

原子位操作

描述

void set_bit(int nr, void *addr)

  原子地设置addr所指对象的第nr位

void clear_bit(int nr, void *addr)

  原子地清空addr所指对象的第nr位

void change_bit(int nr, void *addr)

  原子地翻转addr所指对象的第nr位

int test_and_set_bit(int nr, void *addr)

  原子地设置addr所指对象的第nr位，并返回原先的值

int test_and_clear_bit(int nr, void *addr)

  原子地清空addr所指对象的第nr位，并返回原先的值

int test_and_change_bit(int nr, void *addr)

  原子地翻转addr所指对象的第nr位，并返回原先的值

int test_bit(int nr, void *addr)

  原子地返回addr所指对象的第nr位

2.自旋锁

自旋锁可以使用在中断处理程序中。在中断处理程序中使用自旋锁时，一定要在获取锁之前，首先禁止本地中断，否则，中断处理程序就会打断正持有锁的内核代码，有可能会试图争用这个已经被持有的自旋锁。顺便提一下，选项CONFIG_DEBUG_SPINLOCK可用来调试自旋锁。针对自旋锁的操作见下表:

 

方法

描述

spin_lock( )

  获取指定的自旋锁

spin_lock_irq( )

  禁止本地中断并获取指定的锁

spin_lock_irqsave( )

  保存本地中断的当前状态，禁止本地中断，并获取指定的锁   

spin_unlock( )

  释放指定的锁

spin_unlock_irq( )

  释放指定的锁，并激活本地中断

spin_unlock_irqrestore( )

  释放指定的锁，并让本地中断恢复到以前的状态

spin_lock_init( )

  初始化指定的spinlock_t

spin_trylock( )

  试图获取指定的锁，如果未获取则返回非0

spin_is_locked( )

  如果指定的锁当前正在被获取则返回非0，否则返回0

spin_lock_bh( )

  禁止所有下半部的执行，并获取指定的锁

spin_unlock_bh( )

  释放指定的锁，允许下半部的执行

3.读写自旋锁

当对某个数据结构的操作可以被划分为读/写两种类别时，可以使用Linux专门提供的读——写自旋锁。这种自旋锁为读和写分别提供了不同的锁。一个或多个读任务可以并发的持有读者锁；相反，用于写的锁最多只能被一个写任务持有，而且此时不能有并发的读操作。

 

通常情况下，读锁和写锁会位于完全分割开的代码分支中，下面的代码将会带来死锁：

     read_lock(&mr_rwlock);

     write_lock(&mr_rwlock);

因为写锁会不断自旋，等待所有的读锁释放，其中也包括它自己。当确实需要写操作时，要在一开始就请求写锁。如果写和读不能清晰分开的话，那么就使用一般的自旋锁。多个读者可以安全地获得同一个读锁，即使一个线程递归地获得一个读锁也是安全的。这个特性使读——写自旋锁成为一种有用并且常用的优化手段。读——写锁这种机制照顾读要比照顾写多一点。读锁被持有时，写锁只能等待，但读者却可以继续成功地占用锁，大量的读者就会使挂起的写者处于饥饿状态。读——写锁的操作见下表：

方法

描述

read_lock( )

  获取指定的读锁

read_lock_irq( )

  禁止本地中断并获取指定的读锁

read_lock_irqsave( )

  保存本地中断的当前状态，禁止本地中断并获取指定的读锁

read_unlock( )

  释放指定的读锁

read_unlock_irq( )

  释放指定的读锁，并激活本地中断

read_unlock_irqrestore( )

  释放指定的读锁，并让本地中断恢复到以前的状态

write_lock( )

  获取指定的写锁

write_lock_irq( )

  禁止本地中断并获取指定的写锁

write_lock_irqsave( )

  保存本地中断的当前状态，禁止本地中断并获取指定的写锁

write_unlock( )

  释放指定的写锁

write_unlock_irq( )

  释放指定的写锁，并激活本地中断

write_unlock_irqrestore( )

  释放指定的写锁，并让本地中断恢复到以前的状态

write_trylock( )

  试图获得指定的写锁；如果写锁不可用，返回非0值

rw_lock_init( )

  初始化指定的rwlock_t

rw_is_locked( )

  如果指定的锁当前已被持有，该函数返回非0值，否则返回0

如果加锁时间不长且代码不会睡眠(如中断处理程序)，利用自旋锁是最佳选择；如果加锁时间可能很长或者在持有锁时有可能睡眠，那么最好使用信号量来完成加锁功能。Linux中的信号量是一种睡眠锁。如果一个任务试图获得一个已经被占用的信号量时，信号量会将其推进一个等待队列，然后让其睡眠。这时处理器能重获自由，从而去执行其他代码。信号量不会禁止内核抢占，这意味着，信号量不会对调度的等待时间带来负面影响。

4.信号量

信号量允许任意数量的锁的持有者，而自旋锁在一个时刻最多允许一个任务持有它。信号量同时允许的持有者数量可以在声明信号量时指定，这个值称为使用者数量。该数值为1的信号量成为互斥信号量，大于1的称为计数信号量。信号量支持两个原子操作P()和V()，这两个名字来自荷兰语Proberen(测试操作)和Vershogen(增加操作)。后来的系统包括Linux把这两种操作分别叫做down()和up()。信号量的操作见下表：

方法

描述

sema_init(struct semaphore *, int)

  以指定的计数值初始化动态创建的信号量

init_MUTEX(struct semaphore *)

  以计数值1初始化动态创建的信号量

init_MUTEX_LOCKED(struct semaphore *)

  以计数值0初始化动态创建的信号量(初始化为加锁状态)

down_interruptible(struct semaphore *)

  试图获得指定的信号量，如果信号已被争用，则进入可中断睡眠状态

down(struct semaphore *)

  试图获得指定的信号量，如果信号已被争用，则进入不可中断睡眠状态

down_trylock(struct semaphore *)

  试图获得指定的信号量，如果信号已被争用，则立刻返回非0值

up(struct semaphore *)

  释放指定的信号量，如果睡眠队列不空，则唤醒其中的一个任务

5读写信号量

与自旋锁一样，信号量也有区分读——写访问。读——写信号量要比普通信号量更具优势。所有的读——写信号量都是互斥信号量。只要没有写者，并发持有读锁的读者数不限。相反，只有唯一的写者可以获得写锁。所有读——写锁的睡眠都不会被信号打断。读——写信号量相比读——写自旋锁多了一种特有的操作：downgrade_writer()。这个函数可以动态地将获取的写锁转换成读锁。

6完成变量

如果在内核中一个任务需要发出信号通知另一个任务发生了某个特定事件，利用完成变量是使两个任务得以同步的简单方法。完成变量提供了代替信号量的一个简单解决办法。如果一个任务要执行一些工作时，另一个任务就会在完成变量上等待，当这个任务完成后，会使用完成变量去唤醒在等待的任务。完成变量通常的用法是，将完成变量作为数据结构中的一项动态创建，而完成数据结构初始化工作的内核代码将调用wait_for_completion()进行等待。初始化完成后，初始化函数调用completion()唤醒在等待的内核任务。完成变量的操作见下表：

方法

描述

init_completion(struct completion *)

  初始化指定的动态创建的完成变量

wait_for_completion(struct completion *)

  等待指定的完成变量接受信号

completion(struct completion *)

  发信号唤醒任何等待任务

7.seq锁

Seq锁是在2.6内核版本中才引入的一种新型锁。这种锁提供了一种很简单的机制，用于读写共享数据。实现这种锁主要依靠一个序列计数器。当有疑义的数据被写入时，会得到一个锁，并且序列值会增加。在读取数据之前和之后，序列号都被读取。如果读取的序列号相同，说明在读操作进行的过程中没有被写操作打断过。如果读的值是偶数，那么就表明写操作没有发生。Seq锁对写者更有利，只要没有其它写者，写锁总是能被成功获得。另外，挂起的写者会不断地使得读操作循环，直到不再有任何写者持有锁为止。

8.内核抢占

如果数据对每个处理器是唯一的，这样的数据可能就不需要使用锁来保护，但如果内核是抢占式的，为了防止数据被多个进程以伪并发的方式访问，需要禁止内核抢占，禁止抢占的相关操作如下表：

 

方法

描述

Preempt_disable( )

  禁止内核抢占

Preempt_enable( )

  激活内核抢占并检查和执行被挂起的需要调度的任务

Preempt_enable_no_resched( )

  激活内核抢占但不再进行调度

Preempt_count( )

返回抢占计数

9.屏障

当处理多处理器之间或硬件设备之间的同步问题时，有时需要在程序代码中以指定的顺序发出读内存和写内存指令。在和硬件交互时，时常需要确保一个给定的读操作发生在其它读或写操作之前。另外，在多处理器上，可能需要按写数据的顺序读数据。但编译器和处理器为了提高效率，可能对读和写重新排序。Linux提供了确保顺序的指令称做屏障。其操作见下表：

 

方法

描述

rmb( )

  阻止跨跃屏障的载入动作发生重排序

read_barrier_depends( )

  阻止跨跃屏障的具有数据依赖关系的载入动作重排序

wmb( )

  阻止跨跃屏障的存储动作发生重排序

mb( )

  阻止跨跃屏障的载入和存储动作重新排序

smp_rmb( )

  在SMP上提供rmb( )功能，在UP上提供barrier( )功能

smp_read_barrier_depends( )

  在SMP上提供read_barrier_depends( )功能，在UP上提供barrier( )功能

smp_wmb( )

  在SMP上提供wmb( )功能，在UP上提供barrier( )功能

smp_mb( )

  在SMP上提供mb( )功能，在UP上提供barrier( )功能

barrier( )

  组织编译器跨屏障对载入或存储操作进行优化

转载：http://blog.chinaunix.net/uid-10469829-id-2953001.html