move everything having to do with proc_table_lock into proc.c

643b122b · rsc · 34976701 · 643b122b · 643b122b · 643b122b
--- a/defs.h
+++ b/defs.h
@@ -19,6 +19,8 @@ void sleep(void *, struct spinlock *);
 void wakeup(void *);
 void scheduler(void);
 void proc_exit(void);
+int proc_kill(int);
+int proc_wait(void);
 void yield(void);
 void cli(void);
 void sti(void);

--- a/picirq.c
+++ b/picirq.c
@@ -53,7 +53,7 @@ pic_init(void)
  outb(IO_PIC2+1, IRQ_SLAVE);		// ICW3
  // NB Automatic EOI mode doesn't tend to work on the slave.
  // Linux source code says it's "to be investigated".
-  outb(IO_PIC2+1, 0x3);			// ICW4
+  outb(IO_PIC2+1, 0x1);			// ICW4

  // OCW3:  0ef01prs
  //   ef:  0x = NOP, 10 = clear specific mask, 11 = set specific mask

--- a/proc.c
+++ b/proc.c
@@ -281,6 +281,56 @@ proc_exit()
  panic("a zombie revived");
 }

+int
+proc_wait(void)
+{
+  struct proc *p;
+  struct proc *cp = curproc[cpu()];
+  int any, pid;
+
+  acquire(&proc_table_lock);
+
+  while(1){
+    any = 0;
+    for(p = proc; p < &proc[NPROC]; p++){
+      if(p->state == ZOMBIE && p->ppid == cp->pid){
+        kfree(p->mem, p->sz);
+        kfree(p->kstack, KSTACKSIZE);
+        pid = p->pid;
+        p->state = UNUSED;
+        release(&proc_table_lock);
+        return pid;
+      }
+      if(p->state != UNUSED && p->ppid == cp->pid)
+        any = 1;
+    }
+    if(any == 0){
+      release(&proc_table_lock);
+      return -1;
+    }
+    sleep(cp, &proc_table_lock);
+  }
+}
+
+int
+proc_kill(int pid)
+{
+  struct proc *p;
+
+  acquire(&proc_table_lock);
+  for(p = proc; p < &proc[NPROC]; p++){
+    if(p->pid == pid && p->state != UNUSED){
+      p->killed = 1;
+      if(p->state == WAITING)
+        p->state = RUNNABLE;
+      release(&proc_table_lock);
+      return 0;
+    }
+  }
+  release(&proc_table_lock);
+  return -1;
+}
+
 // disable interrupts
 void
 cli(void)

--- a/syscall.c
+++ b/syscall.c
@@ -162,38 +162,22 @@ int
 sys_exit(void)
 {
  proc_exit();
-  return 0;
+  return 0;  // not reached
 }

 int
 sys_wait(void)
 {
-  struct proc *p;
-  struct proc *cp = curproc[cpu()];
-  int any, pid;
+  return proc_wait();
+}

-  acquire(&proc_table_lock);
+int
+sys_kill(void)
+{
+  int pid;

-  while(1){
-    any = 0;
-    for(p = proc; p < &proc[NPROC]; p++){
-      if(p->state == ZOMBIE && p->ppid == cp->pid){
-        kfree(p->mem, p->sz);
-        kfree(p->kstack, KSTACKSIZE);
-        pid = p->pid;
-        p->state = UNUSED;
-        release(&proc_table_lock);
-        return pid;
-      }
-      if(p->state != UNUSED && p->ppid == cp->pid)
-        any = 1;
-    }
-    if(any == 0){
-      release(&proc_table_lock);
-      return -1;
-    }
-    sleep(cp, &proc_table_lock);
-  }
+  fetcharg(0, &pid);
+  return proc_kill(pid);
 }

 int
@@ -232,27 +216,6 @@ sys_block(void)
 }

 int
-sys_kill(void)
-{
-  int pid;
-  struct proc *p;
-
-  fetcharg(0, &pid);
-  acquire(&proc_table_lock);
-  for(p = proc; p < &proc[NPROC]; p++){
-    if(p->pid == pid && p->state != UNUSED){
-      p->killed = 1;
-      if(p->state == WAITING)
-        p->state = RUNNABLE;
-      release(&proc_table_lock);
-      return 0;
-    }
-  }
-  release(&proc_table_lock);
-  return -1;
-}
-
-int
 sys_panic(void)
 {
  struct proc *p = curproc[cpu()];