Published on

6.S081 lab2 system calls

Authors

6.S081 的第二个实验，system calls，虽然是好久之前做的了，但是一直没把它放到博客里面。今天略无聊，就弄了一下。BTW，第三个实验我到现在都还没开始呢。

system call

在完成实验之前，我们可以先了解一下系统调用的相关的代码。

首先在user/usys.pl中包含生成系统调用汇编的 Perl 代码，其核心为下面这段代码：

sub entry {
    my $name = shift;
    print ".global $name\n";
    print "${name}:\n";
    print " li a7, SYS_${name}\n";
    print " ecall\n";
    print " ret\n";
}

可以看出来这是一个创建汇编的代码，例如调用entry("fork");会得到一下汇编：

fork:
 li a7, SYS_fork
 ecall
 ret

从xv6-book中，我们可以知道：

  • ecall是rsic-v中用来从用户态转到特权态的指令
  • a7用来保存要调用的系统调用号。
  • SYS_fork在kernel/syscall.h中被定义。

在ecall被调用时，RISC-V 的 CPU 会设置一些寄存器（如将pc保存在sepc），然后将stvec保存到pc中，这时，CPU就会执行stvec所指向的代码了，stvec在返回用户态时会被设置成kernel/trampoline.S中uservec（见kernel/trap.c#L100）.

uservec的主要做了以下几件事情：

  1. 交换a0和sscratch寄存器，而sscratch是进程用户空间的trapframe的虚拟地址，此时已经将a0保存到sscratch寄存器中了。
  2. 保存寄存器到trapframe中（包括a0）
  3. 从trapframe中恢复内核栈、切换页表
  4. 跳转到usertrap中

usertrap（kernel/trap.c#32）主要做了以下几件事：

  1. 检验是否从用户态进入（通过sstatus确认）。
  2. 设置stvec为kernelvec，保存用户态pc（在调用ecall时被保存到了sepc中了）。
  3. 关中断
  4. 执行syscall进行系统调用
  5. 调用usertrapret返回

前面的步骤已经将用户态转换成内核态，并将需要保存的信息保存到对应的位置，并将栈和页表等切换成内核所使用的栈和页表了。

syscall（kernel/syscall.c#133）的代码如下：

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

  num = p->trapframe->a7;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    p->trapframe->a0 = syscalls[num]();
  } else {
    printf("%d %s: unknown sys call %d\n",
            p->pid, p->name, num);
    p->trapframe->a0 = -1;
  }
}

可以看到在syscall中，它从a7取出system call number，并调用了对应的handler，然后把返回值保存到用户态的a0中。

系统调用返回的过程有点像是刚才的逆过程，uservec和usertrap分别对应userret和usertrapret。这里不在赘述。

总结以下，当我们调用fork()时会发生的事情。

  1. 通过usys.pl生成的汇编fork()将参数放到a7中，并调用ecall
  2. 调用ecall时，CPU 会执行一些操作（保存用户态pc到sepc，拷贝stvec到pc中）
  3. 由于stvec在用户态时指向uservec，所以会执行uservec来保存寄存器、切换页表、恢复内核堆栈，并跳转到usertrap
  4. usertrap会将stvec修改成kernelvec，关中断调用syscall
  5. syscall会根据a7中保存的system call number来调用对应的handler，执行完后返回值保存在a0中。
  6. usertrap末尾调用usertrapret，而usertrapret会跳转到userret，这两个过程会逆向uservec和usertrap的操作。

trace

由于前面已经分析过调用系统调用的过程了，但是添加一个系统调用还是有所不同的，我们要进行以下步骤：

  1. 在kernel/syscall.h中设置系统调用号，如#define SYS_trace 22
  2. 在kernel/syscall.c中的syscalls数组中设置对应的 handler 函数，同时需要在该数组的上方加入相关的函数声明，如extern unit64 sys_trace(void);
  3. 在kernel/sysproc.c中实现对应的 handler 函数，如sys_trace函数
  4. 在user/user.h中添加函数声明，如int trace(int);
  5. 在user/usys.pl添加对应的entry已生成相应系统调用的汇编，如entry("trace");

添加完成后，我们可以就需要实现kernel/sysproc.c中sys_trace的实现了。

首先，题目要求我们能够通过trace系统调用来设置哪些系统调用会被trace，而且trace的参数也已经提示我们要用1 << SYS_*的方式来设置mask了，mask应该由trace命令来设置。trace应该是只时对某个进程有效的，所以这个mask应该与进程绑定，所以我们可以在进程proc结构体中加入一个新的变量tracemask。然后sys_trace只需要获取用户态传入的参数，并设置进程的tracemask即可。

