[RISC-V] System Call

 

 

 

PA2: System Call 

System calls are interfaces that allow user applications to request various services from the operating system kernel. This project aims to explore and understand how system calls are implemented in the xv6 operating system.

git-hub: https://github.com/snu-csl/os-pa2/

 

xv6: a simple, Unix-like teaching operating system

 

 

 

📌 start.c

• xv6 kernel boot up code 
• 리눅스 커널의 초기화 과정을 담당 
• 커널이 부팅될 때 가장 먼저 실행되어, 초기 환경을 설정

#include "types.h"
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
#include "defs.h"

void main();
void timerinit();

// entry.S needs one stack per CPU.
__attribute__ ((aligned (16))) char stack0[4096 * NCPU];

// entry.S jumps here in machine mode on stack0.
void
start()
{
  // set M Previous Privilege mode to Supervisor, for mret.
  unsigned long x = r_mstatus();
  x &= ~MSTATUS_MPP_MASK;
  x |= MSTATUS_MPP_S;
  w_mstatus(x);

  // set M Exception Program Counter to main, for mret.
  // requires gcc -mcmodel=medany
  w_mepc((uint64)main);

  // disable paging for now.
  w_satp(0);

  // delegate all interrupts and exceptions to supervisor mode.
  w_medeleg(0xffff);
  w_mideleg(0xffff);
  w_sie(r_sie() | SIE_SEIE | SIE_STIE | SIE_SSIE);

#ifdef SNU
  setpmp();
#else
  // configure Physical Memory Protection to give supervisor mode
  // access to all of physical memory.
  w_pmpaddr0(0x3fffffffffffffull);
  w_pmpcfg0(0xf);
#endif

  // ask for clock interrupts.
  timerinit();

  // keep each CPU's hartid in its tp register, for cpuid().
  int id = r_mhartid();
  w_tp(id);

  // switch to supervisor mode and jump to main().
  asm volatile("mret");
}

// ask each hart to generate timer interrupts.
void
timerinit()
{
  // enable supervisor-mode timer interrupts.
  w_mie(r_mie() | MIE_STIE);
  
  // enable the sstc extension (i.e. stimecmp).
  w_menvcfg(r_menvcfg() | (1L << 63)); 
  
  // allow supervisor to use stimecmp and time.
  w_mcounteren(r_mcounteren() | 2);
  
  // ask for the very first timer interrupt.
  w_stimecmp(r_time() + 1000000);
}

 

