6.S081 lab2
Preparation
xv6 book 部分
这一部分最核心的我觉得是x6机器从通电到创建第一个进程的过程:
1.通电,初始化然后加载bootloader,boot loader 把 kernel的代码加载到内存。
2.kernel代码从一个叫entry.S的汇编代码开始执行,它初始化了一个栈,可以让xv6运行c语言代码。然后他就call一个叫stat的c函数处。
3. start函数首先执行一些只有在机器模式才能做的配置,然后切换到监督模式(supervisor mode),并跳转到了main函数。
4. main函数初始几个设备和子系统,然后调用 userinit创建第一个进程。userinit通过调用 initcode.S,然后initcode.S又通过exec这个系统调用进入内核。exec执行完成后,返回到init进程,他会创建shell。
源码阅读
在读这个lab要求的源码的时候,在kernel/syscall.c中发现个奇怪的语法
static uint64 (*syscalls[])(void) = {
[SYS_fork] sys_fork,
[SYS_exit] sys_exit,
[SYS_wait] sys_wait,
[SYS_pipe] sys_pipe,
[SYS_read] sys_read,
[SYS_kill] sys_kill,
[SYS_exec] sys_exec,
[SYS_fstat] sys_fstat,
[SYS_chdir] sys_chdir,
[SYS_dup] sys_dup,
[SYS_getpid] sys_getpid,
[SYS_sbrk] sys_sbrk,
[SYS_sleep] sys_sleep,
[SYS_uptime] sys_uptime,
[SYS_open] sys_open,
[SYS_write] sys_write,
[SYS_mknod] sys_mknod,
[SYS_unlink] sys_unlink,
[SYS_link] sys_link,
[SYS_mkdir] sys_mkdir,
[SYS_close] sys_close,
[SYS_trace] sys_trace,
[SYS_sysinfo] sys_sysinfo,
};
这是定义了一个函数指针数组变量,然后初始化,[ ]是在指定下标赋值。
System call tracing
目标是要我们写一个系统调用,来参数mask指定的系统调用,并输出 进程号,系统调用名称以及该调用的返回值。
首先要知道内核是通过查看 a7中的数据来确定是调用哪个系统调用的,然后执行该系统调用并把值存到a0中。
我们首先要修改 kernel/proc.c 中的proc结构,增加一个参数来保存mask,这个参数可以是数组也可以是其他东西,我这里用的是int
struct proc {
struct spinlock lock;
// p->lock must be held when using these:
enum procstate state; // Process state
struct proc *parent; // Parent process
void *chan; // If non-zero, sleeping on chan
int killed; // If non-zero, have been killed
int xstate; // Exit status to be returned to parent's wait
int pid; // Process ID
// these are private to the process, so p->lock need not be held.
uint64 kstack; // Virtual address of kernel stack
uint64 sz; // Size of process memory (bytes)
pagetable_t pagetable; // User page table
struct trapframe *trapframe; // data page for trampoline.S
struct context context; // swtch() here to run process
struct file *ofile[NOFILE]; // Open files
struct inode *cwd; // Current directory
char name[16]; // Process name (debugging)
int mask; //trace的参数
};
然后在kernel/sysproc.c中增加一个系统调用函数,到时候syscall.c会调用这个函数。
uint64
sys_trace(void)
{
struct proc *p = myproc();
int n;
if(argint(0, &n) < 0)
return -1;
p->mask=n;
return 0;
}
这个函数很简单,就是把读取mask参数并保存到proc里。
然后要修改fork()和syscall().
fork()是要让他在fork的时候也要复制上一个进程的mask信息
int
fork(void)
{
int i, pid;
struct proc *np;
struct proc *p = myproc();
// Allocate process.
if((np = allocproc()) == 0){
return -1;
}
// Copy user memory from parent to child.
if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
freeproc(np);
release(&np->lock);
return -1;
}
np->sz = p->sz;
np->parent = p;
np->mask=p->mask;
// copy saved user registers.
*(np->trapframe) = *(p->trapframe);
// Cause fork to return 0 in the child.
np->trapframe->a0 = 0;
// increment reference counts on open file descriptors.
for(i = 0; i < NOFILE; i++)
if(p->ofile[i])
np->ofile[i] = filedup(p->ofile[i]);
np->cwd = idup(p->cwd);
safestrcpy(np->name, p->name, sizeof(p->name));
pid = np->pid;
np->state = RUNNABLE;
release(&np->lock);
return pid;
}
syscall( )是要在系统调用的时候根据mask判断要不要printf。
当然为了方便输出,用一个数组保存了那些系统调用名
static char* syscall_names[24]={"","fork","exit","wait","pipe","read","kill",
"exec","fstat","chdir","dup","getpid","sbrk","sleep","uptime","open","write",
"mknod","unlink","link","mkdir","close","trace","sysinfo"
};
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(((p->mask)&(1<<(p->trapframe->a7)))!=0){
printf("%d: syscall %s -> %d\n",p->pid,syscall_names[p->trapframe->a7],p->trapframe->a0);
}
} else {
printf("%d %s: unknown sys call %d\n",
p->pid, p->name, num);
p->trapframe->a0 = -1;
}
}
Sysinfo
在 kernel/kalloc.c中增加一个函数,用来计算剩余的内存大小。这个直接遍历页表freelist的数量,然后乘上页大小4096就好了。
int
freemem(void){
int cnt=0;
struct run *r;
r = kmem.freelist;
while(r){
cnt+=4096;
r=r->next;
}
//printf("freemem: %d\n",cnt);
return cnt;
}
在kernel/proc.c加一个函数,计算题意要求的进程数目。
int
nproc(void){
int cnt=0;
struct proc *p;
for(p = proc; p < &proc[NPROC]; p++){
if(p->state!=UNUSED){
cnt+=1;
}
}
//printf("nproc: %d\n",cnt);
return cnt;
}
最后在kernel/sysproc.c中增加sysinfo( )函数。
uint64
sys_sysinfo(void){
//printf("sys_sysinfo\n");
struct proc *p = myproc();
uint64 addr;
if(argaddr(0, &addr) < 0)
return -1;
/*
struct sysinfo info;
info.freemem=freemem();
info.nproc=nproc();
printf("free:%d nproc:%d\n",info.freemem,info.nproc);
if((copyout(p->pagetable, addr, (char *)&info, sizeof(info))<0))
return -1;
*/
uint64 info[2]={freemem(),nproc()};
printf("free:%d nproc:%d\n",info[0],info[1]);
if((copyout(p->pagetable, addr, (char *)info, sizeof(info))<0))
return -1;
return 0;
}
注意 struct sysinfo结构体是两个unit64的数,所以用数组存的话注意数组也要用unit64。
总结
这个lab一开始写的时候比较艰难,主要是自己没弄清系统调用的流程,弄清之后就比较容易了。