Linux内核源码分析 -- 同步原语 -- 自旋锁 spinlock

Linux内核源码分析 -- 同步原语 -- 自旋锁 spinlock_t

        typedef struct spinlock {
        union {
              struct raw_spinlock rlock;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
                struct {
                        u8 __padding[LOCK_PADSIZE];
                        struct lockdep_map dep_map;
                };
#endif
        };
} spinlock_t;

    

如果一个处理程序尝试执行受自旋锁保护的代码，那么代码将会被锁住，直到占有锁的处理程序释放掉。

自旋锁 一共有两种状态

• acquired
• released

自旋锁获取（spinlock acquire）

自旋锁释放（spinlock released）

raw_spinlock 结构

        typedef struct raw_spinlock {
        arch_spinlock_t raw_lock;
#ifdef CONFIG_GENERIC_LOCKBREAK
        unsigned int break_lock;
#endif
} raw_spinlock_t;

    

x86 的 arch_spinlock 结构

        typedef struct arch_spinlock {
        union {
                __ticketpair_t head_tail;
                struct __raw_tickets {
                        __ticket_t head, tail;
                } tickets;
        };
} arch_spinlock_t;

    

Linux内核在自旋锁上提供了一下主要的操作：

• spin_lock_init ——给定的自旋锁进行初始化；
• spin_lock ——获取给定的自旋锁；
• spin_lock_bh ——禁止软件中断并且获取给定的自旋锁。
• spin_lock_irqsave 和 spin_lock_irq——禁止本地处理器上的中断，并且保存／不保存之前的中断状态的标识 (flag)；
• spin_unlock ——释放给定的自旋锁;
• spin_unlock_bh ——释放给定的自旋锁并且启动软件中断；
• spin_is_locked - 返回给定的自旋锁的状态；
• 等等

spin_lock_init —— 对给定的自旋锁进行初始化

        #define spin_lock_init(_lock)        do {                                                spinlock_check(_lock);                            raw_spin_lock_init(&(_lock)->rlock);        } while (0)

    

spinlock_check 检查 _lock

返回已知的自旋锁的 raw_spinlock_t，来确保我们精确获得正常 (normal) 原生自旋锁

        static __always_inline raw_spinlock_t *spinlock_check(spinlock_t *lock)
{
  return &lock->rlock;
}

    

raw_spin_lock_init 宏

这个宏为给定的自旋锁执行初始化操作，并且将锁设置为释放 (released) 状态

        # define raw_spin_lock_init(lock)        do {                                                      *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock);         } while (0)                                           
    

__RAW_SPIN_LOCK_UNLOCKED 宏

        #define __RAW_SPIN_LOCK_UNLOCKED(lockname)               (raw_spinlock_t) __RAW_SPIN_LOCK_INITIALIZER(lockname)
#define __RAW_SPIN_LOCK_INITIALIZER(lockname)            {                                                                   .raw_lock = __ARCH_SPIN_LOCK_UNLOCKED,                          SPIN_DEBUG_INIT(lockname)                                       SPIN_DEP_MAP_INIT(lockname)                                 }
#define __ARCH_SPIN_LOCK_UNLOCKED       { { 0 } }

    

展开 __RAW_SPIN_LOCK_UNLOCKED 宏就是

        *(lock) = __ARCH_SPIN_LOCK_UNLOCKED;

    

展开 raw_spin_lock_init 就是

        *(&(_lock)->rlock) = __ARCH_SPIN_LOCK_UNLOCKED;

    

在 spin_lock_init 宏的扩展之后，给定的自旋锁将会初始化并且状态变为——解锁 (unlocked)。

初始化操作其实就是把 给定的自旋锁 的 rlock 设置成 0 ，表示锁是 released 状态

spin_lock —— 获取给定的自旋锁

        static __always_inline void spin_lock(spinlock_t *lock)
{
    raw_spin_lock(&lock->rlock);
}

    

raw_spin_lock 宏

        #define _raw_spin_lock(lock) __raw_spin_lock(lock)

    

