summaryrefslogtreecommitdiff
path: root/kernel/proc.c
diff options
context:
space:
mode:
Diffstat (limited to 'kernel/proc.c')
-rw-r--r--kernel/proc.c250
1 files changed, 143 insertions, 107 deletions
diff --git a/kernel/proc.c b/kernel/proc.c
index 20d5085..a947f7f 100644
--- a/kernel/proc.c
+++ b/kernel/proc.c
@@ -2,33 +2,36 @@
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
-#include "proc.h"
#include "spinlock.h"
+#include "proc.h"
#include "defs.h"
-struct {
- struct spinlock lock;
- struct proc proc[NPROC];
-} ptable;
+struct proc proc[NPROC];
struct cpu cpus[NCPU];
struct proc *initproc;
+struct spinlock pid_lock;
int nextpid = 1;
+
extern void forkret(void);
// for returning out of the kernel
extern void sysexit(void);
-static void wakeup1(void *chan);
+static void wakeup1(struct proc *chan);
extern char trampout[]; // trampoline.S
void
procinit(void)
{
- initlock(&ptable.lock, "ptable");
+ struct proc *p;
+
+ initlock(&pid_lock, "nextpid");
+ for(p = proc; p < &proc[NPROC]; p++)
+ initlock(&p->lock, "proc");
}
// Must be called with interrupts disabled,
@@ -60,40 +63,48 @@ myproc(void) {
return p;
}
+int
+allocpid() {
+ int pid;
+
+ acquire(&pid_lock);
+ pid = nextpid++;
+ release(&pid_lock);
+ return pid;
+}
+
//PAGEBREAK: 32
// Look in the process table for an UNUSED proc.
-// If found, change state to EMBRYO and initialize
-// state required to run in the kernel.
+// If found, initialize state required to run in the kernel,
+// and return with p->lock held.
// Otherwise return 0.
static struct proc*
allocproc(void)
{
struct proc *p;
- acquire(&ptable.lock);
-
- for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
- if(p->state == UNUSED)
+ for(p = proc; p < &proc[NPROC]; p++) {
+ acquire(&p->lock);
+ if(p->state == UNUSED) {
goto found;
-
- release(&ptable.lock);
+ } else {
+ release(&p->lock);
+ }
+ }
return 0;
found:
- p->state = EMBRYO;
- p->pid = nextpid++;
-
- release(&ptable.lock);
+ p->pid = allocpid();
// Allocate a page for the kernel stack.
if((p->kstack = kalloc()) == 0){
- p->state = UNUSED;
return 0;
}
// Allocate a trapframe page.
if((p->tf = (struct trapframe *)kalloc()) == 0){
- p->state = UNUSED;
+ kfree(p->kstack);
+ p->kstack = 0;
return 0;
}
@@ -111,7 +122,7 @@ found:
// free a proc structure and the data hanging from it,
// including user pages.
-// the proc lock must be held.
+// p->lock must be held.
static void
freeproc(struct proc *p)
{
@@ -195,22 +206,16 @@ userinit(void)
uvminit(p->pagetable, initcode, sizeof(initcode));
p->sz = PGSIZE;
- // prepare for the very first kernel->user.
+ // prepare for the very first "return" from kernel to user.
p->tf->epc = 0;
p->tf->sp = PGSIZE;
safestrcpy(p->name, "initcode", sizeof(p->name));
p->cwd = namei("/");
- // this assignment to p->state lets other cores
- // run this process. the acquire forces the above
- // writes to be visible, and the lock is also needed
- // because the assignment might not be atomic.
- acquire(&ptable.lock);
-
p->state = RUNNABLE;
- release(&ptable.lock);
+ release(&p->lock);
}
// Grow current process's memory by n bytes.
@@ -223,11 +228,13 @@ growproc(int n)
sz = p->sz;
if(n > 0){
- if((sz = uvmalloc(p->pagetable, sz, sz + n)) == 0)
+ if((sz = uvmalloc(p->pagetable, sz, sz + n)) == 0) {
return -1;
+ }
} else if(n < 0){
- if((sz = uvmdealloc(p->pagetable, sz, sz + n)) == 0)
+ if((sz = uvmdealloc(p->pagetable, sz, sz + n)) == 0) {
return -1;
+ }
}
p->sz = sz;
return 0;
@@ -250,6 +257,7 @@ fork(void)
// Copy user memory from parent to child.
if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
freeproc(np);
+ release(&np->lock);
return -1;
}
np->sz = p->sz;
@@ -272,15 +280,39 @@ fork(void)
pid = np->pid;
- acquire(&ptable.lock);
-
np->state = RUNNABLE;
- release(&ptable.lock);
+ release(&np->lock);
return pid;
}
+// Pass p's abandoned children to init. p and p's parent
+// are locked.
+void
+reparent(struct proc *p, struct proc *parent) {
+ struct proc *pp;
+ int child_of_init = (p->parent == initproc);
+
+ for(pp = proc; pp < &proc[NPROC]; pp++){
+ if (pp != p && pp != parent) {
+ acquire(&pp->lock);
+ if(pp->parent == p){
+ pp->parent = initproc;
+ if(pp->state == ZOMBIE) {
+ if(!child_of_init)
+ acquire(&initproc->lock);
+ wakeup1(initproc);
+ if(!child_of_init)
+ release(&initproc->lock);
+ }
+ }
+ release(&pp->lock);
+ }
+ }
+}
+
+
// Exit the current process. Does not return.
// An exited process remains in the zombie state
// until its parent calls wait().
@@ -288,7 +320,6 @@ void
exit(void)
{
struct proc *p = myproc();
- struct proc *pp;
int fd;
if(p == initproc)
@@ -297,7 +328,8 @@ exit(void)
// Close all open files.
for(fd = 0; fd < NOFILE; fd++){
if(p->ofile[fd]){
- fileclose(p->ofile[fd]);
+ struct file *f = p->ofile[fd];
+ fileclose(f);
p->ofile[fd] = 0;
}
}
@@ -307,22 +339,20 @@ exit(void)
end_op();
p->cwd = 0;
- acquire(&ptable.lock);
+ acquire(&p->parent->lock);
+
+ acquire(&p->lock);
+
+ reparent(p, p->parent);
+
+ p->state = ZOMBIE;
// Parent might be sleeping in wait().
wakeup1(p->parent);
- // Pass abandoned children to init.
- for(pp = ptable.proc; pp < &ptable.proc[NPROC]; pp++){
- if(pp->parent == p){
- pp->parent = initproc;
- if(pp->state == ZOMBIE)
- wakeup1(initproc);
- }
- }
+ release(&p->parent->lock);
// Jump into the scheduler, never to return.
- p->state = ZOMBIE;
sched();
panic("zombie exit");
}
@@ -335,32 +365,35 @@ wait(void)
struct proc *np;
int havekids, pid;
struct proc *p = myproc();
-
- acquire(&ptable.lock);
+
+ acquire(&p->lock);
for(;;){
// Scan through table looking for exited children.
havekids = 0;
- for(np = ptable.proc; np < &ptable.proc[NPROC]; np++){
+ for(np = proc; np < &proc[NPROC]; np++){
if(np->parent != p)
continue;
+ acquire(&np->lock);
havekids = 1;
if(np->state == ZOMBIE){
// Found one.
pid = np->pid;
freeproc(np);
- release(&ptable.lock);
+ release(&np->lock);
+ release(&p->lock);
return pid;
}
+ release(&np->lock);
}
// No point waiting if we don't have any children.
if(!havekids || p->killed){
- release(&ptable.lock);
+ release(&p->lock);
return -1;
}
-
- // Wait for children to exit. (See wakeup1 call in proc_exit.)
- sleep(p, &ptable.lock); //DOC: wait-sleep
+
+ // Wait for children to exit. (See wakeup1 call in reparent.)
+ sleep(p, &p->lock); //DOC: wait-sleep
}
}
@@ -377,35 +410,32 @@ scheduler(void)
{
struct proc *p;
struct cpu *c = mycpu();
-
+
c->proc = 0;
for(;;){
// Enable interrupts on this processor.
intr_on();
- // Loop over process table looking for process to run.
- 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 ptable.lock and then reacquire it
- // before jumping back to us.
- c->proc = p;
- p->state = RUNNING;
-
- swtch(&c->scheduler, &p->context);
-
- // Process is done running for now.
- // It should have changed its p->state before coming back.
- c->proc = 0;
+ for(p = proc; p < &proc[NPROC]; p++) {
+ acquire(&p->lock);
+ if(p->state == RUNNABLE) {
+ // Switch to chosen process. It is the process's job
+ // to release its lock and then reacquire it
+ // before jumping back to us.
+ p->state = RUNNING;
+ c->proc = p;
+ swtch(&c->scheduler, &p->context);
+
+ // Process is done running for now.
+ // It should have changed its p->state before coming back.
+ c->proc = 0;
+ }
+ release(&p->lock);
}
- release(&ptable.lock);
}
}
-// Enter scheduler. Must hold only ptable.lock
+// Enter scheduler. Must hold only p->lock
// and have changed proc->state. Saves and restores
// intena because intena is a property of this
// kernel thread, not this CPU. It should
@@ -418,8 +448,8 @@ sched(void)
int intena;
struct proc *p = myproc();
- if(!holding(&ptable.lock))
- panic("sched ptable.lock");
+ if(!holding(&p->lock))
+ panic("sched p->lock");
if(mycpu()->noff != 1)
panic("sched locks");
if(p->state == RUNNING)
@@ -436,10 +466,11 @@ sched(void)
void
yield(void)
{
- acquire(&ptable.lock); //DOC: yieldlock
- myproc()->state = RUNNABLE;
+ struct proc *p = myproc();
+ acquire(&p->lock); //DOC: yieldlock
+ p->state = RUNNABLE;
sched();
- release(&ptable.lock);
+ release(&p->lock);
}
// A fork child's very first scheduling by scheduler()
@@ -449,8 +480,8 @@ forkret(void)
{
static int first = 1;
- // Still holding ptable.lock from scheduler.
- release(&ptable.lock);
+ // Still holding p->lock from scheduler.
+ release(&myproc()->lock);
if (first) {
// Some initialization functions must be run in the context
@@ -477,14 +508,14 @@ sleep(void *chan, struct spinlock *lk)
if(lk == 0)
panic("sleep without lk");
- // Must acquire ptable.lock in order to
+ // Must acquire p->lock in order to
// change p->state and then call sched.
- // Once we hold ptable.lock, we can be
+ // Once we hold p->lock, we can be
// guaranteed that we won't miss any wakeup
- // (wakeup runs with ptable.lock locked),
+ // (wakeup runs with p->lock locked),
// so it's okay to release lk.
- if(lk != &ptable.lock){ //DOC: sleeplock0
- acquire(&ptable.lock); //DOC: sleeplock1
+ if(lk != &p->lock){ //DOC: sleeplock0
+ acquire(&p->lock); //DOC: sleeplock1
release(lk);
}
// Go to sleep.
@@ -497,32 +528,37 @@ sleep(void *chan, struct spinlock *lk)
p->chan = 0;
// Reacquire original lock.
- if(lk != &ptable.lock){ //DOC: sleeplock2
- release(&ptable.lock);
+ if(lk != &p->lock){ //DOC: sleeplock2
+ release(&p->lock);
acquire(lk);
}
}
//PAGEBREAK!
-// Wake up all processes sleeping on chan.
-// The ptable lock must be held.
+// Wake up p, used by exit()
+// Caller should lock p.
static void
-wakeup1(void *chan)
+wakeup1(struct proc *p)
{
- struct proc *p;
-
- for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
- if(p->state == SLEEPING && p->chan == chan)
- p->state = RUNNABLE;
+ if(p->chan == p && p->state == SLEEPING) {
+ p->state = RUNNABLE;
+ }
}
-// Wake up all processes sleeping on chan.
+// Wake up all processes sleeping on chan. Never
+// called when holding a p->lock
void
wakeup(void *chan)
{
- acquire(&ptable.lock);
- wakeup1(chan);
- release(&ptable.lock);
+ struct proc *p;
+
+ for(p = proc; p < &proc[NPROC]; p++) {
+ acquire(&p->lock);
+ if(p->state == SLEEPING && p->chan == chan) {
+ p->state = RUNNABLE;
+ }
+ release(&p->lock);
+ }
}
// Kill the process with the given pid.
@@ -533,18 +569,19 @@ kill(int pid)
{
struct proc *p;
- acquire(&ptable.lock);
- for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
+ for(p = proc; p < &proc[NPROC]; p++){
if(p->pid == pid){
+ acquire(&p->lock);
+ if(p->pid != pid)
+ panic("kill");
p->killed = 1;
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
p->state = RUNNABLE;
- release(&ptable.lock);
+ release(&p->lock);
return 0;
}
}
- release(&ptable.lock);
return -1;
}
@@ -586,7 +623,6 @@ procdump(void)
{
static char *states[] = {
[UNUSED] "unused",
- [EMBRYO] "embryo",
[SLEEPING] "sleep ",
[RUNNABLE] "runble",
[RUNNING] "run ",
@@ -595,7 +631,7 @@ procdump(void)
struct proc *p;
char *state;
- for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
+ for(p = proc; p < &proc[NPROC]; p++){
if(p->state == UNUSED)
continue;
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
Powered by cgit, Theme cgit-dark created by Ted Yin, updated by Mole Shang.