linux 内核同步互斥技术之读写信号量

读写信号量

读写信号量是对互斥信号量的改进，允许多个读者同时进入临界区，读者和写者互斥，写者和写者互斥，适合在以读为主的情况使用。
读写信号量的定义如下：
include/linux/rwsem.h
struct rw_semaphore {
    atomic_long_t count;
    struct list_head wait_list;
    raw_spinlock_t wait_lock;
#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
    struct optimistic_spin_queue osq; /* spinner MCS lock */
    /*
     * Write owner. Used as a speculative check to see
     * if the owner is running on the cpu.
     */
    struct task_struct *owner;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
    struct lockdep_map  dep_map;
#endif
};
初始化静态读写信号量的方法如下：
DECLARE_RWSEM(name);

在运行时动态初始化读写信号量的方法如下：
init_rwsem(sem);

申请读锁的函数如下
（1） void down_read(struct rw_semaphore *sem)；
申请读锁，如果写者占有写锁或者正在等待写锁，那么进程深度睡眠。
（2） int down_read_trylock(struct rw_semaphore *sem)；
尝试申请读锁，不会等待。如果申请成功，返回 1；否则返回 0。

释放读锁的函数如下：
void up_read(struct rw_semaphore *sem);

申请写锁的函数如下
（1） void down_write(struct rw_semaphore *sem);
申请写锁，如果写者占有写锁或者读者占有读锁，那么进程深度睡眠。
（2） int down_write_killable(struct rw_semaphore *sem);
申请写锁，如果写者占有写锁或者读者占有读锁，那么进程中度睡眠。
（3） int down_write_trylock(struct rw_semaphore *sem);
尝试申请写锁，不会等待。如果申请成功，返回 1；否则返回 0。

占有写锁以后，可以把写锁降级为读锁，函数如下
void downgrade_write(struct rw_semaphore *sem);
释放写锁的函数如下：
void up_write(struct rw_semaphore *sem);

rw_semaphore 我之前一直没有从代码理解如何实现的。只知道理论上是可以多个读者去读，如果有写者就不能去读。最近看这块代码，代码实现上是：在等待队列中如果有写者，把写者之前的读者唤醒，写者还是在等待队列中。如果等待队列中写者之前没有读者那就只唤醒写者，写者后面的还继续在等待队列中等待。

实例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kthread.h> 
#include <linux/rwsem.h>
#include <linux/delay.h>

static DECLARE_RWSEM(my_rw_semaphore);
struct task_struct * task1;
struct task_struct * task2;
struct task_struct * task3;
struct task_struct * task4;
struct task_struct * task5;

int thread_print_first(void *p) {
    if(kthread_should_stop()){
        return 0;
    }
    printk(KERN_ALERT"Hello World:first writer\n");
    down_write(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:first writting\n");
    msleep(5000);
    up_write(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:first written\n");
    do {
        msleep(1000);
    }
    while(!kthread_should_stop());
    return 0;
}

int thread_print_second(void *p) {
    if(kthread_should_stop()){
        return 0;
    }
    printk(KERN_ALERT"Hello World:second reader\n");
    down_read(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:second reading\n");
    msleep(5000);
    up_read(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:second read\n");
    do {
        msleep(1000);
    }
    while(!kthread_should_stop());
    return 0;
}

int thread_print_third(void *p) {
    if(kthread_should_stop()){
        return 0;
    }
    printk(KERN_ALERT"Hello World:third reader\n");
    down_read(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:third reading\n");
    msleep(5000);
    up_read(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:third read\n");
    do {
        msleep(1000);
    }
    while(!kthread_should_stop());
    return 0;
}

int thread_print_fourth(void *p) {
    if(kthread_should_stop()){
        return 0;
    }
    msleep(100);
    printk(KERN_ALERT"Hello World:fourth writer\n");
    down_write(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:fourth writting\n");
    msleep(5000);
    up_write(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:fourth written\n");
    do {
        msleep(1000);
    }
    while(!kthread_should_stop());
    return 0;
}

int thread_print_fifth(void *p) {
    if(kthread_should_stop()){
        return 0;
    }
    msleep(200);
    printk(KERN_ALERT"Hello World:fifth reader\n");
    down_read(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:fifth reading\n");
    msleep(5000);
    up_read(&my_rw_semaphore);
    printk(KERN_ALERT"Hello World:fifth read\n");
    do {
        msleep(1000);
    }
    while(!kthread_should_stop());
    return 0;
}

static int hello_init(void) {
    printk(KERN_ALERT"Hello World enter\n");
    task1 = kthread_create(thread_print_first,NULL,"first");
    if(IS_ERR(task1)) {
        printk(KERN_ALERT"kthread_create error!\n");
        return -1;
    }
    task2 = kthread_create(thread_print_second,NULL,"second");
    if(IS_ERR(task2)) {
        printk(KERN_ALERT"kthread_create error!\n");
        kthread_stop(task1);
        return -1;
    }
    task3 = kthread_create(thread_print_third,NULL,"third");
    if(IS_ERR(task3)) {
        printk(KERN_ALERT"kthread_create error!\n");
        kthread_stop(task1);
        kthread_stop(task2);
        return -1;
    }
    task4 = kthread_create(thread_print_fourth,NULL,"fourth");
    if(IS_ERR(task4)) {
        printk(KERN_ALERT"kthread_create error!\n");
        kthread_stop(task1);
        kthread_stop(task2);
        kthread_stop(task3);
        return -1;
    }
    task5 = kthread_create(thread_print_fifth,NULL,"fifth");
    if(IS_ERR(task5)) {
        printk(KERN_ALERT"kthread_create error!\n");
        kthread_stop(task1);
        kthread_stop(task2);
        kthread_stop(task3);
        kthread_stop(task4);
        return -1;
    }
    wake_up_process(task1);
    wake_up_process(task2);
    wake_up_process(task3);
    wake_up_process(task4);
    wake_up_process(task5);
    return 0;
}

static void hello_exit(void) {
    int ret;
    if (!IS_ERR(task1)) {
        ret = kthread_stop(task1);
        printk("<<<<<<<<task1 exit, ret = %d\n", ret);
    }
    if (!IS_ERR(task2)) {
        ret = kthread_stop(task2);
        printk("<<<<<<<<task2 exit, ret = %d\n", ret);
    }
    if (!IS_ERR(task3)) {
        ret = kthread_stop(task3);
        printk("<<<<<<<<task3 exit, ret = %d\n", ret);
    }
    if (!IS_ERR(task4)) {
        ret = kthread_stop(task4);
        printk("<<<<<<<<task4 exit, ret = %d\n", ret);
    }
    if (!IS_ERR(task5)) {
        ret = kthread_stop(task5);
        printk("<<<<<<<<task5 exit, ret = %d\n", ret);
    }
    printk(KERN_ALERT"hello world exit\n");
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");