diff --git a/defs.h b/defs.h
index fa9c502..89b28ac 100644
--- a/defs.h
+++ b/defs.h
@@ -98,10 +98,10 @@ int             pipewrite(struct pipe*, char*, int);
 struct proc*    copyproc(struct proc*);
 int             growproc(int);
 void            pinit(void);
-void            proc_exit(void);
-int             proc_kill(int);
-int             proc_wait(void);
 void            procdump(void);
+void            exit(void);
+int             kill(int);
+int             wait(void);
 void            scheduler(void) __attribute__((noreturn));
 void            setupsegs(struct proc*);
 void            sleep(void*, struct spinlock*);
diff --git a/proc.c b/proc.c
index a6d189b..6803982 100644
--- a/proc.c
+++ b/proc.c
@@ -318,7 +318,7 @@ wakeup(void *chan)
 // Process won't actually exit until it returns
 // to user space (see trap in trap.c).
 int
-proc_kill(int pid)
+kill(int pid)
 {
   struct proc *p;
 
@@ -341,7 +341,7 @@ proc_kill(int pid)
 // Exited processes remain in the zombie state
 // until their parent calls wait() to find out they exited.
 void
-proc_exit(void)
+exit(void)
 {
   struct proc *p;
   int fd;
@@ -384,7 +384,7 @@ proc_exit(void)
 // Wait for a child process to exit and return its pid.
 // Return -1 if this process has no children.
 int
-proc_wait(void)
+wait(void)
 {
   struct proc *p;
   int i, havekids, pid;
diff --git a/sysproc.c b/sysproc.c
index b769216..8d7d9cc 100644
--- a/sysproc.c
+++ b/sysproc.c
@@ -18,14 +18,14 @@ sys_fork(void)
 int
 sys_exit(void)
 {
-  proc_exit();
+  exit();
   return 0;  // not reached
 }
 
 int
 sys_wait(void)
 {
-  return proc_wait();
+  return wait();
 }
 
 int
@@ -35,7 +35,7 @@ sys_kill(void)
 
   if(argint(0, &pid) < 0)
     return -1;
-  return proc_kill(pid);
+  return kill(pid);
 }
 
 int
diff --git a/trap.c b/trap.c
index 3120994..ed286ed 100644
--- a/trap.c
+++ b/trap.c
@@ -36,11 +36,11 @@ trap(struct trapframe *tf)
 {
   if(tf->trapno == T_SYSCALL){
     if(cp->killed)
-      proc_exit();
+      exit();
     cp->tf = tf;
     syscall();
     if(cp->killed)
-      proc_exit();
+      exit();
     return;
   }
 
@@ -89,7 +89,7 @@ trap(struct trapframe *tf)
   // (If it is still executing in the kernel, let it keep running 
   // until it gets to the regular system call return.)
   if(cp && cp->killed && (tf->cs&3) == DPL_USER)
-    proc_exit();
+    exit();
 
   // Force process to give up CPU on clock tick.
   // If interrupts were on while locks held, would need to check nlock.