SchOS/kernel/core/spinlock.c

#include "core/types.h"
#include "core/defs.h"
#include "core/param.h"
#include "arch/x86.h"
#include "arch/memlayout.h"
#include "arch/mmu.h"
#include "core/proc.h"
#include "core/spinlock.h"

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

void
acquire(struct spinlock *lk)
{
  pushcli();
  if(holding(lk))
    panic("acquire");

  {
    uint64 spins = 0;
    while(xchg(&lk->locked, 1) != 0){
      if(++spins == 200000000ULL){
        cprintf("acquire: stuck on \"%s\" held by cpu=%p pcs0=%p pcs1=%p pcs2=%p, acquirer cpu=%p\n",
                lk->name, lk->cpu, lk->pcs[0], lk->pcs[1], lk->pcs[2], mycpu());
        panic("acquire: deadlock");
      }
    }
  }

  __sync_synchronize();

  lk->cpu = mycpu();
  getcallerpcs(&lk, lk->pcs);
}

void
release(struct spinlock *lk)
{
  if(!holding(lk))
    panic("release");

  lk->pcs[0] = 0;
  lk->cpu = 0;

  __sync_synchronize();

  asm volatile("movq $0, %0" : "+m" (lk->locked) : );

  popcli();
}

void
getcallerpcs(void *v, addr_t pcs[])
{
  addr_t *rbp;

  asm volatile("mov %%rbp, %0" : "=r" (rbp));
  getstackpcs(rbp, pcs);
}

void
getstackpcs(addr_t *rbp, addr_t pcs[])
{
  int i;

  for(i = 0; i < 10; i++){
    // This walks a frame chain that may be garbage -- it runs from
    // getcallerpcs() on every lock acquisition, and again from the trap
    // handler, where the thing being diagnosed is often the reason the stack
    // is unwalkable. A fault here replaces the real diagnosis with a second,
    // more confusing one, so every dereference is checked first.
    //
    // The old test also compared against 0xffffffff, which on x86-64 is
    // unreachable: it is far below KERNBASE and the check above already
    // rejected it. The value that actually turns up is all-ones,
    // 0xffffffffffffffff, which is *above* KERNBASE and sailed straight
    // through -- rbp[1] then wraps to address 0x7 and page-faults. Bound rbp
    // from above rather than naming another magic constant, so any frame
    // pointer near the top of the address space is rejected whatever it is.
    if(rbp == 0 || rbp < (addr_t*)KERNBASE || (addr_t)rbp > (addr_t)-16)
      break;
    // A frame pointer is 8-byte aligned. An unaligned one is not a frame,
    // and following it walks off into arbitrary memory.
    if(((addr_t)rbp & 7) != 0)
      break;
    pcs[i] = rbp[1];
    // The next frame is the caller's, further up the same stack: higher, and
    // by less than a whole kernel stack. The chain ends at the system call or
    // interrupt entry, and the rbp saved there is the user's -- which an
    // optimised program uses as an ordinary register. lbreakouthd left -1024
    // in it, 0xfffffffffffffc00, which passed every test above and faulted
    // here under the syscall tracer, taking the kernel down from inside the
    // lock it was recording.
    addr_t *next = (addr_t*)rbp[0];
    if(next <= rbp || (addr_t)next - (addr_t)rbp >= KSTACKSIZE){
      i++;                      // keep the return address just read
      break;
    }
    rbp = next;
  }
  for(; i < 10; i++)
    pcs[i] = 0;
}

int
holding(struct spinlock *lock)
{
  return lock->locked && lock->cpu == mycpu();
}

void
pushcli(void)
{
  int eflags;

  eflags = readeflags();
  cli();
  if(mycpu() == 0){
    extern uint64 kernel_fs_base;
    cprintf("pushcli: cpu==NULL cs=0x%p kernel_fs_base=0x%p actual_fs_base=0x%p\n",
            readcs(), kernel_fs_base, rdmsr(0xC0000100));
    panic("pushcli: cpu is NULL");
  }
  if(mycpu()->ncli == 0)
    mycpu()->intena = eflags & FL_IF;
  mycpu()->ncli += 1;
}

void
popcli(void)
{
  if(readeflags()&FL_IF)
    panic("popcli - interruptible");
  if(--mycpu()->ncli < 0)
    panic("popcli");
  if(mycpu()->ncli == 0 && mycpu()->intena)
    sti();
}