Linux内核读写信号量 rwsem实现分析.doc

读写信号量
信号量根据用途不同，可以区分读和写两种操作方式。
为提高信号量的效率引入rwsem，此锁使用的机会比较少，适用于读频繁的情况。
头文件<linux/rwsem.h>，类型struct rw_semaphore，其必须在运行时进行显示的初始化：
void init_rwsem(struct rw_semaphore* sem);
对于只读访问，使用如下PV：
void down_read(struct rw_semaphore* sem);
int down_read_trylock(struct rw_semaphore* sem);
//成功返回非零，其他返回零（特殊）
void up_read(struct rw_semaphore* sem);
对于写入分别是：down_write, down_write_trylock, up_write
rwsem允许一个写入者或无限个读者拥有该信号量。
在2.6.21内核rwsem的实现中，所有读者和写者排队处理，处理完写者前面的所有读者后才处理到写者。
在rwsem-spinlock.c中down_read实现如下：
/*
* get a read lock on the semaphore
*/
void fastcall __sched __down_read(struct rw_semaphore *sem)
{
struct rwsem_waiter waiter;
struct task_struct *tsk;

spin_lock_irq(&sem->wait_lock);
// 没有写者的情况下直接获取读者锁
if (sem->activity >= 0 && list_empty(&sem->wait_list)) {
/* granted */
sem->activity++;
spin_unlock_irq(&sem->wait_lock);
goto out;
}
// 否则有写者的情况下，加入到排队队列中
tsk = current;
set_task_state(tsk, TASK_UNINTERRUPTIBLE);// 进程不可中断

/* set up my own style of waitqueue */
waiter.task = tsk;
waiter.flags = RWSEM_WAITING_FOR_READ;
get_task_struct(tsk);
list_add_tail(&waiter.list, &sem->wait_list);// 加入到排队队列中

/* we don't need to touch the semaphore struct anymore */
spin_unlock_irq(&sem->wait_lock);

/* wait to be given the lock */
for (;;) {
// task有效的时候，继续调度，在up中会被设置成NULL，进而去调度
if (!waiter.task)
break;
schedule();
set_task_state(tsk, TASK_UNINTERRUPTIBLE);
}
tsk->state = TASK_RUNNING;
out:
;
}
/*
* release a read lock on the semaphore
*/
void fastcall __up_read(struct rw_semaphore *sem)
{
unsigned long flags;
spin_lock_irqsave(&sem->wait_lock, flags);
// 释放读者锁的时候，若wait_list不为空的时候，证明等待队列中存在写者锁请求
if (--sem->activity == 0 && !list_empty(&sem->wait_list))
sem = __rwsem_wake_one_writer(sem);// 此函数下面分析
spin_unlock_irqrestore(&sem->wait_lock, flags);
}
down_write函数会直接调用以下函数
/* get a write lock on the semaphore
* - we increment the waiting count anyway to indicate an exclusive lock
*/
void fastcall __sched __down_write_nested(struct rw_semaphore *sem, int subclass)
{
struct rwsem_waiter waiter;
struct task_struct *tsk;
spin_lock_irq(&sem->wait_lock);
// activity == 0且队列中没有等待时，此时没有读者和写者，直接获取写者锁。
if (sem->activity == 0 && list_empty(&sem->wait_list)) {
/* granted */
sem->activity = -1;
spin_unlock_irq(&sem->wait_lock);
goto out;
}
// 否则去排队
tsk = current;
set_task_state(tsk, TASK_UNINTERRUPTIBLE);
/* set up my own style of waitqueue */
waiter.task = tsk;
waiter.flags = RWSEM_WAITING_FOR_WRITE;
get_task_struct(tsk);
list_add_tail(&waiter.list, &sem->wait_list);
/* we don't need to touch the semaphore struct anymore */
spin_unlock_irq(&sem->wait_lock);
/* wait to be given the lock */
for (;;) {
if (!waiter.task)
break;
schedule();
set_task_state(tsk, TASK_UNINTERRUPTIBLE);
}
tsk->state = TASK_RUNNING;
out:
;
}
down_write函数会被__rwsem_wake_one_writer唤醒。
/*
* wake a single writer
*/
static inline struct rw_semaphore *
__rwsem_wake_one_writer(struct rw_semaphore *sem)
{
struct rwsem_waiter *waiter;
struct task_struct *tsk;
sem->activity = -1; // 表示当前没有写者锁
waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
list_del(&waiter->list);
// 设置waiter->task为NULL，并唤醒进程
tsk = waiter->task;
smp_mb();
waiter->task = NULL;
wake_up_process(tsk);
put_task_struct(tsk);
return sem;
}
Up_write函数如下：
/*
* release a write lock on the semaphore
*/
void fastcall __up_write(struct rw_semaphore *sem)
{
unsigned long flags;
spin_lock_irqsave(&sem->wait_lock, flags);
sem->activity = 0; // 没有读者和写者
// 如果队列不为空，则唤醒，第二个参数1的意思是所有的读者和写者
if (!list_empty(&sem->wait_list))
sem = __rwsem_do_wake(sem, 1);
spin_unlock_irqrestore(&sem->wait_lock, flags);
}
/* handle the lock release when processes blocked on it that can now run
* - if we come here, then:
* - the 'active count' _reached_ zero
* - the 'waiting count' is non-zero
* - the spinlock must be held by the caller
* - woken process blocks are discarded from the list after having task zeroed
* - writers are only woken if wakewrite is non-zero */
static inline struct rw_semaphore * __rwsem_do_wake(struct rw_semaphore *sem, int wakewrite)
{
struct rwsem_waiter *waiter;
struct task_struct *tsk;
int woken;
waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
// 若wakewrite为0则只唤醒读者，为1时唤醒所有写者和读者
if (!wakewrite) {
if (waiter->flags & RWSEM_WAITING_FOR_WRITE)
goto out;
goto dont_wake_writers;
}
// 唤醒写者，list的第一个元素
if (waiter->flags & RWSEM_WAITING_FOR_WRITE) {
sem->activity = -1;
list_del(&waiter->list);
tsk = waiter->task;
/* Don't touch waiter after ->task has been NULLed */
smp_mb();
waiter->task = NULL;
wake_up_process(tsk);
put_task_struct(tsk);
goto out;
}
// 唤醒所有的读者，activity值直接加到位
/* grant an infinite number of read locks to the front of the queue */
dont_wake_writers:
woken = 0;
while (waiter->flags & RWSEM_WAITING_FOR_READ) {
struct list_head *next = waiter->list.next;
list_del(&waiter->list);
tsk = waiter->task;
smp_mb();
waiter->task = NULL;
wake_up_process(tsk);
put_task_struct(tsk);
woken++;
if (list_empty(&sem->wait_list))
break;
waiter = list_entry(next, struct rwsem_waiter, list);
}
sem->activity += woken; // activity值直接加到位
out:
return sem;
}