信号量

信号量

Linux中的信号量是一种睡眠锁

睡眠机制：如果一个任务试图获取一个不可用（正在被占用）的信号量时，信号量会将其推进一个等待队列，然后让其睡眠。这时处理器能重获自由，从而去执行其他代码。当持有的信号量可用（被释放）后，处于等待队列的那个任务将被唤醒，并获得该信号量。

• 由于争用信号量的进程在等待锁重新变为可用时会睡眠，所以信号量适用于锁会被长期持有的情况。

• 由于执行线程在锁被征用时会睡眠，所以只能在进程上下文中才能获取信号量锁，因为在中断上下文中是不能进行调度的。

• 等待信号量时会陷入睡眠，因此在占用信号量的同时不能占用自旋锁，因为在等待信号量时可能会睡眠，而持有自旋锁的时候是不允许睡眠的。

计数信号量

初始化时设置信号量的数值大于1的非0值，在这种情况下允许在一个时刻同时有多个锁持有者，这种信号量称为计数信号量。

计数信号量不能用作强制互斥，因为它允许多个执行线程同时访问临界区。内核中使用的不多。

二值信号量

顾名思义，与计数信号量相对应，二值信号量即信号量值非0即1，也称为互斥信号量。在使用信号量时大部分用的都是二值信号量。

创建和初始化信号量

信号量的实现与体系结构相关，具体定义在<asm/semaphore.h>中。(我只在include/linux下找到了这个文件)

/* Please don't access any members of this structure directly */
struct semaphore {
	spinlock_t		lock;
	unsigned int		count;
	struct list_head	wait_list;
};

静态声明信号量：

struct semaphore name;
sema_init(&name , count);

如果是互斥信号量，还可以简化声明：

static DECLARE_MUTEX(name);

更常见的情况： 信号量作为一个大数据结构的一部分动态创建，此时只有指向该动态创建的信号量的间接指针，可以使用如下函数对它进行初始化：

sema_init(sem,count);//sem是指针，count是信号量的使用者数量

与前面类似，初始化一个动态创建的互斥信号量也可以使用如下函数：

init_MUTEX(sem);

使用信号量

方法	描述
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 *)	以释放指定的信号量，如果睡眠队列不空 则唤醒其中一个任务

内核中对down的细化操作

extern void down(struct semaphore *sem);

具体函数实现如下：

void down(struct semaphore *sem)
{
	unsigned long flags;

	spin_lock_irqsave(&sem->lock, flags);
	if (likely(sem->count > 0))
		sem->count--;
	else
		__down(sem);
	spin_unlock_irqrestore(&sem->lock, flags);
}

显然，信号量的操作使用了自旋锁，这从上面信号量的声明也可以看出，对信号量的操作需要使用自旋锁同步，防止信号量操作产生竞争冒险。

在spinlock锁区域内部，通过判断当前信号量是否为0进行相应操作，若大于0则自减即可；但是如果信号量被持有，则调用__down函数进一步处理。具体函数如下：

static noinline void __sched __down(struct semaphore *sem)
{
	__down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}

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 = 0;

	for (;;) {
		if (signal_pending_state(state, task))
			goto interrupted;
		if (timeout <= 0)
			goto timed_out;
		__set_task_state(task, state);
		spin_unlock_irq(&sem->lock);
		timeout = schedule_timeout(timeout);
		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;
}

注意，这里对task的状态赋值state为uninterruptible

处理过程大概目的就是使当前请求线程进入睡眠等待队列，内核中为信号量等待队列单独设计了结构体，内容如下：

struct semaphore_waiter {
	struct list_head list;
	struct task_struct *task;
	int up;
};

这个结构体中的up在后面的for循环中一直在被检测，直到被置1的时候才会返回，否则线程依然会重新陷入睡眠，或者调度时间time_out耗尽返回错误。

内核中对up的细化操作

extern void up(struct semaphore *sem);

void up(struct semaphore *sem)
{
	unsigned long flags;

	spin_lock_irqsave(&sem->lock, flags);
	if (likely(list_empty(&sem->wait_list)))
		sem->count++;
	else
		__up(sem);
	spin_unlock_irqrestore(&sem->lock, flags);
}

同理，up的操作也使用了自旋锁来保持信号量操作的互斥，在spinlock锁区域进行判断，当睡眠等待队列为空时代表没有人在等待该信号量，直接将信号量释放即可。但是当队列非空时要进行一个重要的操作：唤醒睡眠进程

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 = 1;
	wake_up_process(waiter->task);
}

显然，该操作只对等待链表的第一个成员进行操作，避免多个睡眠进程争用信号量。最后将上文提到的up置1，使睡眠进程唤醒。

读/写信号量

与自旋锁一样，信号量也有区分读/写访问的功能。与读写自旋锁和普通自旋锁之间的关系差不多，读写信号量也要比普通信号更具优势。

读写信号量在内核中由rw_semaphore表示，定义在文件<linux/rwsem.h>中。（2.6.34声明在rwsem-spinlock.h中）

/*
 * the rw-semaphore definition
 * - if activity is 0 then there are no active readers or writers
 * - if activity is +ve then that is the number of active readers
 * - if activity is -1 then there is one active writer
 * - if wait_list is not empty, then there are processes waiting for the semaphore
 */
struct rw_semaphore {
	__s32			activity;
	spinlock_t		wait_lock;
	struct list_head	wait_list;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map dep_map;
#endif
};

通过注释可见，读写信号量引入了activity表征读写状态，同时也使用了自旋锁和等待队列。

同样，读写信号量也可以静态声明：

#define DECLARE_RWSEM(name) 
	struct rw_semaphore name = __RWSEM_INITIALIZER(name)

或者是动态声明：

/*
 * Initialize an rwsem:
 */
void __init_rwsem(struct rw_semaphore *sem, const char *name,
		  struct lock_class_key *key)
{
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	/*
	 * Make sure we are not reinitializing a held semaphore:
	 */
	debug_check_no_locks_freed((void *)sem, sizeof(*sem));
	lockdep_init_map(&sem->dep_map, name, key, 0);
#endif
	sem->count = RWSEM_UNLOCKED_VALUE;
	spin_lock_init(&sem->wait_lock);
	INIT_LIST_HEAD(&sem->wait_list);
}

注意：所有的读写信号量都是互斥信号量。（从结构体描述来看，它只针对写互斥）

对其操作也使用up和down：

extern void __down_read(struct rw_semaphore *sem);
extern int __down_read_trylock(struct rw_semaphore *sem);
extern void __down_write(struct rw_semaphore *sem);
extern void __down_write_nested(struct rw_semaphore *sem, int subclass);
extern int __down_write_trylock(struct rw_semaphore *sem);
extern void __up_read(struct rw_semaphore *sem);
extern void __up_write(struct rw_semaphore *sem);
extern void __downgrade_write(struct rw_semaphore *sem);
extern int rwsem_is_locked(struct rw_semaphore *sem);

函数的使用不作赘述。

但是要注意：这里的trylock操作与普通信号量的返回方式截然相反：读写信号量被争用返回0，而申请成功返回非0值。

没有必要的时候用普通信号量就足够了。。。