root/proc.c

DEFINITIONS

1. pinit
2. allocproc
3. userinit
4. growproc
5. fork
6. exit
7. wait
8. scheduler
9. sched
10. yield
11. forkret
12. sleep
13. wakeup1
14. wakeup
15. kill
16. procdump

   1 #include "types.h"
   2 #include "defs.h"
   3 #include "param.h"
   4 #include "memlayout.h"
   5 #include "mmu.h"
   6 #include "x86.h"
   7 #include "proc.h"
   8 #include "spinlock.h"
  10 struct {
  11   struct spinlock lock;
  12   struct proc proc[NPROC];
  13 } ptable;
  15 static struct proc *initproc;
  17 int nextpid = 1;
  18 extern void forkret(void);
  19 extern void trapret(void);
  21 static void wakeup1(void *chan);
  23 void
pinit(void)
  25 {
initlock(&ptable.lock, "ptable");
  27 }
  29 //PAGEBREAK: 32
  30 // Look in the process table for an UNUSED proc.
  31 // If found, change state to EMBRYO and initialize
  32 // state required to run in the kernel.
  33 // Otherwise return 0.
  34 static struct proc*
allocproc(void)
  36 {
  37   struct proc *p;
  38   char *sp;
acquire(&ptable.lock);
  41   for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
  42     if(p->state == UNUSED)
  43       goto found;
release(&ptable.lock);
  45   return 0;
found:
p->state = EMBRYO;
p->pid = nextpid++;
release(&ptable.lock);
  52   // Allocate kernel stack.
  53   if((p->kstack = kalloc()) == 0){
p->state = UNUSED;
  55     return 0;
  56   }
sp = p->kstack + KSTACKSIZE;
  59   // Leave room for trap frame.
sp -= sizeof *p->tf;
p->tf = (struct trapframe*)sp;
  63   // Set up new context to start executing at forkret,
  64   // which returns to trapret.
sp -= 4;
  66   *(uint*)sp = (uint)trapret;
sp -= sizeof *p->context;
p->context = (struct context*)sp;
memset(p->context, 0, sizeof *p->context);
p->context->eip = (uint)forkret;
  73   return p;
  74 }
  76 //PAGEBREAK: 32
  77 // Set up first user process.
  78 void
userinit(void)
  80 {
  81   struct proc *p;
  82   extern char _binary_initcode_start[], _binary_initcode_size[];
p = allocproc();
initproc = p;
  86   if((p->pgdir = setupkvm()) == 0)
panic("userinit: out of memory?");
inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size);
p->sz = PGSIZE;
memset(p->tf, 0, sizeof(*p->tf));
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
p->tf->es = p->tf->ds;
p->tf->ss = p->tf->ds;
p->tf->eflags = FL_IF;
p->tf->esp = PGSIZE;
p->tf->eip = 0;  // beginning of initcode.S
safestrcpy(p->name, "initcode", sizeof(p->name));
p->cwd = namei("/");
p->state = RUNNABLE;
 103 }
 105 // Grow current process's memory by n bytes.
 106 // Return 0 on success, -1 on failure.
 107 int
growproc(int n)
 109 {
uint sz;
sz = proc->sz;
 113   if(n > 0){
 114     if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)
 115       return -1;
 116   } else if(n < 0){
 117     if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)
 118       return -1;
 119   }
proc->sz = sz;
switchuvm(proc);
 122   return 0;
 123 }
 125 // Create a new process copying p as the parent.
 126 // Sets up stack to return as if from system call.
 127 // Caller must set state of returned proc to RUNNABLE.
 128 int