__raw_spin_lock 函数

        static inline void __raw_spin_lock(raw_spinlock_t *lock)
{
        preempt_disable(); // 禁用抢占（当程序正在自旋锁时，这个已经获取锁的程序必须阻止其他程序方法的抢占）
        spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);
        LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);
}

    

跳过 spin_acquire

分析 LOCK_CONTENDED

        LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);

    

LOCK_CONTENDED

        #define LOCK_CONTENDED(_lock, try, lock)          lock(_lock)

    

其实 lock 就是 do_raw_spin_lock

        static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock)
{
        __acquire(lock); // [稀疏(sparse)]相关宏
         arch_spin_lock(&lock->raw_lock);
}
#define arch_spin_lock(l)               queued_spin_lock(l)

    

arch_spinlock

        typedef struct arch_spinlock {
        union {
                __ticketpair_t head_tail;
                struct __raw_tickets {
                        __ticket_t head, tail;
                } tickets;
        };
} arch_spinlock_t;

    

这个自旋锁的变体被称为——标签自旋锁 (ticket spinlock)

当锁被获取，如果有程序想要获取自旋锁，它就会将 tail 的值加 1，如果 tail != head ，那么程序就会被锁住，直到 tail == head

arch_spin_lock

        #define __TICKET_LOCK_INC       1
#define cpu_relax()     asm volatile("rep; nop")
static __always_inline void arch_spin_lock(arch_spinlock_t *lock)
{
        register struct __raw_tickets inc = { .tail = TICKET_LOCK_INC }; // tail = 1
        inc = xadd(&lock->tickets, inc); // 这个操作过后 &lock->tickets = inc (这是个原子操作,详细请自行搜索 xadd)
        // 锁的关键就在这里了,只要 inc.head == inc.tail 成立,就说明这个锁没有被其他进程获取
        if (likely(inc.head == inc.tail))
                goto out; // 这个锁没有被获取,直接跳到 out 去执行
        // inc.head != inc.tail 说明有线程获取了这个锁,进入这个循环,等待这个锁被释放
        for (;;) {
                 unsigned count = SPIN_THRESHOLD; // 这是类似于信号量的 timeout 的东西,这个变量定义了进程 "等多久" (while执行多少次)
                 do {
                       // 把 head 读出来
                       inc.head = READ_ONCE(lock->tickets.head);
                       // 对比 head 和 tail,相等就说明这个锁被释放了
                       if (__tickets_equal(inc.head, inc.tail))
                                goto clear_slowpath;
                        cpu_relax(); // #define cpu_relax()     asm volatile("rep; nop"),就是一个 nop 指令,啥都不做
                 } while (--count);
                 __ticket_lock_spinning(lock, inc.tail);
         }
clear_slowpath:
        __ticket_check_and_clear_slowpath(lock, inc.head);
out:
        barrier(); // 屏障指令(防止 CPU 乱序)
}

    

spin_unlock -- 释放给定的自旋锁

其实这个锁的释放就是让 head 加 1

核心操作

        __add(&lock->tickets.head, TICKET_LOCK_INC, UNLOCK_LOCK_PREFIX);

    

这样的话所有的等待进程就形成一个队列

head 是当前获得锁的进程的编号

tail 就是正在等待的进程的编号

在锁没有被释放的时候, 一直有进程请求这个锁,请求一次 tail 就加 1

释放锁的时候是 head 加 1, 这样对应的 tail (head == tail)的进程就能获得锁

就像是这样的

                  +-------+
head      |   3   |
          +-------+

                  +-------+-------+-------+-------+
tail              |   4   |   5   |   6   |   7   |
                  +-------+-------+-------+-------+

    

现在 tail 等于 3 , head 等于 3

释放锁后, head 等于 4

                  +-------+
head      |   4   |
          +-------+

          +-------+-------+-------+-------+
tail      |   4   |   5   |   6   |   7   |
          +-------+-------+-------+-------+

    

这样 tail == 4 的进程就能获得锁

本文参考

《Linux Inside》：https://github.com/0xAX/linux-insides

《内核揭秘（中文版）》：https://github.com/MintCN/linux-insides-zh

原文：https://www.cnblogs.com/crybaby/p/13062811.html