Linux内核中的互斥与同步机制

共有这么几大类

1.自旋锁
2.信号量
3.互斥锁
4.RCU
5.原子变量
6.完成量

文章列举了各个互斥机制所要用的api以及在什么情况下用哪种互斥,并未对内核中的互斥和同步机制详细分析,
只供今后写代码时查阅,如果想了解详细机制可参考LKD或<<深入Linux设备驱动程序内核机制>>等书.

自旋锁
    spin_lock/spin_unlock
    因为只禁止抢占,并未对中断做处理,所以不能在中断上下文用,所以便有了以下变体

    spin_lock_irq/spin_unlock_irq
    禁止抢占,禁止中断,可以在中断上下文用

    spin_lock_irqsave/spin_unlock_irqrestore
    禁止抢占,禁止中断的同时保存中断前处理器FLAGS寄存器的状态,在ARM上是保存CPSR寄存器

    spin_lock_bh/spin_unlock_bh
    相对于spin_lock_irq来说,spin_lock_bh关闭的是softirq

    非阻塞
    spin_trylock
    spin_trylock_irq
    spin_trylock_irqsave
    spin_trylock_bh

    读写者自旋锁
        如果系统中有大量对共享资源的读操作,但并不会改写其内容,那么用spin_lock就会大大降低系统性能
        所以便有了读写者自旋锁rwlock.唯一与自旋锁不同的是可以允许多个读者同时访问,如果有写操作参与那么得互斥

        读取者
        read_lock/read_unlock
        read_lock_irq/read_unlock_irq
        read_lock_irqsave/read_unlock_irqrestore

        写入者    
        write_lock/write_unlock
        write_lock_irq/write_unlock_irq
        write_lock_irqsave/write_unlock_irqrestore

    顺序锁
        typedef struct {
            unsigned sequence;
            spinlock_t lock;
        } seqlock_t;

        顺序锁seqlock的设计思想是写加锁,读不加
        为了保证读取数据的过程中不会由写入者参与,便设置了一个sequence值,读取者在开始读取前读取该值,
        读取操作完成后再读取该值,看两值是否一致,如果不一致,说明数据被更新,读取操作无效.因此写入者在
        开始写入时要更新sequence值

        同样,静态初始化
        #define DEFINE_SEQLOCK(x) \
                seqlock_t x = __SEQLOCK_UNLOCKED(x)

        动态
        seqlock_init

        例子
        //定义一个顺序锁变量demo_seqlock
        DEFINE_SEQLOCK(demo_seqlock)

        //写入者代码
        write_seqlock(&demo_seqlock);    //实际写之前调用write_seqlock获取自旋锁,同时更新sequence的值
        do_write();            //实际的写入操作
        write_unseqlock(&demo_seqlock);    //写入结束,释放自旋锁

        //读取者代码
        unsigned start;
        do {
            //读取操作前先得到sequence的值赋给start,用以在读操作结束后判断是否发生更新
            //注意读操作无需获取锁,但是如果有写操作在进行那么会一直循环读取sequence的值,直到写操作结束
            //read_seqbegin是通过判断sequence的最低位实现的,写操作完成那么sequence&0返回0,否则返回1
            start = read_seqbegin(&demo_seqlock);

            do_read();    //实际的读操作

        } while (read_seqretry(&demo_seqlock, start));    //如果有数据更新,再重新读取

        如果考虑到中断安全问题,可以用
        write_seqlock_irq/write_sequnlock_irq
        write_seqlock_irqsave/write_sequnlock_irqrestore
        write_seqlock_bh/write_sequnlock_bh

        read_seqbegin_irqsave
        read_seqretry_irqrestore

        顺序锁seqlock和之前的读写者自旋锁rwlock其实是相同的,者是读写互斥,写写互斥,读读不互斥

