diff options
| -rw-r--r-- | bio.c | 2 | ||||
| -rw-r--r-- | console.c | 27 | ||||
| -rw-r--r-- | file.c | 2 | ||||
| -rw-r--r-- | fs.c | 2 | ||||
| -rw-r--r-- | ide.c | 4 | ||||
| -rw-r--r-- | init.c | 4 | ||||
| -rw-r--r-- | kalloc.c | 26 | ||||
| -rw-r--r-- | proc.c | 86 | ||||
| -rw-r--r-- | proc.h | 4 | ||||
| -rw-r--r-- | usertests.c | 5 |
10 files changed, 82 insertions, 80 deletions
@@ -41,7 +41,7 @@ binit(void) { struct buf *b; - initlock(&bcache.lock, "buf_table"); + initlock(&bcache.lock, "bcache"); //PAGEBREAK! // Create linked list of buffers @@ -17,9 +17,12 @@ static ushort *crt = (ushort*)0xb8000; // CGA memory -static struct spinlock console_lock; -int panicked = 0; -volatile int use_console_lock = 0; +static struct { + struct spinlock lock; + int locking; +} cons; + +static int panicked = 0; static void cgaputc(int c) @@ -99,9 +102,9 @@ cprintf(char *fmt, ...) uint *argp; char *s; - locking = use_console_lock; + locking = cons.locking; if(locking) - acquire(&console_lock); + acquire(&cons.lock); argp = (uint*)(void*)&fmt + 1; state = 0; @@ -146,7 +149,7 @@ cprintf(char *fmt, ...) } if(locking) - release(&console_lock); + release(&cons.lock); } int @@ -155,10 +158,10 @@ consolewrite(struct inode *ip, char *buf, int n) int i; iunlock(ip); - acquire(&console_lock); + acquire(&cons.lock); for(i = 0; i < n; i++) consputc(buf[i] & 0xff); - release(&console_lock); + release(&cons.lock); ilock(ip); return n; @@ -255,12 +258,12 @@ consoleread(struct inode *ip, char *dst, int n) void consoleinit(void) { - initlock(&console_lock, "console"); - initlock(&input.lock, "console input"); + initlock(&cons.lock, "console"); + initlock(&input.lock, "input"); devsw[CONSOLE].write = consolewrite; devsw[CONSOLE].read = consoleread; - use_console_lock = 1; + cons.locking = 1; picenable(IRQ_KBD); ioapicenable(IRQ_KBD, 0); @@ -273,7 +276,7 @@ panic(char *s) uint pcs[10]; cli(); - use_console_lock = 0; + cons.locking = 0; cprintf("cpu%d: panic: ", cpu()); cprintf(s); cprintf("\n"); @@ -14,7 +14,7 @@ struct { void fileinit(void) { - initlock(&ftable.lock, "file_table"); + initlock(&ftable.lock, "ftable"); } // Allocate a file structure. @@ -138,7 +138,7 @@ struct { void iinit(void) { - initlock(&icache.lock, "icache.lock"); + initlock(&icache.lock, "icache"); } // Find the inode with number inum on device dev @@ -30,13 +30,13 @@ static void idestart(struct buf*); // Wait for IDE disk to become ready. static int -idewait(int check_error) +idewait(int checkerr) { int r; while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY) ; - if(check_error && (r & (IDE_DF|IDE_ERR)) != 0) + if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0) return -1; return 0; } @@ -5,7 +5,7 @@ #include "user.h" #include "fcntl.h" -char *sh_args[] = { "sh", 0 }; +char *argv[] = { "sh", 0 }; int main(void) @@ -27,7 +27,7 @@ main(void) exit(); } if(pid == 0){ - exec("sh", sh_args); + exec("sh", argv); printf(1, "init: exec sh failed\n"); exit(); } @@ -10,13 +10,15 @@ #include "param.h" #include "spinlock.h" -struct spinlock kalloc_lock; - struct run { struct run *next; int len; // bytes }; -struct run *freelist; + +struct { + struct spinlock lock; + struct run *freelist; +} kmem; // Initialize free list of physical pages. // This code cheats by just considering one megabyte of @@ -29,7 +31,7 @@ kinit(void) uint mem; char *start; - initlock(&kalloc_lock, "kalloc"); + initlock(&kmem.lock, "kmem"); start = (char*) &end; start = (char*) (((uint)start + PAGE) & ~(PAGE-1)); mem = 256; // assume computer has 256 pages of RAM @@ -52,10 +54,10 @@ kfree(char *v, int len) // Fill with junk to catch dangling refs. memset(v, 1, len); - acquire(&kalloc_lock); + acquire(&kmem.lock); p = (struct run*)v; pend = (struct run*)(v + len); - for(rp=&freelist; (r=*rp) != 0 && r <= pend; rp=&r->next){ + for(rp=&kmem.freelist; (r=*rp) != 0 && r <= pend; rp=&r->next){ rend = (struct run*)((char*)r + r->len); if(r <= p && p < rend) panic("freeing free page"); @@ -80,7 +82,7 @@ kfree(char *v, int len) *rp = p; out: - release(&kalloc_lock); + release(&kmem.lock); } // Allocate n bytes of physical memory. @@ -95,21 +97,21 @@ kalloc(int n) if(n % PAGE || n <= 0) panic("kalloc"); - acquire(&kalloc_lock); - for(rp=&freelist; (r=*rp) != 0; rp=&r->next){ + acquire(&kmem.lock); + for(rp=&kmem.freelist; (r=*rp) != 0; rp=&r->next){ if(r->len == n){ *rp = r->next; - release(&kalloc_lock); + release(&kmem.lock); return (char*)r; } if(r->len > n){ r->len -= n; p = (char*)r + r->len; - release(&kalloc_lock); + release(&kmem.lock); return p; } } - release(&kalloc_lock); + release(&kmem.lock); cprintf("kalloc: out of memory\n"); return 0; @@ -6,9 +6,11 @@ #include "proc.h" #include "spinlock.h" -struct spinlock proc_table_lock; +struct { + struct spinlock lock; + struct proc proc[NPROC]; +} ptable; -struct proc proc[NPROC]; static struct proc *initproc; int nextpid = 1; @@ -18,7 +20,7 @@ extern void forkret1(struct trapframe*); void pinit(void) { - initlock(&proc_table_lock, "proc_table"); + initlock(&ptable.lock, "ptable"); } // Look in the process table for an UNUSED proc. @@ -30,20 +32,19 @@ allocproc(void) int i; struct proc *p; - acquire(&proc_table_lock); - for(i = 0; i < NPROC; i++){ - p = &proc[i]; + acquire(&ptable.lock); + for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->state == UNUSED){ p->state = EMBRYO; p->pid = nextpid++; goto found; } } - release(&proc_table_lock); + release(&ptable.lock); return 0; found: - release(&proc_table_lock); + release(&ptable.lock); // Allocate kernel stack if necessary. if((p->kstack = kalloc(KSTACKSIZE)) == 0){ @@ -215,14 +216,13 @@ scheduler(void) sti(); // Loop over process table looking for process to run. - acquire(&proc_table_lock); - for(i = 0; i < NPROC; i++){ - p = &proc[i]; + acquire(&ptable.lock); + for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->state != RUNNABLE) continue; // Switch to chosen process. It is the process's job - // to release proc_table_lock and then reacquire it + // to release ptable.lock and then reacquire it // before jumping back to us. cp = p; usegment(); @@ -234,12 +234,12 @@ scheduler(void) cp = 0; usegment(); } - release(&proc_table_lock); + release(&ptable.lock); } } -// Enter scheduler. Must already hold proc_table_lock +// Enter scheduler. Must already hold ptable.lock // and have changed cp->state. void sched(void) @@ -250,8 +250,8 @@ sched(void) panic("sched interruptible"); if(cp->state == RUNNING) panic("sched running"); - if(!holding(&proc_table_lock)) - panic("sched proc_table_lock"); + if(!holding(&ptable.lock)) + panic("sched ptable.lock"); if(c->ncli != 1) panic("sched locks"); @@ -264,10 +264,10 @@ sched(void) void yield(void) { - acquire(&proc_table_lock); + acquire(&ptable.lock); cp->state = RUNNABLE; sched(); - release(&proc_table_lock); + release(&ptable.lock); } // A fork child's very first scheduling by scheduler() @@ -275,8 +275,8 @@ yield(void) void forkret(void) { - // Still holding proc_table_lock from scheduler. - release(&proc_table_lock); + // Still holding ptable.lock from scheduler. + release(&ptable.lock); // Jump into assembly, never to return. forkret1(cp->tf); @@ -293,14 +293,14 @@ sleep(void *chan, struct spinlock *lk) if(lk == 0) panic("sleep without lk"); - // Must acquire proc_table_lock in order to + // Must acquire ptable.lock in order to // change p->state and then call sched. - // Once we hold proc_table_lock, we can be + // Once we hold ptable.lock, we can be // guaranteed that we won't miss any wakeup - // (wakeup runs with proc_table_lock locked), + // (wakeup runs with ptable.lock locked), // so it's okay to release lk. - if(lk != &proc_table_lock){ - acquire(&proc_table_lock); + if(lk != &ptable.lock){ + acquire(&ptable.lock); release(lk); } @@ -313,15 +313,15 @@ sleep(void *chan, struct spinlock *lk) cp->chan = 0; // Reacquire original lock. - if(lk != &proc_table_lock){ - release(&proc_table_lock); + if(lk != &ptable.lock){ + release(&ptable.lock); acquire(lk); } } //PAGEBREAK! // Wake up all processes sleeping on chan. -// Proc_table_lock must be held. +// The ptable lock must be held. static void wakeup1(void *chan) { @@ -336,9 +336,9 @@ wakeup1(void *chan) void wakeup(void *chan) { - acquire(&proc_table_lock); + acquire(&ptable.lock); wakeup1(chan); - release(&proc_table_lock); + release(&ptable.lock); } // Kill the process with the given pid. @@ -349,18 +349,18 @@ kill(int pid) { struct proc *p; - acquire(&proc_table_lock); - for(p = proc; p < &proc[NPROC]; p++){ + acquire(&ptable.lock); + for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->pid == pid){ p->killed = 1; // Wake process from sleep if necessary. if(p->state == SLEEPING) p->state = RUNNABLE; - release(&proc_table_lock); + release(&ptable.lock); return 0; } } - release(&proc_table_lock); + release(&ptable.lock); return -1; } @@ -387,13 +387,13 @@ exit(void) iput(cp->cwd); cp->cwd = 0; - acquire(&proc_table_lock); + acquire(&ptable.lock); // Parent might be sleeping in wait(). wakeup1(cp->parent); // Pass abandoned children to init. - for(p = proc; p < &proc[NPROC]; p++){ + for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->parent == cp){ p->parent = initproc; if(p->state == ZOMBIE) @@ -416,12 +416,11 @@ wait(void) struct proc *p; int i, havekids, pid; - acquire(&proc_table_lock); + acquire(&ptable.lock); for(;;){ // Scan through table looking for zombie children. havekids = 0; - for(i = 0; i < NPROC; i++){ - p = &proc[i]; + for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->state == UNUSED) continue; if(p->parent == cp){ @@ -435,7 +434,7 @@ wait(void) p->pid = 0; p->parent = 0; p->name[0] = 0; - release(&proc_table_lock); + release(&ptable.lock); return pid; } } @@ -443,12 +442,12 @@ wait(void) // No point waiting if we don't have any children. if(!havekids || cp->killed){ - release(&proc_table_lock); + release(&ptable.lock); return -1; } // Wait for children to exit. (See wakeup1 call in proc_exit.) - sleep(cp, &proc_table_lock); + sleep(cp, &ptable.lock); } } @@ -471,8 +470,7 @@ procdump(void) char *state; uint pc[10]; - for(i = 0; i < NPROC; i++){ - p = &proc[i]; + for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){ if(p->state == UNUSED) continue; if(p->state >= 0 && p->state < NELEM(states) && states[p->state]) @@ -24,14 +24,14 @@ struct context { uint eip; }; -enum proc_state { UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE }; +enum procstate { UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE }; // Per-process state struct proc { char *mem; // Start of process memory (kernel address) uint sz; // Size of process memory (bytes) char *kstack; // Bottom of kernel stack for this process - enum proc_state state; // Process state + enum procstate state; // Process state volatile int pid; // Process ID struct proc *parent; // Parent process struct trapframe *tf; // Trap frame for current syscall diff --git a/usertests.c b/usertests.c index 1d9352d..cc2601c 100644 --- a/usertests.c +++ b/usertests.c @@ -6,8 +6,7 @@ char buf[2048]; char name[3]; -char *echo_args[] = { "echo", "ALL", "TESTS", "PASSED", 0 }; -char *cat_args[] = { "cat", "README", 0 }; +char *echoargv[] = { "echo", "ALL", "TESTS", "PASSED", 0 }; int stdout = 1; // simple file system tests @@ -191,7 +190,7 @@ void exectest(void) { printf(stdout, "exec test\n"); - if(exec("echo", echo_args) < 0) { + if(exec("echo", echoargv) < 0) { printf(stdout, "exec echo failed\n"); exit(); } |