sys_trace的实现如下：

uint64
sys_trace(void)
{
    int mask;
    if (argint(0, &mask) < 0)
        return -1;
    myproc()->tracemask = mask;
    return 0;
}

从上面关于系统调用的分析可以知道，每个系统调用的 handler 都会由syscall来调用，所以我们可以在修改这个函数来实现每次系统调用 handler 返回后都输出对应的信息。pid和系统调用返回值都可以直接获取到，而系统调用名称则需要自己手动写一个字符串数组来映射。下面是实现代码：

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

  num = p->trapframe->a7;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    p->trapframe->a0 = syscalls[num]();
    if (!!(1 << num  & p->tracemask)) {
        printf("%d: syscall %s -> %d\n", p->pid, syscall_name[num], p->trapframe->a0);
    }
  } else {
    printf("%d %s: unknown sys call %d\n",
            p->pid, p->name, num);
    p->trapframe->a0 = -1;
  }
}

由于题目要求某个进程被trace后，其子进程也要被trace，所以我们只需要在fork中简单的添加np->tracemask = p->tracemask即可。

sysinfo

这里要增加一个系统调用来实现sysinfo，因为前面已经描述过给xv6增加系统调用的过程了，这里不在赘述。

因为sysinfo需要传入一个struct sysinfo的指针，然后通过这个指针返回一个struct sysinfo，这个结构体主要包含两个属性：freemem和nproc，即当前空闲内存和当前状态不为UNUSED的proc数量。所以这个实验主要要解决三个问题：

  1. 计算当前空闲内存大小
  2. 计算当前状态不为UNUSED的proc数量
  3. 将计算得到的值从内核态拷贝到用户态。

freemem

在kernel/kalloc.c代码中可以看到：

struct run {
  struct run *next;
};

struct {
  struct spinlock lock;
  struct run *freelist;
} kmem;

这里有一个全局变量kmem，她包含了一个名为freelist的链表指针和保护该链表的锁。从其他相关代码可以看出这个freelist所代表的链表是空闲页，每一个空闲页的开头都保存着下一个空闲页的位置，由于每一页的大小都是固定的，已知的（由PGSIZE确定），所以通过遍历一个freelist可以计算出空闲内存大小。这个要主要的是在遍历链表时，需要想获取锁。实现代码如下：

uint64
kfreemem(void)
{
    uint64 size = 0;
    struct run *r;
    acquire(&kmem.lock);

    for(r = kmem.freelist ; r ; r = r->next)
        size += PGSIZE;
    release(&kmem.lock);
    return size;
}

nproc

从kernel/proc.c可以看出来内核中可用的struct proc是由一个数组存储的，我们可以简单的遍历这个数组，然后判断每个元素的状态是否为UNUSED，然后计数即可。代码如下：

uint64
nproc(void)
{
    uint64 n = 0;
    struct proc *p;
    for(p = proc;p < &proc[NPROC]; p++) {
        if (p->state != UNUSED)
            n++;
    }
    return n;
}

copyout

由于sys_sysinfo系统调用读到的地址是用户态的虚拟地址，所以不能在内核直接使用，copyout函数来将内存中的数据拷贝到用户态。从实验给出的提示可以看出，可以从参考sys_fstat和filestat来使用copyout。由于sys_fstat只涉及到读取参数和调用filestat，所以这里只给出filestat的代码，它的第二个参数就是用户态的地址。

// Get metadata about file f.
// addr is a user virtual address, pointing to a struct stat.
int
filestat(struct file *f, uint64 addr)
{
  struct proc *p = myproc();
  struct stat st;

  if(f->type == FD_INODE || f->type == FD_DEVICE){
    ilock(f->ip);
    stati(f->ip, &st);
    iunlock(f->ip);
    if(copyout(p->pagetable, addr, (char *)&st, sizeof(st)) < 0)
      return -1;
    return 0;
  }
  return -1;
}

上面的代码关键在于copyout(p->pagetable, add, (char*)&st, sizeof(st))，这里可以看出copyout是通过进程的页表来计算实地址的位置。

因此，我们可以写出sys_sysinfo的代码如下：

uint64
sys_sysinfo(void)
{
    struct sysinfo info;
    struct proc *p = myproc();
    uint64 pinfo;

    if (argaddr(0, &pinfo) < 0)
        return -1;

    info.freemem = kfreemem();
    info.nproc = nproc();


    if (copyout(p->pagetable, pinfo, (char *)&info, sizeof(info)) < 0)
        return -1;
    return 0;
}
View on GitHub