From 34295f461a416e40bb76e67c568a761222dc6913 Mon Sep 17 00:00:00 2001
From: rsc <rsc>
Date: Sun, 31 May 2009 05:12:21 +0000
Subject: [PATCH] group locks into structs they protect. few naming nits.

---
 bio.c       |  2 +-
 console.c   | 27 +++++++++--------
 file.c      |  2 +-
 fs.c        |  2 +-
 ide.c       |  4 +--
 init.c      |  4 +--
 kalloc.c    | 26 ++++++++--------
 proc.c      | 86 ++++++++++++++++++++++++++---------------------------
 proc.h      |  4 +--
 usertests.c |  5 ++--
 10 files changed, 82 insertions(+), 80 deletions(-)

diff --git a/bio.c b/bio.c
index 12b258e..6a3968b 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 8f89b49..6834c6a 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 05374e0..12b1561 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 46179d4..13fc935 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 cfe5728..1f19833 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 e15cccf..046b551 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 e0b9765..6c6ca7e 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 dd7d881..9ab4922 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 d37975c..2c7fade 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 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();
   }