diff --git a/bio.c b/bio.c
index 12b258efa42512bd95cdc88a124d77a98ea13316..6a3968b49dc4b54d0c2aa480e359c6cf022fd846 100644
--- a/bio.c
+++ b/bio.c
@@ -41,7 +41,7 @@ binit(void)
{
struct buf *b;
- initlock(&bcache.lock, "buf_table");
+ initlock(&bcache.lock, "bcache");
//PAGEBREAK!
// Create linked list of buffers
diff --git a/console.c b/console.c
index 8f89b49c322842ae7e093e610cfa9a3b04b9e9e2..6834c6a1ef1b7c0ab6f683a723ecdffd3e464c44 100644
--- a/console.c
+++ b/console.c
@@ -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");
diff --git a/file.c b/file.c
index 05374e06636151d500c8765d9a8b765e5bffb1d6..12b1561ab6cda2598f4f20e560e673137cfd9681 100644
--- a/file.c
+++ b/file.c
@@ -14,7 +14,7 @@ struct {
void
fileinit(void)
{
- initlock(&ftable.lock, "file_table");
+ initlock(&ftable.lock, "ftable");
}
// Allocate a file structure.
diff --git a/fs.c b/fs.c
index 46179d43f2a8baea0ccfc6320aa818ebd090665a..13fc935454b70d8826fa381fa6b3453173a2f38a 100644
--- a/fs.c
+++ b/fs.c
@@ -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
diff --git a/ide.c b/ide.c
index cfe5728df9805f5ada16ffbf87d8a09b4765d5a7..1f19833220bab306283888ea615300e7fa52aca1 100644
--- a/ide.c
+++ b/ide.c
@@ -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;
}
diff --git a/init.c b/init.c
index e15cccf62fcadcfde3c3e5294c8327313485fecb..046b551b71b8e6ec068ac2bacea6e8756970d168 100644
--- a/init.c
+++ b/init.c
@@ -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();
}
diff --git a/kalloc.c b/kalloc.c
index e0b9765c849e4e2d6867fa104aaa7aee44531cb8..6c6ca7ee5ac1857f9bcf70411653fc7b47f8b836 100644
--- a/kalloc.c
+++ b/kalloc.c
@@ -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;
diff --git a/proc.c b/proc.c
index dd7d8818de199d8a45ccb49c703783a511734442..9ab4922099bdb71ceac4ceca996b188bbf249c31 100644
--- a/proc.c
+++ b/proc.c
@@ -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])
diff --git a/proc.h b/proc.h
index d37975c7a2cc92883d83e65b87365bd12f8484ae..2c7fadea5c49a5928fdb273d6111b30b25606171 100644
--- a/proc.h
+++ b/proc.h
@@ -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 1d9352d4328d6e893c1e03b8cb83b1b9a30f521b..cc2601ceed91ad962b6bcf80aa8ddd2b28df4d13 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();
}