当前位置：首页 > ops >正文

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

ops 2025/8/29 14:35:54

接上文 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: sleeplock1release(lk);// Go to sleep.p->chan = chan;p->state = SLEEPING;sched();// Tidy up.p->chan = 0;// Reacquire original lock.release(&p->lock);acquire(lk);
}