信号量
    struct semaphore {
        raw_spinlock_t          lock;
        unsigned int            count;
        struct list_head        wait_list;
    };
    相对于自旋锁来讲,信号量最大的特点就是允许调用它的线程睡眠
    定义信号量    struct semaphore
    初始化信号量    sema_init(struct semaphore *sem, int val)

    信号量主要是DOWN/UP操作,DOWN操作有,不过驱动使用最频繁的是down_interruptible
    down
    down_interruptible
    down_killable
    down_trylock
    down_timeout

    UP操作只有一个
    up

    即使不是信号量的拥有者也可以调用up函数来释放一个信号量,这一点是与mutex不同的

    其实信号量常见的用途就是实现互斥机制,也就是信号量的count为1,也就是任意时刻只允许一个进程进入临界区,用法是
    #define DECLARE_MUTEX(name)

    以免与mutex产生混淆,Thomas Gleixner在2010年9月7号改为了
    #define DEFINE_SEMAPHORE(name)  \
        struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1)

    所以现在我们用DEFINE_SEMAPHORE

    读写者信号量
        与读写自旋锁一个意思,者是为了提高系统性能
        /*
         * 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;
            raw_spinlock_t          wait_lock;
            struct list_head        wait_list;
        #ifdef CONFIG_DEBUG_LOCK_ALLOC
            struct lockdep_map dep_map;
        #endif
        };

        定义
        #define DECLARE_RWSEM(name) \
            struct rw_semaphore name = __RWSEM_INITIALIZER(name)

        初始化
        init_rwsem

        DOWN操作
        down_read
        down_read_trylock
        down_write
        down_write_trylock

        UP操作
        up_read
        up_write

互斥锁
    用信号量实现互斥不是Linux中最经典的用法,于是便有了mutex.
    struct mutex {
        /* 1: unlocked, 0: locked, negative: locked, possible waiters */
        atomic_t        count;
        spinlock_t        wait_lock;
        struct list_head    wait_list;
    #if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_SMP)
        struct task_struct    *owner;
    #endif
    #ifdef CONFIG_DEBUG_MUTEXES
        const char         *name;
        void            *magic;
    #endif
    #ifdef CONFIG_DEBUG_LOCK_ALLOC
        struct lockdep_map    dep_map;
    #endif
    };

    定义并初始化,静态
    #define DEFINE_MUTEX(mutexname) \
        struct mutex mutexname = __MUTEX_INITIALIZER(mutexname)

    动态
    struct mutex
    mutex_init

    DOWN/UP操作,得不到锁就去等待队列睡眠
    mutex_lock/mutex_unlock

RCU
    Read-Copy_Update,即读/写-复制-更新.Linux提供了很多互斥机制,RCU与其他不同的是它是免锁的.
    RCU的应用场景也是读取者/写入者,不同的是RCU不用考虑读/写的互斥问题.

    简单原理是,将读取者和写入者要访问的共享数据放在指针p指向的区域,读取者通过p来访问数据,而写入者通过
    修改这个区域来更新数据.在具体实现上读取者没有太多的事要做,大量的工作都在写入者一方.免锁的实现双方
    必须同时遵守一定的规则.

    读取者所做的工作是
    禁止抢占,对p指针的引用只能在临界区中

    写入者做做的工作是
    1.分配新的空间ptr
    2.更新数据
    3.用新指针ptr替换老指针p
    4.调用call_rcu释放老指针所指向的空间

    注意第4步释放空间时必须确保没有读取者对老指针的引用,内核是通过判断处理器是否发生进程切换来实现的.因为
    读取者是禁止抢占的,所以在临界区不会发生进程切换(就单核而言),如果发生进程切换那么就说明不在临界区了

    例子
    //假设struct shared_data是读者和写者要共同访问的共享数据
    struct shared_data {
        int a;
        int b;
        struct rcu_head rcu;
    };

    //读取者代码
    //读取者调用rcu_read_lock/rcu_read_unlock构建它的读取临界区,所有对指向被保护资源指针的引用都应该只出现在临界区中,
    //而且临界区中的代码不能睡眠
    static void demo_reader(struct shared_data *ptr)
    {
        struct shared_data *p = NULL;

        rcu_read_lock();

        p = rcu_dereference(ptr);    //调用rcu_dereference获得指向共享数据的指针
        if (p)
            do_something...

        rcu_read_unlock();
    }

    //写入者代码
    //写入者提供的回调函数,用于释放老指针
    static void demo_del_oldptr(struct rcu_head *rh)
    {
        struct shared_data *p = container_of(rh, struct shared_data, rcu);
    
        kfree(p);
    }

    static void demo_writer(struct shared_data *ptr)
    {
        struct shared_data *new_ptr = kmalloc(...);
        ...
        new_ptr->a = 30;
        new_ptr->b = 40;

        rcu_assign_pointer(ptr, new_ptr);    //用新指针更新老指针

        call_rcu(ptr->rcu, demo_del_oldptr);    //调用call_rcu让内核在确保所有对老指针ptr的引用都结束后回调demo_del_oldptr释放老指针所指向的区域
    }

    和call_rcu类似的还有一个synchronize_rcu,不过后者会阻塞,它会等待所有对老指针的引用都消失后才执行,所以在中断上下文要用call_rcu

原子变量
    如果需要保护的数据只是一个简单的整型变量,那么可以用原子变量

    typedef struct {
        int counter;
    } atomic_t;

    例子
    atomic_t flag = ATOMIC_INIT(0);

    //Task A
    void add_flag()
    {
        atomic_inc(&flag);
    }

    //Task B
    void add_flag()
    {
        atomic_inc(&flag);
    }

完成量
    struct completion {
        unsigned int done;
        wait_queue_head_t wait;
    };

    静态初始化
    #define DECLARE_COMPLETION(work) \
        struct completion work = COMPLETION_INITIALIZER(work)

    动态
    init_completion

    等待完成所调用的API
    wait_for_completion
    wait_for_completion_interruptible
    wait_for_completion_timeout
    wait_for_completion_interruptible_timeout

    完成
    complete
    complete_all