linux信号量的实现细节

信号量是操作系统非常重要的一种进程同步方式,今天先分析下实现细节

先看下结构体

< include/linux/semaphore.c >

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

lock: 自旋锁变量，用于保护count和wait_list

count: 表示允许同时获取该信号量的进程数量

wait_list: 等待本信号量的所有睡眠进程

初始化函数

< include/linux/semaphore.c >

#define __SEMAPHORE_INITIALIZER(name, n)				\
{									\
	.lock		= __RAW_SPIN_LOCK_UNLOCKED((name).lock),	\
	.count		= n,						\
	.wait_list	= LIST_HEAD_INIT((name).wait_list),		\
}

#define DEFINE_SEMAPHORE(name)	\
	struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1)

static inline void sema_init(struct semaphore *sem, int val)
{
	static struct lock_class_key __key;
	*sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
	lockdep_init_map(&sem->lock.dep_map, "semaphore->lock", &__key, 0);
}

看得出，支持两种初始化方式，一种是宏定义的方式声明，一种是显式调用

信号量对外接口

< include/linux/semaphore.c >

extern void down(struct semaphore *sem);
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);
extern void up(struct semaphore *sem);

分析具体函数

down_interruptible()

< kernel/locking/semaphore.c >

/**
 * down_interruptible - acquire the semaphore unless interrupted
 * @sem: the semaphore to be acquired
 *
 * Attempts to acquire the semaphore.  If no more tasks are allowed to
 * acquire the semaphore, calling this function will put the task to sleep.
 * If the sleep is interrupted by a signal, this function will return -EINTR.
 * If the semaphore is successfully acquired, this function returns 0.
 */
int __sched down_interruptible(struct semaphore *sem)
{
	unsigned long flags;
	int result = 0;

	might_sleep();
	raw_spin_lock_irqsave(&sem->lock, flags);
	if (likely(sem->count > 0))
		sem->count--;
	else
		result = __down_interruptible(sem);
	raw_spin_unlock_irqrestore(&sem->lock, flags);

	return result;
}
EXPORT_SYMBOL(down_interruptible);

内部执行函数是__down_interruptible()，我们进一步分析

< kernel/locking/semaphore.c >

static noinline int __sched __down_interruptible(struct semaphore *sem)
{
	return __down_common(sem, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}

static inline int __sched __down_common(struct semaphore *sem, long state,
					long timeout)
{
	int ret;

	trace_contention_begin(sem, 0);
	ret = ___down_common(sem, state, timeout);
	trace_contention_end(sem, ret);

	return ret;
}

最终实现函数是___down_common()

< kernel/locking/semaphore.c >

/*
 * Because this function is inlined, the 'state' parameter will be
 * constant, and thus optimised away by the compiler.  Likewise the
 * 'timeout' parameter for the cases without timeouts.
 */
static inline int __sched ___down_common(struct semaphore *sem, long state,
								long timeout)
{
	struct semaphore_waiter waiter;

	list_add_tail(&waiter.list, &sem->wait_list);
	waiter.task = current;
	waiter.up = false;

	for (;;) {
		if (signal_pending_state(state, current))
			goto interrupted;
		if (unlikely(timeout <= 0))
			goto timed_out;
                /* 设置进程状态，我们这里是TASK_INTERRUPTIBLE */
		__set_current_state(state);  
		raw_spin_unlock_irq(&sem->lock);
                /* 主动将进程调度出去，说明这里是主动调度 */
		timeout = schedule_timeout(timeout);      
		raw_spin_lock_irq(&sem->lock);
		if (waiter.up)                                          
                /* 当waiter.up为true时，说明进程是被信号量正常唤醒，如果不是true，可能被信号唤醒或者因为超时被唤醒  */
			return 0;
	}

 timed_out:
	list_del(&waiter.list);
	return -ETIME;

 interrupted:
	list_del(&waiter.list);
	return -EINTR;
}

看看up()函数

< kernel/locking/semaphore.c >

/**
 * up - release the semaphore
 * @sem: the semaphore to release
 *
 * Release the semaphore.  Unlike mutexes, up() may be called from any
 * context and even by tasks which have never called down().
 */
void __sched 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);
}
EXPORT_SYMBOL(up);

/* 这里是具体实现位置 */
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的置位，说明信号量获得后唤醒进程 */
	waiter->up = true;                                 
	wake_up_process(waiter->task);         /* 唤醒睡眠的进程 */
}