ilo-pona/xv6-65oo2
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Activity

Merge branch 'riscv-proc' into riscv

Browse source
This commit is contained in:
Frans Kaashoek 2019-07-08 15:50:06 -04:00
parent 75b0c6fc91 60ed537427
commit 2f22a3ed6a
17 changed files with 176 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
kernel/exec.c
View file

@ -2,6 +2,7 @@
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
#include "spinlock.h"
#include "proc.h"
#include "defs.h"
#include "elf.h"
@ -19,7 +20,6 @@ exec(char *path, char **argv)
struct proghdr ph;
pagetable_t pagetable = 0, oldpagetable;
struct proc *p = myproc();
uint64 oldsz = p->sz;
begin_op();
@ -60,6 +60,9 @@ exec(char *path, char **argv)
end_op();
ip = 0;
p = myproc();
uint64 oldsz = p->sz;
// Allocate two pages at the next page boundary.
// Use the second as the user stack.
sz = PGROUNDUP(sz);

2
kernel/fs.c
View file

@ -14,8 +14,8 @@
#include "defs.h"
#include "param.h"
#include "stat.h"
#include "proc.h"
#include "spinlock.h"
#include "proc.h"
#include "sleeplock.h"
#include "fs.h"
#include "buf.h"

2
kernel/pipe.c
View file

@ -2,9 +2,9 @@
#include "riscv.h"
#include "defs.h"
#include "param.h"
#include "spinlock.h"
#include "proc.h"
#include "fs.h"
#include "spinlock.h"
#include "sleeplock.h"
#include "file.h"

248
kernel/proc.c
View file

