自旋锁在内核中的实现

╰半夏微凉° 2022-10-01 03:56 124阅读 0赞

自旋锁是相对于SMP系统而言的。  
  
在单处理器中只要保证在临界区时不发生进程调度（包括进程抢占）， 禁止中断，或者即使开启中断，  
只要中断例程与临界区无冲突，在或者临界区只有一条指令（中断只发生在指令之间，并不会打断一条执行中的指令），  
就会保持操作的同步。  
  
但是在SMP中，情况就会变的复杂的多， 考虑下面一种情况：  
  
1. CPU0中的某一个进程从内存A处读取了一个值， 然后对它进行了修改。  
2. CPU1中的某一个进程也同时从内存A处读取了这个值，并且也对它进行了修改。  
3. CPU0中的进程把修改后的值写回到了内存A处。  
4. CPU1中的进程也把修改后的值写回到了内存A处。  
  
这个操作过程中造成了内存A处的值也预期的结果可能不太一样。 在一个如果CPU0和CPU1的这个操作正好是测试自旋锁值的过程，  
那么将导致CPU0和CPU1都以为获得了临界区的操作权限， 那么执行结果将变的更加不可预知了。  
  
所以在SMP系统中常用的一个方法就是采用叫做自旋锁的方法来达到CPU之间的同步操作。  
  
在spin\_lock在spinlock.h中定义：  
  
\#define spin\_lock(lock)         \_spin\_lock(lock)  
  
\_spin\_lock(lock)在/kernel/spinlock.c中实现：  
  
void \_\_lockfunc \_spin\_lock(spinlock\_t \*lock)  
\{  
        preempt\_disable();  
        if (unlikely(!\_raw\_spin\_trylock(lock)))  
                \_\_preempt\_spin\_lock(lock);  
\}  
  
1. 函数首先调用preempt\_disable();来禁止内核抢占， 如果在CPU在执行自旋锁代码的时候开启了内核抢占，  
在这个过程中它有可能被其他CPU抢占， 而其他CPU此时也需要获得这个自旋锁的话， 将会发生自旋，在最坏的情况下它将一直  
自旋下去。  
  
2. 然后调用\_raw\_spin\_trylock(lock)来检查下是否能获得这个锁。  
static inline int \_raw\_spin\_trylock(spinlock\_t \*lock)  
\{  
        char oldval;  
        \_\_asm\_\_ \_\_volatile\_\_(  
                "xchgb %b0,%1"  
                :"=q" (oldval), "=m" (lock->lock)  
                :"0" (0) : "memory");  
        return oldval > 0;  
\}  
  
这段代码让lock->lock与0值进行交换，存储到oldval中，如果oldval为正值，就返回1，  
否则返回0.  
  
当\_raw\_spin\_trylock(lock)返回0值时，表明临界区被加了锁，代码开始执行\_\_preempt\_spin\_lock()  
不断自旋来检查lock是否被释放。  
  
static inline void \_\_preempt\_spin\_lock(spinlock\_t \*lock)  
\{  
        if (preempt\_count() > 1) \{  
                \_raw\_spin\_lock(lock);  
                return;  
        \}  
  
        do \{  
                preempt\_enable();  
                while (spin\_is\_locked(lock))  
                        cpu\_relax();  
                preempt\_disable();  
        \} while (!\_raw\_spin\_trylock(lock));  
\}  
  
在这个过程中如果禁止了内核抢占的话， 执行\_raw\_spin\_lock()进行自旋。  
      static inline void \_raw\_spin\_lock(spinlock\_t \*lock)  
\{  
\#ifdef CONFIG\_DEBUG\_SPINLOCK  
        if (unlikely(lock->magic != SPINLOCK\_MAGIC)) \{  
                printk("eip: %p/n", \_\_builtin\_return\_address(0));  
                BUG();  
        \}  
\#endif  
        \_\_asm\_\_ \_\_volatile\_\_(  
                spin\_lock\_string  
                :"=m" (lock->lock) : : "memory");  
\}  
具体代码为spin\_lock\_string  
\#define spin\_lock\_string /  
        "/n1:/t" /  
        "lock ; decb %0/n/t" /  
        "jns 3f/n" /  
        "2:/t" /  
        "rep;nop/n/t" /  
        "cmpb $0,%0/n/t" /  
        "jle 2b/n/t" /  
        "jmp 1b/n" /  
        "3:/n/t"  
这段代码就是不断的测试lock->lock的值，如果大于0就跳出循环返回。此处的lock指令为会锁定地址总线，  
防止其他CPU并发访问，起到了内存屏障的作用。  
  
如果在这个过程中如果开启了内核抢占的话，首先通过preempt\_enable()开启内核抢占。  
然后一个循环检查lock->lock的值。  
\#define spin\_is\_locked(x)       (\*(volatile signed char \*)(&(x)->lock) <= 0)  
如果lock->lock的值小于0， 表示临界区不可用， 执行cpu\_relax()， 其实就是执行nop指令  
来获得短暂的延迟。 当临界区可用的时候执行preempt\_disable()来禁止内核抢占。  
如果此时还开启内核抢占的话， 那么在执行\_raw\_spin\_trylock(lock)前，它可能在次失去  
对临界区的访问权限。 最后调用\_raw\_spin\_trylock(lock)来确保自旋锁确实所得了对临界区的  
访问权限。