【MIT6.828】xv6系统中的spinlock（自旋锁）

末蓝、 2023-06-16 08:18 17阅读 0赞

# 【MIT6.828】xv6系统中的spinlock（自旋锁） #

自旋锁是专为防止多处理器并发而引入的一种锁，它在内核中大量应用于中断处理等部分（对于单处理器来说，防止中断处理中的并发可简单采用关闭中断的方式，即在标志寄存器中关闭/打开中断标志位，不需要自旋锁）。

Xv6是由麻省理工学院(MIT)为操作系统工程的课程（代号6.828）,开发的一个教学目的的操作系统。Xv6是在x86处理器上(x即指x86)用ANSI标准C重新实现的Unix第六版(Unix V6，通常直接被称为V6)。

## spinglock的使用 ##

以文件的操作为例。  
file.c中初始化一个spinlock

void
    fileinit(void)
    { 
      initlock(&ftable.lock, "ftable");
    }

file.c中申请锁和释放锁的源码

// Increment ref count for file f.
    struct file*
    filedup(struct file *f)
    { 
      acquire(&ftable.lock);
      if(f->ref < 1)
        panic("filedup");
      f->ref++;
      release(&ftable.lock);
      return f;
    }

## spinlock源码 ##

### 初始化部分 ###

spinlock.c初始化锁的源码

void
    initlock(struct spinlock *lk, char *name)
    { 
      lk->name = name;
      lk->locked = 0;
      lk->cpu = 0;
    }

### 获取锁 ###

spinlock.c获取锁源码

// Acquire the lock.
    // Loops (spins) until the lock is acquired.
    // Holding a lock for a long time may cause
    // other CPUs to waste time spinning to acquire it.
    void
    acquire(struct spinlock *lk)
    { 
      pushcli(); // disable interrupts to avoid deadlock.
      if(holding(lk))
        panic("acquire");
    
      // The xchg is atomic.
      while(xchg(&lk->locked, 1) != 0)
        ;
    
      // Tell the C compiler and the processor to not move loads or stores
      // past this point, to ensure that the critical section's memory
      // references happen after the lock is acquired.
      __sync_synchronize();
    
      // Record info about lock acquisition for debugging.
      lk->cpu = mycpu();
      getcallerpcs(&lk, lk->pcs);
    }

其中，xchg方法来自x86.h，是一种硬件特性，原子性操作如何保障的，只有处理器知道。

static inline uint
    xchg(volatile uint *addr, uint newval)
    { 
      uint result;
    
      // The + in "+m" denotes a read-modify-write operand.
      asm volatile("lock; xchgl %0, %1" :
                   "+m" (*addr), "=a" (result) :
                   "1" (newval) :
                   "cc");
      return result;
    }

### 释放锁 ###

spinlock.c释放锁源码

// Release the lock.
    void
    release(struct spinlock *lk)
    { 
      if(!holding(lk))
        panic("release");
    
      lk->pcs[0] = 0;
      lk->cpu = 0;
    
      // Tell the C compiler and the processor to not move loads or stores
      // past this point, to ensure that all the stores in the critical
      // section are visible to other cores before the lock is released.
      // Both the C compiler and the hardware may re-order loads and
      // stores; __sync_synchronize() tells them both not to.
      __sync_synchronize();
    
      // Release the lock, equivalent to lk->locked = 0.
      // This code can't use a C assignment, since it might
      // not be atomic. A real OS would use C atomics here.
      asm volatile("movl $0, %0" : "+m" (lk->locked) : );
    
      popcli();
    }