• entry.S: 각 hart에 대하여, stack0 + hartid * 4096을 스택 포인터로 설정 -> start() 진입
• 머신 모드에서 모든 트랩/인터럽트를 S Mode로 위임
• S Mode가 모든 메모리에 접근할 수 있도록 PMP 설정 (#ifdef SNU)
• 타이머 인터럽트 초기화
  
  
• M → S Mode 전환 (asm volatile("mret");) 
  커널이 M-mode에서 부팅되고, S-mode로 전환된 후, 동작 

 

 

 

📌 kernel/riscv.h

• Architecture-dependent codes
• OS와 RISC-V CPU의 interaction 지원
• 하드웨어 추상화 레이어 - HAL: Hardware Abstraction Layer
• 어셈블리 명령어(CSR read/write, register 접근) wrapping  

// Physical Memory Protection
static inline void
w_pmpcfg0(uint64 x)
{
  asm volatile("csrw pmpcfg0, %0" : : "r" (x));
}

static inline void
w_pmpaddr0(uint64 x)
{
  asm volatile("csrw pmpaddr0, %0" : : "r" (x));
}

 

• csrr: CSR read
• csrw : CSR write 

  # Reading pmpaddr0 register
  csrr a0, pmpaddr0

 

 

 

 

 

📌 kernel/kernelvec.S

• M-mode and S-mode trap vectors
• 커널에서 인터럽트 -> CPU 진입점(Trap Vector) 역할
• 커널 트랩 핸들러를 호출하는 역할 

#
# Interrupts and exceptions while in supervisor mode come here.
# The current stack is a kernel stack.
# We push registers, call the kerneltrap() function.
# When kerneltrap() returns, we restore registers and return.
#

.globl kerneltrap
.globl kernelvec
.align 4
kernelvec:
        # Make room to save registers.
        addi sp, sp, -256

        # Save caller-saved registers.
        sd ra, 0(sp)
        sd sp, 8(sp)
        sd gp, 16(sp)
        sd tp, 24(sp)
        sd t0, 32(sp)
        sd t1, 40(sp)
        sd t2, 48(sp)
        sd a0, 72(sp)
        sd a1, 80(sp)
        sd a2, 88(sp)
        sd a3, 96(sp)
        sd a4, 104(sp)
        sd a5, 112(sp)
        sd a6, 120(sp)
        sd a7, 128(sp)
        sd t3, 216(sp)
        sd t4, 224(sp)
        sd t5, 232(sp)
        sd t6, 240(sp)

        # Call the C trap handler in trap.c
        call kerneltrap

        # Restore registers.
        ld ra, 0(sp)
        ld sp, 8(sp)
        ld gp, 16(sp)
        ld t0, 32(sp)
        ld t1, 40(sp)
        ld t2, 48(sp)
        ld a0, 72(sp)
        ld a1, 80(sp)
        ld a2, 88(sp)
        ld a3, 96(sp)
        ld a4, 104(sp)
        ld a5, 112(sp)
        ld a6, 120(sp)
        ld a7, 128(sp)
        ld t3, 216(sp)
        ld t4, 224(sp)
        ld t5, 232(sp)
        ld t6, 240(sp)

        addi sp, sp, 256

        # Return to whatever we were doing in the kernel.
        sret

• 트랩 발생 -> S-Mode stvec register 주소로 jump (kernelvec) 
• 스택에서 256 byte 내리기 (addi sp, sp, -256) 
  레지스터를 스택에 백업 (caller-saved register: ra, t0~t6, a0~a7, gp, tp, sp)

 

• 트랩 처리 함수 호출 (kerneltrap in trap.c) -> Call kerneltrap
• register 값 복원하기
• sret = 트랩이 발생했던 지점으로 돌아가기 

 

 

 

+ riscv.h - stvec이 쓰이는 part 

// Supervisor Trap-Vector Base Address
// low two bits are mode.
static inline void 
w_stvec(uint64 x)
{
  asm volatile("csrw stvec, %0" : : "r" (x));
}

static inline uint64
r_stvec()
{
  uint64 x;
  asm volatile("csrr %0, stvec" : "=r" (x) );
  return x;
}

 

 

 

📌 kernel/trap.c

• Trap handling = 트랩 처리 로직
• 프로그램 실행 중 발생하는 Interrupt, exception, system call, trap 처리 

// interrupts and exceptions from kernel code go here via kernelvec,
// on whatever the current kernel stack is.
void 
kerneltrap()
{
  int which_dev = 0;
  uint64 sepc = r_sepc();
  uint64 sstatus = r_sstatus();
  uint64 scause = r_scause();
  
  if((sstatus & SSTATUS_SPP) == 0)
    panic("kerneltrap: not from supervisor mode");
  if(intr_get() != 0)
    panic("kerneltrap: interrupts enabled");

  if((which_dev = devintr()) == 0){
    // interrupt or trap from an unknown source
    printf("scause=0x%lx sepc=0x%lx stval=0x%lx\n", scause, r_sepc(), r_stval());
    panic("kerneltrap");
  }

  // give up the CPU if this is a timer interrupt.
  if(which_dev == 2 && myproc() != 0)
    yield();

  // the yield() may have caused some traps to occur,
  // so restore trap registers for use by kernelvec.S's sepc instruction.
  w_sepc(sepc);
  w_sstatus(sstatus);
}

 

 

 

📌 kernel/syscall.c

• General system call handling
• User Program이 kernel 기능 요청 시 사용하는 인터페이스 
• System Call -> 해당하는 kernel func 호출 · 전달

void
syscall(void)
{
  int num;
  struct proc *p = myproc();

  num = p->trapframe->a7;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    // Use num to lookup the system call function for num, call it,
    // and store its return value in p->trapframe->a0
    p->trapframe->a0 = syscalls[num]();
  } else {
    printf("%d %s: unknown sys call %d\n",
            p->pid, p->name, num);
    p->trapframe->a0 = -1;
  }
}

 

• User Trap -> Syscall 호출 
• a7 register: System Call number 저장
• 매핑된 sys_ func 호출 -> 반환 값 a0에 저장 

 

 

 

📌 kernel/sysproc.c

• Several system call implementations
• system call 중 프로세스 기능 구현 (커널 내부 동작 정의)
• User Program이 요청하는 system call의 로직을 커널에서 구현

uint64
sys_exit(void)
{
  int n;
  argint(0, &n);
  exit(n);
  return 0;  // not reached
}

uint64
sys_getpid(void)
{
  return myproc()->pid;
}

uint64
sys_fork(void)
{
  return fork();
}

uint64
sys_wait(void)
{
  uint64 p;
  argaddr(0, &p);
  return wait(p);
}

uint64
sys_sbrk(void)
{
  uint64 addr;
  int n;

  argint(0, &n);
  addr = myproc()->sz;
  if(growproc(n) < 0)
    return -1;
  return addr;
}

uint64
sys_sleep(void)
{
  int n;
  uint ticks0;

  argint(0, &n);
  if(n < 0)
    n = 0;
  acquire(&tickslock);
  ticks0 = ticks;
  while(ticks - ticks0 < n){
    if(killed(myproc())){
      release(&tickslock);
      return -1;
    }
    sleep(&ticks, &tickslock);
  }
  release(&tickslock);
  return 0;
}

uint64
sys_kill(void)
{
  int pid;

  argint(0, &pid);
  return kill(pid);
}

 

+ 실제 system call 내용들을 구현하는 부분 

 

 

 

 

 

 

 

 

출처: https://github.com/snu-csl/os-pa2/

GitHub - snu-csl/os-pa2: OS Project #2 (Fall 2024)