【深入理解Linux内核锁】四、自旋锁

自旋锁是一种典型的对临界资源进行互斥访问的手段。

它的底层实现逻辑是：原子变量+判断检测。

原子变量我们可以理解为一把锁，通过操作原子变量（锁）的状态，并对其进行判断，如果锁未被锁定，我们就继续往下执行；如果锁已经被锁定，我们就原地自旋，直到等到锁被打开。

在ARM平台下，自旋锁的实现使用了ldrex、strex、以及内存屏障指令dmb、dsb、wfe、sev等。

2、自旋锁思想

• 自旋锁主要针对于SMP或者单CPU但内核可抢占的情况，对于单CPU内核不可抢占的情况时，自旋锁退化为空操作。
• 自旋锁实际为忙等锁，当锁不可用时，CPU一直处于等待状态，直到该锁被释放。
• 自旋锁可能会导致内核死锁，当递归使用自旋锁时，则将该CPU锁死。
• 在多核SMP的情况下，任何一个核拿到了自旋锁，该核上的抢占调度也暂时禁止了，但是没有禁止另外一个核的抢占调度。
• 在自旋锁锁定期间，不能调用引起进程调度的函数，如copy_from_user()、copy_to_user()、kmalloc()和msleep()，否则会导致内核崩溃

3、自旋锁的定义及实现

3.1 API接口

// 定义自旋锁
spinlock_t lock;

// 初始化自旋锁
spin_lock_init(&lock)

// 获得自旋锁
spin_lock(&lock)  // 获取自旋锁，如果立即获得锁，则直接返回，否则，自旋等待，直到锁被释放
spin_trylock(&lock)  // 尝试获取自旋锁，如果立即获得锁，返回true，否则直接返回false，不原地等待

// 释放自旋锁
spin_unlock(&lock)

自旋锁保证了不受其他CPU或者单CPU内的抢占进程的干扰，但是对于临界区代码，仍然有可能会受到中断和底半部的影响。

为了解决这种问题，我们就要使用自旋锁的衍生。

spin_lock_irq() = spin_lock() + local_irq_disable()   // 获取自旋锁并关中断
spin_unlock_irq() = spin_unlock() + local_irq_enable()  // 释放自旋锁并开中断
spin_lock_irqsave() = spin_lock() + local_irq_save()  // 获取自旋锁并关中断，保存中断状态
spin_unlock_irqrestore() = spin_unlock() + local_irq_restore()//释放自旋锁，开中断并恢复中断状态
spin_lock_bh() = spin_lock() + local_bh_disable()   // 获取自旋锁并关底半部中断
spin_unlock_bh() = spin_unlock() + local_bh_enable()  // 释放自旋锁并发开底半部中断

当我们的临界区代码，有可能被进程或者中断访问时，就需要在进程上下文中，调用spin_lock_irqsave()、spin_unlock_irqrestore()，在中断上下文中调用spin_lock()、spin_unlock()，如下图：

3.2 API实现

3.2.1 结构体spinlock_t、raw_spinlock、arch_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 {
            u6 __padding[LOCK_PADSIZE];
            struct lockdep_map dep_map;
        };
#endif
    };
} spinlock_t;

typedef struct raw_spinlock {
    arch_spinlock_t raw_lock;
#ifdef CONFIG_DEBUG_SPINLOCK
    unsigned int magic, owner_cpu;
    void *owner;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
    struct lockdep_map dep_map;
#endif
} raw_spinlock_t;

typedef struct {
    union {
        u32 slock;
        struct __raw_tickets {
#ifdef __ARMEB__
            u16 next;
            u16 owner;
#else
            u16 owner;
            u16 next;
#endif
        } tickets;
    };
} arch_spinlock_t;

结构体名称：spinlock_t、raw_spinlock、arch_spinlock_t

文件位置：include/linux/spinlock.h、arch/arm/include/asm/spinlock_types.h

主要作用：结构体层层嵌套，用于定义一个自旋锁。

• slock：32位无符号整形数据，用于锁的控制

• __raw_tickets：union类型，用于基于票证锁算法的自旋锁。

  每个线程进入代码段时，会尝试获取自旋锁，如果获取失败，它们会在锁的等待队列中排队。然后，等待队列中的线程会按照优先级顺序依次抢占锁的拥有权，直到某个线程成功获取自旋锁并执行完关键代码，释放锁资源为止。

• owner ：表示当前持有自旋锁的线程的索引
• next ：表示下一个等待获取自旋锁的线程的索引

这里使用的union联合体，其共享内存空间，其具体区别可看下面：

struct与union区别：https://blog.csdn.net/lishuo0204/article/details/118957959

3.2.2 spin_lock_init

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

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

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

#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 } }

函数名称：spin_lock_init

文件位置：include/linux/spinlock.h

主要作用：初始化自旋锁

函数调用流程：

//  spin_lock_init
spin_lock_init(include/linux/spinlock.h)
    |--> spinlock_check         //  对锁进行检查，判断是否存在
    |--> raw_spin_lock_init     //  初始化锁
        |--> __RAW_SPIN_LOCK_UNLOCKED(include/linux/spinlock_types.h)
            |--> __RAW_SPIN_LOCK_INITIALIZER    //  将锁初始为__ARCH_SPIN_LOCK_UNLOCKED未上锁状态

上述函数主要通过宏定义给变量.raw_lock = __ARCH_SPIN_LOCK_UNLOCKED赋值，初始化为0，即为未上锁的状态；并且提供了两个调试接口：CONFIG_DEBUG_SPINLOCK、CONFIG_DEBUG_LOCK_ALLOC，默认为关闭。

