sanchayanmaity/xv6-cs450
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

group locks into structs they protect.

Browse source 
few naming nits.
This commit is contained in:
rsc 2009-05-31 05:12:21 +00:00
parent 949e55902b
commit 34295f461a
10 changed files with 82 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bio.c
View file

@ -41,7 +41,7 @@ binit(void)
{
struct buf *b;
initlock(&bcache.lock, "buf_table");
initlock(&bcache.lock, "bcache");
//PAGEBREAK!
// Create linked list of buffers

27
console.c
View file

@ -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");

2
file.c
View file

@ -14,7 +14,7 @@ struct {
void
fileinit(void)
{
initlock(&ftable.lock, "file_table");
initlock(&ftable.lock, "ftable");
}
// Allocate a file structure.

2
fs.c
View file

@ -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

4
ide.c
View file

@ -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;
}

4
init.c
View file

@ -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();
}

24
kalloc.c
View file

@ -10,13 +10,15 @@
#include "param.h"
#include "spinlock.h"
struct spinlock kalloc_lock;
struct run {
struct run *next;
int len; // bytes
};
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;

86
proc.c
View file

@ -6,9 +6,11 @@
#include "proc.h"
#include "spinlock.h"
struct spinlock proc_table_lock;
struct {
struct spinlock lock;
struct proc proc[NPROC];
} ptable;
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])

4
proc.h
View file

@ -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

5
usertests.c
View file

@ -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();
}