fork(void)
 130 {
 131   int i, pid;
 132   struct proc *np;
 134   // Allocate process.
 135   if((np = allocproc()) == 0)
 136     return -1;
 138   // Copy process state from p.
 139   if((np->pgdir = copyuvm(proc->pgdir, proc->sz)) == 0){
kfree(np->kstack);
np->kstack = 0;
np->state = UNUSED;
 143     return -1;
 144   }
np->sz = proc->sz;
np->parent = proc;
 147   *np->tf = *proc->tf;
 149   // Clear %eax so that fork returns 0 in the child.
np->tf->eax = 0;
 152   for(i = 0; i < NOFILE; i++)
 153     if(proc->ofile[i])
np->ofile[i] = filedup(proc->ofile[i]);
np->cwd = idup(proc->cwd);
safestrcpy(np->name, proc->name, sizeof(proc->name));
pid = np->pid;
 161   // lock to force the compiler to emit the np->state write last.
acquire(&ptable.lock);
np->state = RUNNABLE;
release(&ptable.lock);
 166   return pid;
 167 }
 169 // Exit the current process.  Does not return.
 170 // An exited process remains in the zombie state
 171 // until its parent calls wait() to find out it exited.
 172 void
exit(void)
 174 {
 175   struct proc *p;
 176   int fd;
 178   if(proc == initproc)
panic("init exiting");
 181   // Close all open files.
 182   for(fd = 0; fd < NOFILE; fd++){
 183     if(proc->ofile[fd]){
fileclose(proc->ofile[fd]);
proc->ofile[fd] = 0;
 186     }
 187   }
begin_op();
iput(proc->cwd);
end_op();
proc->cwd = 0;
acquire(&ptable.lock);
 196   // Parent might be sleeping in wait().
wakeup1(proc->parent);
 199   // Pass abandoned children to init.
 200   for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
 201     if(p->parent == proc){
p->parent = initproc;
 203       if(p->state == ZOMBIE)
wakeup1(initproc);
 205     }
 206   }
 208   // Jump into the scheduler, never to return.
proc->state = ZOMBIE;
sched();
panic("zombie exit");
 212 }
 214 // Wait for a child process to exit and return its pid.
 215 // Return -1 if this process has no children.
 216 int
wait(void)
 218 {
 219   struct proc *p;
 220   int havekids, pid;
acquire(&ptable.lock);
 223   for(;;){
 224     // Scan through table looking for zombie children.
havekids = 0;
 226     for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
 227       if(p->parent != proc)
 228         continue;
havekids = 1;
 230       if(p->state == ZOMBIE){
 231         // Found one.
pid = p->pid;
kfree(p->kstack);
p->kstack = 0;
freevm(p->pgdir);
p->state = UNUSED;
p->pid = 0;
p->parent = 0;
p->name[0] = 0;
p->killed = 0;
release(&ptable.lock);
 242         return pid;
 243       }
 244     }
 246     // No point waiting if we don't have any children.
 247     if(!havekids || proc->killed){
release(&ptable.lock);
 249       return -1;
 250     }
 252     // Wait for children to exit.  (See wakeup1 call in proc_exit.)
sleep(proc, &ptable.lock);  //DOC: wait-sleep
 254   }
 255 }
 257 //PAGEBREAK: 42
 258 // Per-CPU process scheduler.
 259 // Each CPU calls scheduler() after setting itself up.
 260 // Scheduler never returns.  It loops, doing:
 261 //  - choose a process to run
 262 //  - swtch to start running that process
 263 //  - eventually that process transfers control
 264 //      via swtch back to the scheduler.
 265 void
scheduler(void)
 267 {
 268   struct proc *p;
 270   for(;;){
 271     // Enable interrupts on this processor.
sti();
 274     // Loop over process table looking for process to run.
acquire(&ptable.lock);
 276     for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
 277       if(p->state != RUNNABLE)
 278         continue;
 280       // Switch to chosen process.  It is the process's job
 281       // to release ptable.lock and then reacquire it
 282       // before jumping back to us.
proc = p;
switchuvm(p);
p->state = RUNNING;
swtch(&cpu->scheduler, proc->context);
switchkvm();
 289       // Process is done running for now.
 290       // It should have changed its p->state before coming back.
proc = 0;
 292     }
release(&ptable.lock);
 295   }
 296 }
 298 // Enter scheduler.  Must hold only ptable.lock
 299 // and have changed proc->state.
 300 void
sched(void)
 302 {
 303   int intena;
 305   if(!holding(&ptable.lock))
panic("sched ptable.lock");
 307   if(cpu->ncli != 1)
panic("sched locks");
 309   if(proc->state == RUNNING)
panic("sched running");
 311   if(readeflags()&FL_IF)
panic("sched interruptible");
intena = cpu->intena;
swtch(&proc->context, cpu->scheduler);
cpu->intena = intena;
 316 }
 318 // Give up the CPU for one scheduling round.
 319 void
