Linux内核中的锁——知识点 1. 信号量 2. completions机制 3. 自旋锁 4. 其他锁

 系统中的锁，说简单点就是为了保护共享资源，从而更好的实现系统并发。本文对内核中的相关常用锁进行了介绍以及部分使用。

1.  

信号量

第一个经验法则是设计驱动时在任何可能的时候记住避免共享的资源。

全局变量远远不是共享数据的唯一方式

信号量Semaphores是一个单个整型值, 结合有一对函数, 典型地称为 P 和 V 。当信号量用作互斥，阻止多个进程同时在同一个临界区内运行

-- 它们的值将初始化为 1. 这样的信号量在任何给定时间只能由一个单个进程或者线程持有. 以这种模式使用的信号量有时称为一个mutex互斥锁。

内核中实现

Linux 内核提供了信号量实现, 内核代码必须包含 <asm/semaphore.h>. 相关的类型是 struct

semaphore; 实际可以用 几种方法来声明和初始化. 一种是直接创建一个, 接着使用 sema_init 来设定它:

sema_init(struct semaphore *sem, int val)

其中val是初始化的值。

如果是互斥锁，val就设置为１ 即可。

获取信号量可以使用：

down_interruptible，获取信号量除非中断打断。

down_trylock,尝试获取信号量但不等待。

down,尝试获取信号量，如果没有获取则等待直到获取。

和down对应的方法是up函数。

up(struct semaphore

*sem)

            除了互斥锁外，还有读写信号量，这样读写可以有更好的保障。

一个 rwsem 允许一个读者或者不限数目的读者来持有信号量。写者有优先权; 当一个写者试图进入临界区, 就不会允许读者进入直到所有的写者完成了它们的工作. 这个实现可能导致读者饥饿 -- 读者被长时间拒绝存取。 所以， rwsem 最好用在很少请求写的时候, 并且写者只占用短时间。

2.  

completions机制

　　如果信号量有很多竞争,性能会受损并且加锁方案需要重新审视.在调用down 的线程将几乎是一直不得不等待.在一些情况中, 信号可能在调用 up 的进程用完它之前消失.

在2.4.7 内核中增加了

"completion" 接口 ，一个轻量级机制: 允许一个线程告诉另一个线程工作已经完成. 为使用 completion,代码必须包含 <linux/completion.h>

通过DECLARE_COMPLETION(work)来静态创建。

也可以动态创建，通过init_completion来初始化。

init_completion - Initialize a dynamically allocated

completion

使用中进程可以调用wait_for_completion来等待，这是一个不可中断的等待，也不能杀死了。

     另一方面，complete和complete_all可以唤醒wait_for_completion的进程。

complete 只唤醒一个等待的线程, 而

complete_all 允许所有都继续.  

　　completion 机制的典型使用是在模块退出时。当模块准备被清理时, exit函数告知线程退出并且等待结束。内核包含一个特殊的函数complete_and_exit给线程使用.

void complete_and_exit(struct completion *comp, long code)

{

if (comp)

                complete(comp);

do_exit(code);

}

代码实例   

使用实例如下，创建一个字符设备，关联一个读操作和写操作。

#include <linux/module.h>

#include <linux/init.h>

#include <linux/sched.h>  /* current and everything */

#include <linux/kernel.h> /* printk() */

#include <linux/fs.h>     /* everything... */

#include <linux/types.h>  /* size_t */

#include <linux/completion.h>

MODULE_LICENSE("Dual BSD/GPL");

static int complete_major = 0;

DECLARE_COMPLETION(comp);

ssize_t complete_read (struct file *filp, char __user *buf, size_t count, loff_t *pos)

printk(KERN_DEBUG "process %i (%s) going to sleep\n",

                        current->pid,

current->comm);

wait_for_completion(&comp);

printk(KERN_DEBUG "awoken %i (%s)\n", current->pid, current->comm);

return 0; /* EOF */

ssize_t complete_write (struct file *filp, const char __user *buf, size_t count,

                loff_t *pos)