@ -2,33 +2,36 @@
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
#include "proc.h"
#include "spinlock.h"
#include "proc.h"
#include "defs.h"
struct {
struct spinlock lock;
struct proc proc[NPROC];
} ptable;
struct proc proc[NPROC];
struct cpu cpus[NCPU];
struct proc *initproc;
struct spinlock pid_lock;
int nextpid = 1;
extern void forkret(void);
// for returning out of the kernel
extern void sysexit(void);
static void wakeup1(void *chan);
static void wakeup1(struct proc *chan);
extern char trampout[]; // trampoline.S
void
procinit(void)
{
initlock(&ptable.lock, "ptable");
struct proc *p;
initlock(&pid_lock, "nextpid");
for(p = proc; p < &proc[NPROC]; p++)
initlock(&p->lock, "proc");
}
// Must be called with interrupts disabled,
@ -60,40 +63,48 @@ myproc(void) {
return p;
}
int
allocpid() {
int pid;
acquire(&pid_lock);
pid = nextpid++;
release(&pid_lock);
return pid;
}
//PAGEBREAK: 32
// Look in the process table for an UNUSED proc.
// If found, change state to EMBRYO and initialize
// state required to run in the kernel.
// If found, initialize state required to run in the kernel,
// and return with p->lock held.
// Otherwise return 0.
static struct proc*
allocproc(void)
{
struct proc *p;
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
if(p->state == UNUSED)
for(p = proc; p < &proc[NPROC]; p++) {
acquire(&p->lock);
if(p->state == UNUSED) {
goto found;
release(&ptable.lock);
} else {
release(&p->lock);
}
}
return 0;
found:
p->state = EMBRYO;
p->pid = nextpid++;
release(&ptable.lock);
p->pid = allocpid();
// Allocate a page for the kernel stack.
if((p->kstack = kalloc()) == 0){
p->state = UNUSED;
return 0;
}
// Allocate a trapframe page.
if((p->tf = (struct trapframe *)kalloc()) == 0){
p->state = UNUSED;
kfree(p->kstack);
p->kstack = 0;
return 0;
}
@ -111,7 +122,7 @@ found:
// free a proc structure and the data hanging from it,
// including user pages.
// the proc lock must be held.
// p->lock must be held.
static void
freeproc(struct proc *p)
{
@ -195,22 +206,16 @@ userinit(void)
uvminit(p->pagetable, initcode, sizeof(initcode));
p->sz = PGSIZE;
// prepare for the very first kernel->user.
// prepare for the very first "return" from kernel to user.
p->tf->epc = 0;
p->tf->sp = PGSIZE;
safestrcpy(p->name, "initcode", sizeof(p->name));
p->cwd = namei("/");
// this assignment to p->state lets other cores
// run this process. the acquire forces the above
// writes to be visible, and the lock is also needed
// because the assignment might not be atomic.
acquire(&ptable.lock);
p->state = RUNNABLE;
release(&ptable.lock);
release(&p->lock);
}
// Grow current process's memory by n bytes.
@ -223,11 +228,13 @@ growproc(int n)
sz = p->sz;
if(n > 0){
if((sz = uvmalloc(p->pagetable, sz, sz + n)) == 0)
if((sz = uvmalloc(p->pagetable, sz, sz + n)) == 0) {
return -1;
}
} else if(n < 0){
if((sz = uvmdealloc(p->pagetable, sz, sz + n)) == 0)
if((sz = uvmdealloc(p->pagetable, sz, sz + n)) == 0) {
return -1;
}
}
p->sz = sz;
return 0;
@ -250,6 +257,7 @@ fork(void)
// 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;
@ -272,15 +280,39 @@ fork(void)
pid = np->pid;
acquire(&ptable.lock);
np->state = RUNNABLE;
release(&ptable.lock);
release(&np->lock);
return pid;
}
// Pass p's abandoned children to init. p and p's parent
// are locked.
void
reparent(struct proc *p, struct proc *parent) {
struct proc *pp;
int child_of_init = (p->parent == initproc);
for(pp = proc; pp < &proc[NPROC]; pp++){
if (pp != p && pp != parent) {
acquire(&pp->lock);
if(pp->parent == p){
pp->parent = initproc;
if(pp->state == ZOMBIE) {
if(!child_of_init)
acquire(&initproc->lock);
wakeup1(initproc);
if(!child_of_init)
release(&initproc->lock);
}
}
release(&pp->lock);
}
}
}
// Exit the current process. Does not return.
// An exited process remains in the zombie state
// until its parent calls wait().
@ -288,7 +320,6 @@ void
exit(void)
{
struct proc *p = myproc();
struct proc *pp;
int fd;
if(p == initproc)
@ -297,7 +328,8 @@ exit(void)
// Close all open files.
for(fd = 0; fd < NOFILE; fd++){
if(p->ofile[fd]){
fileclose(p->ofile[fd]);
struct file *f = p->ofile[fd];
fileclose(f);
p->ofile[fd] = 0;
}
}
@ -307,22 +339,20 @@ exit(void)
end_op();
p->cwd = 0;
acquire(&ptable.lock);
acquire(&p->parent->lock);
acquire(&p->lock);
reparent(p, p->parent);
p->state = ZOMBIE;
// Parent might be sleeping in wait().
wakeup1(p->parent);
// Pass abandoned children to init.
for(pp = ptable.proc; pp < &ptable.proc[NPROC]; pp++){
if(pp->parent == p){
pp->parent = initproc;
if(pp->state == ZOMBIE)
wakeup1(initproc);
}
}
release(&p->parent->lock);
// Jump into the scheduler, never to return.
p->state = ZOMBIE;
sched();
panic("zombie exit");
}
@ -335,32 +365,35 @@ wait(void)
struct proc *np;
int havekids, pid;
struct proc *p = myproc();
acquire(&ptable.lock);
acquire(&p->lock);
for(;;){
// Scan through table looking for exited children.
havekids = 0;
for(np = ptable.proc; np < &ptable.proc[NPROC]; np++){
for(np = proc; np < &proc[NPROC]; np++){
if(np->parent != p)
continue;
acquire(&np->lock);
havekids = 1;
if(np->state == ZOMBIE){
// Found one.
pid = np->pid;
freeproc(np);
release(&ptable.lock);
release(&np->lock);
release(&p->lock);
return pid;
}
release(&np->lock);
}
// No point waiting if we don't have any children.
if(!havekids || p->killed){
release(&ptable.lock);
release(&p->lock);
return -1;
}
// Wait for children to exit. (See wakeup1 call in proc_exit.)
sleep(p, &ptable.lock); //DOC: wait-sleep
// Wait for children to exit. (See wakeup1 call in reparent.)
sleep(p, &p->lock); //DOC: wait-sleep
}
}
@ -377,35 +410,32 @@ scheduler(void)
{
struct proc *p;
struct cpu *c = mycpu();
c->proc = 0;
for(;;){
// Enable interrupts on this processor.
intr_on();
// Loop over process table looking for process to run.
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
if(p->state != RUNNABLE)
continue;
for(p = proc; p < &proc[NPROC]; p++) {
acquire(&p->lock);
if(p->state == RUNNABLE) {
// Switch to chosen process. It is the process's job
// to release its lock and then reacquire it
// before jumping back to us.
p->state = RUNNING;
c->proc = p;
swtch(&c->scheduler, &p->context);
// Switch to chosen process. It is the process's job
// to release ptable.lock and then reacquire it
// before jumping back to us.
c->proc = p;
p->state = RUNNING;
swtch(&c->scheduler, &p->context);
// Process is done running for now.
// It should have changed its p->state before coming back.
c->proc = 0;
// Process is done running for now.
// It should have changed its p->state before coming back.
c->proc = 0;
}
release(&p->lock);
}
release(&ptable.lock);
}
}
// Enter scheduler. Must hold only ptable.lock
// Enter scheduler. Must hold only p->lock
// and have changed proc->state. Saves and restores
// intena because intena is a property of this
// kernel thread, not this CPU. It should
@ -418,8 +448,8 @@ sched(void)
int intena;
struct proc *p = myproc();
if(!holding(&ptable.lock))
panic("sched ptable.lock");
if(!holding(&p->lock))
panic("sched p->lock");
if(mycpu()->noff != 1)
panic("sched locks");
if(p->state == RUNNING)
@ -436,10 +466,11 @@ sched(void)
void
yield(void)
{
acquire(&ptable.lock); //DOC: yieldlock
myproc()->state = RUNNABLE;
struct proc *p = myproc();
acquire(&p->lock); //DOC: yieldlock
p->state = RUNNABLE;
sched();
release(&ptable.lock);
release(&p->lock);
}
// A fork child's very first scheduling by scheduler()
@ -449,8 +480,8 @@ forkret(void)
{
static int first = 1;
// Still holding ptable.lock from scheduler.
release(&ptable.lock);
// Still holding p->lock from scheduler.
release(&myproc()->lock);
if (first) {
// Some initialization functions must be run in the context
@ -477,14 +508,14 @@ sleep(void *chan, struct spinlock *lk)
if(lk == 0)
panic("sleep without lk");
// Must acquire ptable.lock in order to
// Must acquire p->lock in order to
// change p->state and then call sched.
// Once we hold ptable.lock, we can be
// Once we hold p->lock, we can be
// guaranteed that we won't miss any wakeup
// (wakeup runs with ptable.lock locked),
// (wakeup runs with p->lock locked),
// so it's okay to release lk.
if(lk != &ptable.lock){ //DOC: sleeplock0
acquire(&ptable.lock); //DOC: sleeplock1
if(lk != &p->lock){ //DOC: sleeplock0
acquire(&p->lock); //DOC: sleeplock1
release(lk);
}
// Go to sleep.
@ -497,32 +528,37 @@ sleep(void *chan, struct spinlock *lk)
p->chan = 0;
// Reacquire original lock.
if(lk != &ptable.lock){ //DOC: sleeplock2
release(&ptable.lock);
if(lk != &p->lock){ //DOC: sleeplock2
release(&p->lock);
acquire(lk);
}
}
//PAGEBREAK!
// Wake up all processes sleeping on chan.
// The ptable lock must be held.
// Wake up p, used by exit()
// Caller should lock p.
static void
wakeup1(void *chan)
wakeup1(struct proc *p)
{
struct proc *p;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
if(p->state == SLEEPING && p->chan == chan)
p->state = RUNNABLE;
if(p->chan == p && p->state == SLEEPING) {
p->state = RUNNABLE;
}
}
// Wake up all processes sleeping on chan.
// Wake up all processes sleeping on chan. Never
// called when holding a p->lock
void
wakeup(void *chan)
{
acquire(&ptable.lock);
wakeup1(chan);
release(&ptable.lock);
struct proc *p;
for(p = proc; p < &proc[NPROC]; p++) {
acquire(&p->lock);
if(p->state == SLEEPING && p->chan == chan) {
p->state = RUNNABLE;
}
release(&p->lock);
}
}
// Kill the process with the given pid.
@ -533,18 +569,19 @@ kill(int pid)
{
struct proc *p;
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
for(p = proc; p < &proc[NPROC]; p++){
if(p->pid == pid){
acquire(&p->lock);
if(p->pid != pid)
panic("kill");
p->killed = 1;
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
p->state = RUNNABLE;
release(&ptable.lock);
release(&p->lock);
return 0;
}
}
release(&ptable.lock);
return -1;
}
@ -586,7 +623,6 @@ procdump(void)
{
static char *states[] = {
[UNUSED] "unused",
[EMBRYO] "embryo",
[SLEEPING] "sleep ",
[RUNNABLE] "runble",
[RUNNING] "run ",
@ -595,7 +631,7 @@ procdump(void)
struct proc *p;
char *state;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
for(p = proc; p < &proc[NPROC]; p++){
if(p->state == UNUSED)
continue;
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])

3
kernel/proc.h
View file

@ -78,10 +78,11 @@ struct trapframe {
/* 280 */ uint64 t6;
};
enum procstate { UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE };
enum procstate { UNUSED, SLEEPING, RUNNABLE, RUNNING, ZOMBIE };
// Per-process state
struct proc {
struct spinlock lock;
char *kstack; // Bottom of kernel stack for this process
uint64 sz; // Size of process memory (bytes)
pagetable_t pagetable; // Page table

9
kernel/riscv.h
View file

@ -304,6 +304,15 @@ w_tp(uint64 x)
asm volatile("mv tp, %0" : : "r" (x));
}
static inline uint64
r_ra()
{
uint64 x;
asm volatile("mv %0, ra" : "=r" (x) );
return x;
}
#define PGSIZE 4096 // bytes per page
#define PGSHIFT 12 // bits of offset within a page

2
kernel/sleeplock.c
View file

@ -5,8 +5,8 @@
#include "defs.h"
#include "param.h"
#include "memlayout.h"
#include "proc.h"
#include "spinlock.h"
#include "proc.h"
#include "sleeplock.h"
void

2
kernel/spinlock.h
View file

@ -5,5 +5,7 @@ struct spinlock {
// For debugging:
char *name; // Name of lock.
struct cpu *cpu; // The cpu holding the lock.
struct cpu *last_release;
uint64 last_pc;
};

4
kernel/stat.h
View file

@ -3,9 +3,9 @@
#define T_DEVICE 3 // Device
struct stat {
short type; // Type of file
int dev; // File system's disk device
uint ino; // Inode number
short type; // Type of file
short nlink; // Number of links to file
uint size; // Size of file in bytes
uint64 size; // Size of file in bytes
};

3
kernel/syscall.c
View file

@ -2,6 +2,7 @@
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
#include "spinlock.h"
#include "proc.h"
#include "syscall.h"
#include "defs.h"
@ -170,7 +171,9 @@ dosyscall(void)
num = p->tf->a7;
if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
//printf("%d: syscall %d\n", p->pid, num);
p->tf->a0 = syscalls[num]();
//printf("%d: syscall %d -> %d\n", p->pid, num, p->tf->a0);
} else {
printf("%d %s: unknown sys call %d\n",
p->pid, p->name, num);

2
kernel/sysfile.c
View file

@ -9,9 +9,9 @@
#include "defs.h"
#include "param.h"
#include "stat.h"
#include "spinlock.h"
#include "proc.h"
#include "fs.h"
#include "spinlock.h"
#include "sleeplock.h"
#include "file.h"
#include "fcntl.h"

1
kernel/sysproc.c
View file

@ -4,6 +4,7 @@
#include "date.h"
#include "param.h"
#include "memlayout.h"
#include "spinlock.h"
#include "proc.h"
uint64

2
kernel/trap.c
View file

@ -2,8 +2,8 @@
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
#include "proc.h"
#include "spinlock.h"
#include "proc.h"
#include "defs.h"
struct spinlock tickslock;

2
kernel/uart.c
View file

@ -2,8 +2,8 @@
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
#include "proc.h"
#include "spinlock.h"
#include "proc.h"
#include "defs.h"
//

2
runoff.list
View file

@ -9,6 +9,7 @@ kernel/date.h
# entering xv6
kernel/entry.S
kernel/start.c
kernel/main.c
# locks
@ -24,6 +25,7 @@ kernel/kalloc.c
# system calls
user/usys.pl
kernel/kernelvec.S
kernel/trap.c
kernel/syscall.h
kernel/syscall.c

2
user/ls.c
View file

@ -43,7 +43,7 @@ ls(char *path)
switch(st.type){
case T_FILE:
printf(1, "%s %d %d %d\n", fmtname(path), st.type, st.ino, st.size);
printf(1, "%s %d %d %l\n", fmtname(path), st.type, st.ino, st.size);
break;
case T_DIR:

2
user/printf.c
View file

@ -68,6 +68,8 @@ printf(int fd, const char *fmt, ...)
} else if(state == '%'){
if(c == 'd'){
printint(fd, va_arg(ap, int), 10, 1);
} else if(c == 'l') {
printint(fd, va_arg(ap, uint64), 10, 0);
} else if(c == 'x') {
printint(fd, va_arg(ap, int), 16, 0);
} else if(c == 'p') {