summaryrefslogtreecommitdiff
path: root/proc.c
diff options
context:
space:
mode:
authorFrans Kaashoek <[email protected]>2017-01-31 20:21:14 -0500
committerFrans Kaashoek <[email protected]>2017-01-31 20:21:14 -0500
commitfbb4c0944422f860484142010bb9f366f3e87bf8 (patch)
tree5e339842d43d09a4d23f1a2165391f00af30e308 /proc.c
parentabf847a083888bbed4260ecacf849ea19f23e810 (diff)
downloadxv6-labs-fbb4c0944422f860484142010bb9f366f3e87bf8.tar.gz
xv6-labs-fbb4c0944422f860484142010bb9f366f3e87bf8.tar.bz2
xv6-labs-fbb4c0944422f860484142010bb9f366f3e87bf8.zip
Read curproc from cpu structure, but be careful because after a schedule event
myproc() points to a different thread. myproc(); sched(); myproc(); // this proc maybe different than the one before sched Thus, in a function that operates on one thread better to retrieve the current process once at the start of the function.
Diffstat (limited to 'proc.c')
-rw-r--r--proc.c101
1 files changed, 63 insertions, 38 deletions
diff --git a/proc.c b/proc.c
index bd62e4b..4e8f461 100644
--- a/proc.c
+++ b/proc.c
@@ -26,14 +26,23 @@ pinit(void)
initlock(&ptable.lock, "ptable");
}
+// XXX get rid off?
int
cpuid() {
return mycpu()-cpus;
}
-void
-setproc(struct proc* p) {
- mycpu()->proc = p;
+// Disable interrupts so that we are not rescheduled
+// while reading proc from the cpu structure
+struct proc*
+myproc(void) {
+ struct cpu *c;
+ struct proc *p;
+ pushcli();
+ c = mycpu();
+ p = c->proc;
+ popcli();
+ return p;
}
//PAGEBREAK: 32
@@ -130,17 +139,18 @@ int
growproc(int n)
{
uint sz;
+ struct proc *curproc = myproc();
- sz = myproc()->sz;
+ sz = curproc->sz;
if(n > 0){
- if((sz = allocuvm(myproc()->pgdir, sz, sz + n)) == 0)
+ if((sz = allocuvm(curproc->pgdir, sz, sz + n)) == 0)
return -1;
} else if(n < 0){
- if((sz = deallocuvm(myproc()->pgdir, sz, sz + n)) == 0)
+ if((sz = deallocuvm(curproc->pgdir, sz, sz + n)) == 0)
return -1;
}
- myproc()->sz = sz;
- switchuvm(myproc());
+ curproc->sz = sz;
+ switchuvm(curproc);
return 0;
}
@@ -152,6 +162,7 @@ fork(void)
{
int i, pid;
struct proc *np;
+ struct proc *curproc = myproc();
// Allocate process.
if((np = allocproc()) == 0){
@@ -159,25 +170,25 @@ fork(void)
}
// Copy process state from proc.
- if((np->pgdir = copyuvm(myproc()->pgdir, myproc()->sz)) == 0){
+ if((np->pgdir = copyuvm(curproc->pgdir, curproc->sz)) == 0){
kfree(np->kstack);
np->kstack = 0;
np->state = UNUSED;
return -1;
}
- np->sz = myproc()->sz;
- np->parent = myproc();
- *np->tf = *myproc()->tf;
+ np->sz = curproc->sz;
+ np->parent = curproc;
+ *np->tf = *curproc->tf;
// Clear %eax so that fork returns 0 in the child.
np->tf->eax = 0;
for(i = 0; i < NOFILE; i++)
- if(myproc()->ofile[i])
- np->ofile[i] = filedup(myproc()->ofile[i]);
- np->cwd = idup(myproc()->cwd);
+ if(curproc->ofile[i])
+ np->ofile[i] = filedup(curproc->ofile[i]);
+ np->cwd = idup(curproc->cwd);
- safestrcpy(np->name, myproc()->name, sizeof(myproc()->name));
+ safestrcpy(np->name, curproc->name, sizeof(curproc->name));
pid = np->pid;
@@ -196,33 +207,34 @@ fork(void)
void
exit(void)
{
+ struct proc *curproc = myproc();
struct proc *p;
int fd;
- if(myproc() == initproc)
+ if(curproc == initproc)
panic("init exiting");
// Close all open files.
for(fd = 0; fd < NOFILE; fd++){
- if(myproc()->ofile[fd]){
- fileclose(myproc()->ofile[fd]);
- myproc()->ofile[fd] = 0;
+ if(curproc->ofile[fd]){
+ fileclose(curproc->ofile[fd]);
+ curproc->ofile[fd] = 0;
}
}
begin_op();
- iput(myproc()->cwd);
+ iput(curproc->cwd);
end_op();
- myproc()->cwd = 0;
+ curproc->cwd = 0;
acquire(&ptable.lock);
// Parent might be sleeping in wait().
- wakeup1(myproc()->parent);
+ wakeup1(curproc->parent);
// Pass abandoned children to init.
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
- if(p->parent == myproc()){
+ if(p->parent == curproc){
p->parent = initproc;
if(p->state == ZOMBIE)
wakeup1(initproc);
@@ -230,7 +242,7 @@ exit(void)
}
// Jump into the scheduler, never to return.
- myproc()->state = ZOMBIE;
+ curproc->state = ZOMBIE;
sched();
panic("zombie exit");
}
@@ -242,13 +254,14 @@ wait(void)
{
struct proc *p;
int havekids, pid;
-
+ struct proc *curproc = myproc();
+
acquire(&ptable.lock);
for(;;){
// Scan through table looking for exited children.
havekids = 0;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
- if(p->parent != myproc())
+ if(p->parent != curproc)
continue;
havekids = 1;
if(p->state == ZOMBIE){
@@ -268,13 +281,13 @@ wait(void)
}
// No point waiting if we don't have any children.
- if(!havekids || myproc()->killed){
+ if(!havekids || curproc->killed){
release(&ptable.lock);
return -1;
}
// Wait for children to exit. (See wakeup1 call in proc_exit.)
- sleep(myproc(), &ptable.lock); //DOC: wait-sleep
+ sleep(curproc, &ptable.lock); //DOC: wait-sleep
}
}
@@ -290,6 +303,7 @@ void
scheduler(void)
{
struct proc *p;
+ struct cpu *c = mycpu();
for(;;){
// Enable interrupts on this processor.
@@ -304,15 +318,18 @@ scheduler(void)
// Switch to chosen process. It is the process's job
// to release ptable.lock and then reacquire it
// before jumping back to us.
- setproc(p);
+ c->proc = p;
switchuvm(p);
p->state = RUNNING;
- swtch(&(mycpu()->scheduler), p->context);
+ p->cpu = c;
+ // cprintf("%d: switch to %d\n", c-cpus, p->pid);
+ swtch(&(p->cpu->scheduler), p->context);
switchkvm();
// Process is done running for now.
// It should have changed its p->state before coming back.
- setproc(0);
+ c->proc = 0;
+ p->cpu = 0;
}
release(&ptable.lock);
@@ -330,17 +347,20 @@ void
sched(void)
{
int intena;
+ struct proc *p = myproc();
if(!holding(&ptable.lock))
panic("sched ptable.lock");
if(mycpu()->ncli != 1)
panic("sched locks");
- if(myproc()->state == RUNNING)
+ if(p->state == RUNNING)
panic("sched running");
if(readeflags()&FL_IF)
panic("sched interruptible");
intena = mycpu()->intena;
- swtch(&myproc()->context, mycpu()->scheduler);
+ // cprintf("%d: before swtch %d %x\n", p->cpu-cpus, p->pid, * (int *) 0x1d);
+ swtch(&p->context, p->cpu->scheduler);
+ // cprintf("%d/%d: after swtch %d %x\n", cpuid(), p->cpu-cpus, p->pid, * (int *) 0x1d);
mycpu()->intena = intena;
}
@@ -380,7 +400,9 @@ forkret(void)
void
sleep(void *chan, struct spinlock *lk)
{
- if(myproc() == 0)
+ struct proc *p = myproc();
+
+ if(p == 0)
panic("sleep");
if(lk == 0)
@@ -397,12 +419,15 @@ sleep(void *chan, struct spinlock *lk)
release(lk);
}
// Go to sleep.
- myproc()->chan = chan;
- myproc()->state = SLEEPING;
+ p->chan = chan;
+ p->state = SLEEPING;
+
+ // cprintf("sleep %d\n", p->pid);
+
sched();
// Tidy up.
- myproc()->chan = 0;
+ p->chan = 0;
// Reacquire original lock.
if(lk != &ptable.lock){ //DOC: sleeplock2