6.828(2021)

 1struct trapframe {
 2  /*   0 */ uint64 kernel_satp;   // kernel page table
 3  /*   8 */ uint64 kernel_sp;     // top of process's kernel stack
 4  /*  16 */ uint64 kernel_trap;   // usertrap()
 5  /*  24 */ uint64 epc;           // saved user program counter
 6  /*  32 */ uint64 kernel_hartid; // saved kernel tp
 7  /*  40 */ uint64 ra;
 8  /*  48 */ uint64 sp;
 9  /*  56 */ uint64 gp;
10  /*  64 */ uint64 tp;
11  /*  72 */ uint64 t0;
12  /*  80 */ uint64 t1;
13  /*  88 */ uint64 t2;
14  /*  96 */ uint64 s0;
15  /* 104 */ uint64 s1;
16  /* 112 */ uint64 a0;
17  /* 120 */ uint64 a1;
18  /* 128 */ uint64 a2;
19  /* 136 */ uint64 a3;
20  /* 144 */ uint64 a4;
21  /* 152 */ uint64 a5;
22  /* 160 */ uint64 a6;
23  /* 168 */ uint64 a7;
24  /* 176 */ uint64 s2;
25  /* 184 */ uint64 s3;
26  /* 192 */ uint64 s4;
27  /* 200 */ uint64 s5;
28  /* 208 */ uint64 s6;
29  /* 216 */ uint64 s7;
30  /* 224 */ uint64 s8;
31  /* 232 */ uint64 s9;
32  /* 240 */ uint64 s10;
33  /* 248 */ uint64 s11;
34  /* 256 */ uint64 t3;
35  /* 264 */ uint64 t4;
36  /* 272 */ uint64 t5;
37  /* 280 */ uint64 t6;
38};

1w_stvec((uint64)kernelvec);

1p->trapframe->epc += 4;

 1// kernel/vm.c:
 2// map the trampoline for trap entry/exit to
 3// the highest virtual address in the kernel.
 4kvmmap(kpgtbl, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);
 5
 6// kernel/proc.c:
 7// map the trampoline code (for system call return)
 8// at the highest user virtual address.
 9// only the supervisor uses it, on the way
10// to/from user space, so not PTE_U.
11if(mappages(pagetable, TRAMPOLINE, PGSIZE,
12            (uint64)trampoline, PTE_R | PTE_X) < 0){
13  uvmfree(pagetable, 0);
14  return 0;
15}

1// Allocate a trapframe page.
2if((p->trapframe = (struct trapframe *)kalloc()) == 0){
3  freeproc(p);
4  release(&p->lock);
5  return 0;
6}

 1void
 2acquire(struct spinlock *lk) // does not work!
 3{
 4    for(;;) {
 5        if(lk->locked == 0) {
 6            lk->locked = 1;
 7            break;
 8        }
 9    }
10}

 1// Acquire the lock.
 2// Loops (spins) until the lock is acquired.
 3void
 4acquire(struct spinlock *lk)
 5{
 6  push_off(); // disable interrupts to avoid deadlock.
 7  if(holding(lk))
 8    panic("acquire");
 9
10  // On RISC-V, sync_lock_test_and_set turns into an atomic swap:
11  //   a5 = 1
12  //   s1 = &lk->locked
13  //   amoswap.w.aq a5, a5, (s1)
14  while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
15    ;
16
17  // Tell the C compiler and the processor to not move loads or stores
18  // past this point, to ensure that the critical section's memory
19  // references happen strictly after the lock is acquired.
20  // On RISC-V, this emits a fence instruction.
21  __sync_synchronize();
22
23  // Record info about lock acquisition for holding() and debugging.
24  lk->cpu = mycpu();
25}

 1// Release the lock.
 2void
 3release(struct spinlock *lk)
 4{
 5  if(!holding(lk))
 6    panic("release");
 7
 8  lk->cpu = 0;
 9
10  // Tell the C compiler and the CPU to not move loads or stores
11  // past this point, to ensure that all the stores in the critical
12  // section are visible to other CPUs before the lock is released,
13  // and that loads in the critical section occur strictly before
14  // the lock is released.
15  // On RISC-V, this emits a fence instruction.
16  __sync_synchronize();
17
18  // Release the lock, equivalent to lk->locked = 0.
19  // This code doesn't use a C assignment, since the C standard
20  // implies that an assignment might be implemented with
21  // multiple store instructions.
22  // On RISC-V, sync_lock_release turns into an atomic swap:
23  //   s1 = &lk->locked
24  //   amoswap.w zero, zero, (s1)
25  __sync_lock_release(&lk->locked);
26
27  pop_off();
28}

1l = malloc(sizeof *l);
2l->data = data;
3acquire(&listlock);
4l->next = list;
5list = l;
6release(&listlock);

 1// Switch to scheduler.  Must hold only p->lock
 2// and have changed proc->state. Saves and restores
 3// intena because intena is a property of this
 4// kernel thread, not this CPU. It should
 5// be proc->intena and proc->noff, but that would
 6// break in the few places where a lock is held but
 7// there's no process.
 8void
 9sched(void)
10{
11  int intena;
12  struct proc *p = myproc();
13
14  if(!holding(&p->lock))
15    panic("sched p->lock");
16  if(mycpu()->noff != 1)
17    panic("sched locks");
18  if(p->state == RUNNING)
19    panic("sched running");
20  if(intr_get())
21    panic("sched interruptible");
22
23  intena = mycpu()->intena;
24  swtch(&p->context, &mycpu()->context);
25  mycpu()->intena = intena;
26}
27
28// Give up the CPU for one scheduling round.
29void
30yield(void)
31{
32  struct proc *p = myproc();
33  acquire(&p->lock);
34  p->state = RUNNABLE;
35  sched();
36  release(&p->lock);
37}