这里面有个关于spinlock_check存在的意义的讨论，感兴趣的可以看一下：https://stackoverflow.com/questions/52551594/spinlock-initialization-function

3.2.3 spin_lock

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

#define raw_spin_lock(lock) _raw_spin_lock(lock)

#ifndef CONFIG_INLINE_SPIN_LOCK
void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)
{
    __raw_spin_lock(lock);
}
EXPORT_SYMBOL(_raw_spin_lock);

#ifndef CONFIG_INLINE_SPIN_LOCK
void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)
{
    __raw_spin_lock(lock);
}
EXPORT_SYMBOL(_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);
}

#define preempt_disable() \
do { \
    preempt_count_inc(); \
    barrier(); \
} while (0)

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

static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock)
{
    __acquire(lock);
    arch_spin_lock(&lock->raw_lock);
}

static inline void arch_spin_lock(arch_spinlock_t *lock)
{
    unsigned long tmp;
    u32 newval;
    arch_spinlock_t lockval;

    prefetchw(&lock->slock);
    __asm__ __volatile__(
"1: ldrex %0, [%3]\n"
" add %1, %0, %4\n"
" strex %2, %1, [%3]\n"
" teq %2, #0\n"
" bne 1b"
    : "=&r" (lockval), "=&r" (newval), "=&r" (tmp)
    : "r" (&lock->slock), "I" (1 << TICKET_SHIFT)
    : "cc");

    while (lockval.tickets.next != lockval.tickets.owner) {
        wfe();
        lockval.tickets.owner = READ_ONCE(lock->tickets.owner);
    }

    smp_mb();
}

函数名称：spin_lock

文件位置：include/linux/spinlock.h

主要作用：用于在进程或线程首次尝试获取锁的时候进行自旋，不停地检查锁的状态，如果锁已经被其他进程或线程占用，则自旋等待，直到锁被释放。

函数调用流程：

//  spin_lock
spin_lock(include/linux/spinlock.h)
    |--> raw_spin_lock
        |--> _raw_spin_lock(include/linux/spinlock_api_smp.h)
            |--> __raw_spin_lock
                |--> __raw_spin_lock
                    |--> preempt_disable
          |--> preempt_count_inc
          |--> barrier
                    |--> spin_acquire
                    |--> LOCK_CONTENDED
                        |--> do_raw_spin_lock
                            |--> arch_spin_lock(arch/arm/include/asm/spinlock.h)

实现流程：

1. preempt_disable(); 禁用内核抢占，确保当前 CPU 执行该代码时不会被其他进程或线程抢占。

• 其通过preempt_count_inc增加抢占计数器的值，通过抢占计数器来实现对任务的执行顺序进行管理。
• 通过内存屏障barrier来确保前面的操作完成后再继续执行后面的代码。

• spin_acquire是lockdep工具的一部分，主要用于动态检测死锁。
• lock->dep_map是锁的依赖地图，_RET_IP_是调用者的返回地址。这两个参数都是用于lockdep的调试信息。
• lockdep是一个强大的锁调试工具，它可以跟踪锁的所有获取和释放，并动态地检测可能的死锁情况。

下面为arch_spin_lock汇编代码分析：

1. prefetchw(&lock->slock) 函数用于提前加载锁的地址到处理器缓存中，从而提高锁的获取效率。

2. ldrex %0, [%3] 用于以原子方式读取锁的值到寄存器 %0 中，%3 为锁的地址。

3. add %1, %0, %4用于将当前获取锁的 CPU 分配的新值加上原锁值 %0 以及%4 固定常量，结果存放在%1新值中。

4. strex %2, %1, [%3] 用于以原子方式将更新的值 %1 写入锁的地址所指定的内存位置，%2 为写入结果。

   这里解释一下为什么要做add处理：

   由spinlock_t的结构体可知，是由联合体组成，并且可以通过owner和next两个字段访问，next在高16位，owner在低16位。

   这里上锁的操作，是将其值设置为1 << TICKET_SHIFT，也就是高16位，即next字段设置为1，表示下一个等待获取自旋锁的线程的索引。

5. teq %2, #0：用于测试写入结果 %2 是否为0，如果为0，表示锁获取成功，反之则跳转到标签1b处执行。

6. 当获取锁成功之后，程序会执行 while 循环，不断等待锁的所有权被赋予当前 CPU, 直到锁的所有权的拥有者持有锁为止。

7. smp_mb() 函数执行一条内存屏障，确保所有关键数据的顺序性已经刷新到内存中。

综上，spin_lock代码的作用是获取自旋锁，让当前线程获得临界资源的控制权，避免多个线程同时修改共享资源而造成数据冲突。同时，通过禁用内核抢占和使用内联函数优化的方式，保证了原子操作的执行效率和可靠性。

3.2.4 spin_unlock

static __always_inline void spin_unlock(spinlock_t *lock)
{
    raw_spin_unlock(&lock->rlock);
}

#define raw_spin_unlock(lock)  _raw_spin_unlock(lock)

void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)
{
    __raw_spin_unlock(lock);
}

static inline void __raw_spin_unlock(raw_spinlock_t *lock)
{
    spin_release(&lock->dep_map, 1, _RET_IP_);
    do_raw_spin_unlock(lock);
    preempt_enable();
}

static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
{
    arch_spin_unlock(&lock->raw_lock);
    __release(lock);
}

static inline void arch_spin_unlock(arch_spinlock_t *lock)
{
    smp_mb();
    lock->tickets.owner++;
    dsb_sev();
}

函数名称：spin_unlock