MIT XV6 - 1.6 Lab: Xv6 and Unix utilities -uptime

接上文 MIT XV6 - 1.5 Lab: Xv6 and Unix utilities - xargs

第一章持续有点久了，虽然肯定有些特点和细节还没注意到，但这次的主要目的是学习内核部分，决定水一篇然后进入第二章节

uptime

第一章的最后一个实验，选做性质，实验介绍和要求如下 (原文链接 译文链接) :

Optional challenge exercises

• Write an uptime program that prints the uptime in terms of ticks using the uptime system call. (easy)

当然还有好几个教材中提到的选做的实验有简单的也有很有挑战的，但都是用户层的实现了，决定水一个之后赶紧后续的内容，要求。。。等于没有要求，macOS上运行 uptime 输出如下:

uptime
23:42  up 1 day, 8 mins, 2 users, load averages: 1.92 1.96 2.08

我决定。。。什么也不干，就 printf一下

#include "kernel/types.h"
#include "user/user.h"

int main(void) {
  printf("%d\n", uptime());
  exit(0);
}

实验结果，刚进入系统后执行是个很小的数字，随着系统运行时间增加而增加，是系统运行以来时钟中断次数

$ uptime
32
$ uptime
68
$ uptime
113
$ 

他肯定不是秒，但精度好像也不怎么高的样子。

其实有意思的是他旁边的 sys_sleep，代码在 kernal/sysproc.c : 52

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)
{
  // ignore
}

// return how many clock tick interrupts have occurred
// since start.
uint64
sys_uptime(void)
{
  uint xticks;

  acquire(&tickslock);
  xticks = ticks;
  release(&tickslock);
  return xticks;
}

我们大致可以看出来，sys_uptime 的实现就是去对 tickslock 加锁，取一份 ticks, 然后释放锁返回～

sys_sleep 实现复杂多了, 大致流程是

• 获取参数 n
• 对 tickslock 上锁
• 记录当前的 ticks
• 循环直到 now_ticks - old_ticks >= n
• 循环中判断如果进程被干掉了，就直接释放锁返回错误
• 调用 sleep 使进程进入休眠状态等待下次调度
• 唤醒后若条件达到，退出循环，释放锁，返回；否则继续上面的循环体

我们先找一找 这个 ticks 和 tickslock 都是哪里来的吧, 分别在 kernel/trap.c:10 和 kernel/trap.c:9

struct spinlock tickslock;
uint ticks;

看来就是一个自选锁和一个全局的变量，哪里更新他呢，在 kernel/trap.c: 164 的系统中断处理函数 clockintr 中:

void
clockintr()
{
  acquire(&tickslock);
  ticks++;
  wakeup(&ticks);
  release(&tickslock);
}

也比较简单啊，上锁 -> 自加1 -> 唤醒 &ticks -> 释放锁，其中的 weakup函数的参数 &ticks 是个什么鬼？我们看一下 wakeup 函数定义

// Wake up all processes sleeping on chan.
// Must be called without any p->lock.
void
wakeup(void *chan)
{
  struct proc *p;

  for(p = proc; p < &proc[NPROC]; p++) {
    if(p != myproc()){
      acquire(&p->lock);
      if(p->state == SLEEPING && p->chan == chan) {
        p->state = RUNNABLE;
      }
      release(&p->lock);
    }
  }
}

结合代码和注释来看，有点像是一个标记，一个channel，一个flag，一个队列，或者是一个可以让进程注册到操作系统中的一个回调机制? 简化的 IO 等待？
回到 sleep

// Atomically release lock and sleep on chan.
// Reacquires lock when awakened.
void
sleep(void *chan, struct spinlock *lk)
{
  struct proc *p = myproc();
  
  // Must acquire p->lock in order to
  // change p->state and then call sched.
  // Once we hold p->lock, we can be
  // guaranteed that we won't miss any wakeup
  // (wakeup locks p->lock),
  // so it's okay to release lk.

  acquire(&p->lock);  //DOC: sleeplock1
  release(lk);

  // Go to sleep.
  p->chan = chan;
  p->state = SLEEPING;

  sched();

  // Tidy up.
  p->chan = 0;

  // Reacquire original lock.
  release(&p->lock);
  acquire(lk);
}

这样看下来就明了多了:

• 上进程锁，休眠锁？
• 释放刚刚传入的 tickslock
• 将当前进程的channel设置为 &ticks
• 将当前进程状态设置为 SLEEPING
• 交出CPU，让调度器去玩去
• 唤醒后，重制 p->chan
• 释放进程 sleep lock
• 重新获取传入的 tickslock

所以 Xv6 系统中对于 sleep 的实现就是上面的全部了.