配套的代码可以从本号的github下载，https://github.com/shuningzhang/linux_kernel
前面我们介绍了Linux内核中的自旋锁的使用和具体的实现。接下来我们介绍一下在Linux内核中使用比较广泛的另外一种锁机制---信号量。信号量又称为信号灯（semaphore），其与自旋锁不同的地方是它可以引起调用者休眠，也就是信号量本质上是一种睡眠锁。如果有一个任务试图获得一个不可用（已经被占用）的信号量时，信号量会将其推进一个等待队列，然后让其睡眠。这时处理器能重获自由，从而去执行其他代码。当持有的信号量可用（被释放后），处于等待队列中的那个任务将被唤醒，并将获得该信号量。
信号量一个有用的特性是它可以同时允许任意数量的锁持有者，而自旋锁和互斥锁在一个时刻最多允许一个任务持有它。信号量同时允许的持有者数量可以在声明信号量时指定。这个值称为使用者数量（usage count）或简单的叫做数量（count）。通常情况下，信号量和自旋锁一样，在一个时刻仅允许有一个锁持有者。这时计数等于1，这样的信号量被称为二值信号量或者称为互斥信号量。另一方面，初始化时也可以把数量设置为大于1的非0值。这种情况，信号量被称为计数信号量（counting semaphore），它允许在同一时刻至多有count个锁持有者。
基本接口
本节我们介绍一下信号量的基本接口，信号量的用法与自旋锁非常相似（分为初始化、加锁和解锁三部分）。主要需要注意的地方是信号量会引起休眠，因此不要在不能休眠的地方使用信号量。
信号量初始化
void sema_init (struct semaphore *sem, int val);
void init_MUTEX (struct semaphore *sem); //将sem的值置为1，表示资源空闲
void init_MUTEX_LOCKED (struct semaphore *sem); //将sem的值置为0，表示资源忙
信号量加锁
void down(struct semaphore * sem); // 可引起睡眠
int down_interruptible(struct semaphore * sem);
// down_interruptible能被信号打断
int down_trylock(struct semaphore * sem);
// 非阻塞函数，不会睡眠。无法锁定资源则马上返回
信号量解锁
void up(struct semaphore * sem);
应用示例
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/socket.h>
#include <net/sock.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/semaphore.h>
#define BUF_SIZE 1024
struct task_data {
int progress;
};
struct task_struct *main_task;
struct task_struct *client_task;
/* 在这里定义信号量及要保护的数据，这里只是为了说明用法
* 实际生产中不会这么用，因为对于一个简单数据，可以通过
* 原子变量实现。 */
struct semaphore lock;
struct task_data thread_data;
static inline void sleep(unsigned sec)
{
__set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(sec * HZ);
}
/* 这个是2个线程中的一个，只是为了说明自旋锁的用法。 */
static int multhread_server(void *data)
{
struct task_data *cur = (struct task_data *)data;
while (!kthread_should_stop()) {
/* 通过信号量进行临界区保护，在信号量保护的
* 临界区中是可以休眠的。 */
down(&lock);
printk(KERN_NOTICE "server thread run begin %d\n", cur->progress);
sleep(1);
/* 临界区，也就是被保护的数据的操作 */
cur->progress ++;
printk(KERN_NOTICE "server thread run after %d\n", cur->progress);
/* 信号量解锁 */
up(&lock);
}
return 0;
}
static int multhread_client(void *data)
{
struct task_data *cur = (struct task_data *)data;
while(!kthread_should_stop()) {
down(&lock);
printk(KERN_NOTICE "client thread run begin %d\n", cur->progress);
sleep(1);
cur->progress += 2;
printk(KERN_NOTICE "client thread run after %d\n", cur->progress);
up(&lock);
}
return 0;
}
static int multhread_init(void)
{
ssize_t ret = 0;
thread_data.progress = 0;
sema_init(&lock, 1);
printk("Hello, socket \n");
main_task = kthread_run(multhread_server,
&thread_data,
"multhread_server");
if (IS_ERR(main_task)) {
ret = PTR_ERR(main_task);
goto failed;
}
client_task = kthread_run(multhread_client,
&thread_data,
"multhread_client");
if (IS_ERR(client_task)) {
ret = PTR_ERR(client_task);
goto client_failed;
}
return ret;
client_failed:
kthread_stop(main_task);
failed:
return ret;
}
static void multhread_exit(void)
{
printk("Bye!\n");
kthread_stop(main_task);
kthread_stop(client_task);
}
module_init(multhread_init);
module_exit(multhread_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("SunnyZhang<shuningzhang@126.com>");
基本原理
本节介绍一下信号量的具体实现。照例，我们先从信号量的数据结构走起。下面是信号量的数据结构，可以看出其由自旋锁、计数和一个链表头组成。
struct semaphore {
raw_spinlock_t lock;
unsigned int count; //标示信号量是否可用，也即是否处于加锁状态
struct list_head wait_list;
};
这里自旋锁 lock用于保护数据的访问，而链表 wait_list则用于记录有那些线程在等待该信号量。
如果之前看过本号前面的文章，结合这里关于结构体的介绍，估计能够猜出来信号量的实现方式。其大概原理是当有线程企图加锁的时候调用加锁函数（down），如果count大于0则表示可以加锁，并加锁成功。如果小于等于0则表示不可加锁，此时线程将被放入wait_list队列，然后线程被调度出CPU（休眠）。
加锁流程分析
如下代码是加锁的接口，可以看到入参就是上面定义的信号量的结构体指针。在进行实际操作之前需要使用自旋锁进行保护。
void down(struct semaphore *sem)
{
unsigned long flags;
/* 自旋锁保护临界区 */
raw_spin_lock_irqsave(&sem->lock, flags);
/* 是否可以直接加锁， 如果大于0则可以加锁成功 */
if (likely(sem->count > 0))
sem->count--;
else
__down(sem); /* 加锁等待流程， 调用实际执行函数 */
raw_spin_unlock_irqrestore(&sem->lock, flags);
}
函数的调用关系是down->__down->__down_common，实际执行函数是__down_common。下面是函数的源代码，具体请看函数内的注释。
static inline int __sched __down_common(struct semaphore *sem, long state,
long timeout)
{
struct task_struct *task = current;
struct semaphore_waiter waiter;
/* 记录受阻的线程，并且初始化等待任务。 */
list_add_tail(&waiter.list, &sem->wait_list);
waiter.task = task;
waiter.up = false;
/* 引起睡眠的逻辑就在这里，下面这段代码将本
* 线程调度出去，并且在加锁的线程没有解锁的
* 情况下回持续循环休眠。 */
for (;;) {
if (signal_pending_state(state, task))
goto interrupted;
if (unlikely(timeout <= 0))
goto timed_out;
__set_task_state(task, state);
raw_spin_unlock_irq(&sem->lock);
timeout = schedule_timeout(timeout);
raw_spin_lock_irq(&sem->lock);
if (waiter.up)
return 0;
}
timed_out:
list_del(&waiter.list);
return -ETIME;
interrupted:
list_del(&waiter.list);
return -EINTR;
}
信号量解锁
信号量解锁的流程比较简单，如下是其实现代码，主函数比较简单，这里不做解释了。
void up(struct semaphore *sem)
{
unsigned long flags;
raw_spin_lock_irqsave(&sem->lock, flags);
if (likely(list_empty(&sem->wait_list)))
sem->count++;
else
__up(sem);
raw_spin_unlock_irqrestore(&sem->lock, flags);
}
需要真正解锁的情况下将执行本函数。可以看到本函数的实现也并不复杂，在这里首先从队列中取出第一个等待的任务，然后调用线程唤醒函数进行唤醒。
static noinline void __sched __up(struct semaphore *sem)
{
struct semaphore_waiter *waiter = list_first_entry(&sem->wait_list,
struct semaphore_waiter, list);
list_del(&waiter->list);
waiter->up = true;
wake_up_process(waiter->task);
}
能力增强
除了上面的基本的接口外，还有一些辅助功能的接口。比如down_trylock可以探测一下是否可以加锁。而down_interruptible则设置当前线程的状态为TASK_INTERRUPTIBLE状态。
extern int __must_check down_interruptible(struct semaphore *sem);
extern int __must_check down_killable(struct semaphore *sem);
extern int __must_check down_trylock(struct semaphore *sem);
extern int __must_check down_timeout(struct semaphore *sem, long jiffies);