yield(void)
 321 {
acquire(&ptable.lock);  //DOC: yieldlock
proc->state = RUNNABLE;
sched();
release(&ptable.lock);
 326 }
 328 // A fork child's very first scheduling by scheduler()
 329 // will swtch here.  "Return" to user space.
 330 void
forkret(void)
 332 {
 333   static int first = 1;
 334   // Still holding ptable.lock from scheduler.
release(&ptable.lock);
 337   if (first) {
 338     // Some initialization functions must be run in the context
 339     // of a regular process (e.g., they call sleep), and thus cannot 
 340     // be run from main().
first = 0;
iinit(ROOTDEV);
initlog(ROOTDEV);
 344   }
 346   // Return to "caller", actually trapret (see allocproc).
 347 }
 349 // Atomically release lock and sleep on chan.
 350 // Reacquires lock when awakened.
 351 void
sleep(void *chan, struct spinlock *lk)
 353 {
 354   if(proc == 0)
panic("sleep");
 357   if(lk == 0)
panic("sleep without lk");
 360   // Must acquire ptable.lock in order to
 361   // change p->state and then call sched.
 362   // Once we hold ptable.lock, we can be
 363   // guaranteed that we won't miss any wakeup
 364   // (wakeup runs with ptable.lock locked),
 365   // so it's okay to release lk.
 366   if(lk != &ptable.lock){  //DOC: sleeplock0
acquire(&ptable.lock);  //DOC: sleeplock1
release(lk);
 369   }
 371   // Go to sleep.
proc->chan = chan;
proc->state = SLEEPING;
sched();
 376   // Tidy up.
proc->chan = 0;
 379   // Reacquire original lock.
 380   if(lk != &ptable.lock){  //DOC: sleeplock2
release(&ptable.lock);
acquire(lk);
 383   }
 384 }
 386 //PAGEBREAK!
 387 // Wake up all processes sleeping on chan.
 388 // The ptable lock must be held.
 389 static void
wakeup1(void *chan)
 391 {
 392   struct proc *p;
 394   for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
 395     if(p->state == SLEEPING && p->chan == chan)
p->state = RUNNABLE;
 397 }
 399 // Wake up all processes sleeping on chan.
 400 void
wakeup(void *chan)
 402 {
acquire(&ptable.lock);
wakeup1(chan);
release(&ptable.lock);
 406 }
 408 // Kill the process with the given pid.
 409 // Process won't exit until it returns
 410 // to user space (see trap in trap.c).
 411 int
kill(int pid)
 413 {
 414   struct proc *p;
acquire(&ptable.lock);
 417   for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
 418     if(p->pid == pid){
p->killed = 1;
 420       // Wake process from sleep if necessary.
 421       if(p->state == SLEEPING)
p->state = RUNNABLE;
release(&ptable.lock);
 424       return 0;
 425     }
 426   }
release(&ptable.lock);
 428   return -1;
 429 }
 431 //PAGEBREAK: 36
 432 // Print a process listing to console.  For debugging.
 433 // Runs when user types ^P on console.
 434 // No lock to avoid wedging a stuck machine further.
 435 void
procdump(void)
 437 {
 438   static char *states[] = {
 439   [UNUSED]    "unused",
 440   [EMBRYO]    "embryo",
 441   [SLEEPING]  "sleep ",
 442   [RUNNABLE]  "runble",
 443   [RUNNING]   "run   ",
 444   [ZOMBIE]    "zombie"
 445   };
 446   int i;
 447   struct proc *p;
 448   char *state;
uint pc[10];
 451   for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
 452     if(p->state == UNUSED)
 453       continue;
 454     if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
state = states[p->state];
 456     else
state = "???";
cprintf("%d %s %s", p->pid, state, p->name);
 459     if(p->state == SLEEPING){
getcallerpcs((uint*)p->context->ebp+2, pc);
 461       for(i=0; i<10 && pc[i] != 0; i++)
cprintf(" %p", pc[i]);
 463     }
cprintf("\n");
 465   }
 466 }