printk(KERN_DEBUG "process %i (%s) awakening the readers...\n",

complete(&comp);

return count; /* succeed, to avoid retrial

*/

struct file_operations complete_fops = {

.owner = THIS_MODULE,

.read =  complete_read,

.write = complete_write,

};

int complete_init(void)

int result;

/*

* Register your major, and accept a dynamic number

        result = register_chrdev(complete_major, "complete", &complete_fops);

if (result < 0)

                return result;

if (complete_major == 0)

                complete_major = result; /* dynamic */

return 0;

void complete_cleanup(void)

unregister_chrdev(complete_major, "complete");

module_init(complete_init);

module_exit(complete_cleanup);

3.  

自旋锁

内核中大部分加锁通过自旋锁来完成。自旋锁用在不能睡眠的代码中，例如中断处理。

自旋锁概念上简单，是一个互斥设备,有２个值:"上锁"和"解锁".要想获取一个特殊锁的代码，需要测试相关的位. 如果锁是可用的, 这个"上锁"位被置位并且代码继续进入临界区.如果这个锁已经被别人获得, 代码进入一个紧凑的循环中反复检查这个锁, 直到它变为可用。

"测试并置位"操作必须以原子方式进行, 以便只有一个线程能够获得锁

自旋锁是设计用在多处理器系统上，如果一个非抢占的单处理器系统进入一 个锁上的自旋,

它将永远自旋; 没有其他的线程再能够获得 CPU 来释放这个锁. 在没有打开抢占的单处理器系统上自旋锁操作被优化为什么不作，如果是支持抢占的单处理系统也是正确加锁的。

内核实现

自旋锁的核心规则是任何代码必须在持有自旋锁时, 是原子性的，不能睡眠（其实而很多内核函数可能睡眠）。

      持有自旋锁时禁止中断( 只在本地 CPU )

            自旋锁必须一直是尽可能短时间的持有

自旋锁原语要求的包含文件是 <linux/spinlock.h>

实际所的类型是spinlock_t.像其他数据结构一样, 一个自旋锁必须初始化,初始化函数spin_lock_init。

            获取自旋锁的函数是spin_lock。

            释放自旋锁是spin_unlock函数。

            此外还有三对获取自旋锁函数如下：

            spin_lock_irqsave/ spin_unlock_irqrestore：在获得锁之前，禁止本地CPU中断，中断状态保存在flags.

            spin_lock_irq/spin_unlock_irq进入之前中断时开启的，不用保存中断状态，用完继续开启中断即可。

            spin_lock_bh/spin_unlock_bh禁用软中断。

            另外还有非阻塞的自旋锁操作：spin_trylock,

spin_trylock_bh

读写自旋锁

读写锁有一个类型 rwlock_t, 在<linux/spinlokc.h> 中定义 ,类似信号量中的读写信号量.

            使用rwlock_init来初始化。操作和spin_lock基本类似。

read_lock/read_unlock

read_lock_irqsave/read_unlock_irqsave

read_lock_irq/read_unlock_irq

read_lock_bh/read_unlock_bh

write_lock/write_unlock

write_trylock

write_lock_irqsave/write_unlock_irqsave

write_lock_irq/write_unlock_irq

write_lock_bh/write_unlock_bh

读写锁会引起读饥饿，要在多读少写场景使用。

4.  

其他锁

因为加锁机制是实现存在缺陷，有些情况不需要加锁。例如环形缓冲区，在网络适配器中的使用。

还可以使用原子变量atomic_t来替代一个完整的加锁体制。对一个变量实现加锁显得有些过分，原子变量的操作如下。

void atomic_set(atomic_t *v, int i);

atomic_t v = ATOMIC_INIT(0);

int

atomic_read(atomic_t *v);

void atomic_add(int i, atomic_t *v);

void

atomic_sub(int i, atomic_t *v);

void atomic_inc(atomic_t *v);

void atomic_dec(atomic_t *v);

……

     atomic_t在整数算术时是不错的，但是如果要以原子方式操作可能就不行了。

     原子位操作非常快, 因为它们使用单个机器指令来进行操作, 而在任何时候低层平台做的 时候不用禁止中断，因为中断来不及中断原子位操作。如：

set_bit(nr, void *addr);

clear_bit(nr, void *addr);

change_bit(nr, void *addr);

     不过在新代码中，还是建议使用自旋锁，至少别人知道是在做什么。

seqlock锁

spin_lock对于临界区是不做区分的。而读写锁是对临界区做读写区分，写进程进入时需要等待读进程退出临界区。为了保护写进程的优先权，并使得写进程可以更快的获得锁，引入了顺序锁。

顺序锁的思想是：对某一个共享数据读取的时候不加锁，写的时候加锁。在读取者和写入者之间引入变量sequence，读取者在读取之前读取sequence, 读取之后再次读取此值，如果不相同，则说明本次读取操作过程中数据发生了更新，需要重新读取。而对于写进程在写入数据的时候就需要更新sequence的值。

初始化可以如下：

seqlock_t

lock1 = SEQLOCK_UNLOCKED;//静态初始化

lock2;

seqlock_init(&lock2);//动态初始化

读之前调用函数：read_seqbegin，读完继续调用read_seqretry。

     如果是写则是：write_seqlock，写完调用write_sequnlock

     考虑到中断影响，读写都有irqsave,irq,bh版本。

RCU

读取-拷贝-更新(RCU) 是一个高级的互斥方法,当数据结构需要改变, 写线程做一个拷贝, 改变这个拷贝, 接着使相关的指针对准新的版本.RCU 的代码应当包含 <linux/rcupdate.h>。使用一个 RCU-保护的数据结构的代码应当用 rcu_read_lock 和 rcu_read_unlock 调用将它的引用包含起来.