xv6/proc.c

151 lines
3.5 KiB
C
Raw Normal View History

2006-06-12 15:22:12 +00:00
#include "types.h"
#include "mmu.h"
#include "x86.h"
#include "proc.h"
#include "param.h"
#include "defs.h"
struct proc proc[NPROC];
2006-06-15 16:02:20 +00:00
struct proc *curproc;
2006-06-15 19:58:01 +00:00
int next_pid = 1;
2006-06-12 15:22:12 +00:00
/*
* set up a process's task state and segment descriptors
* correctly, given its current size and address in memory.
* this should be called whenever the latter change.
* doesn't change the cpu's current segmentation setup.
*/
void
setupsegs(struct proc *p)
{
memset(&p->ts, 0, sizeof(struct Taskstate));
p->ts.ts_ss0 = SEG_KDATA << 3;
p->ts.ts_esp0 = (unsigned)(p->kstack + KSTACKSIZE);
2006-06-13 15:50:06 +00:00
// XXX it may be wrong to modify the current segment table!
2006-06-12 15:22:12 +00:00
p->gdt[0] = SEG_NULL;
p->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
p->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
2006-06-15 16:02:20 +00:00
p->gdt[SEG_TSS] = SEG16(STS_T32A, (unsigned) &p->ts,
sizeof(p->ts), 0);
2006-06-12 15:22:12 +00:00
p->gdt[SEG_TSS].sd_s = 0;
p->gdt[SEG_UCODE] = SEG(STA_X|STA_R, (unsigned)p->mem, p->sz, 3);
p->gdt[SEG_UDATA] = SEG(STA_W, (unsigned)p->mem, p->sz, 3);
p->gdt_pd.pd__garbage = 0;
p->gdt_pd.pd_lim = sizeof(p->gdt) - 1;
p->gdt_pd.pd_base = (unsigned) p->gdt;
}
extern void trapret();
/*
* internal fork(). does not copy kernel stack; instead,
* sets up the stack to return as if from system call.
*/
struct proc *
2006-06-15 16:02:20 +00:00
newproc()
2006-06-12 15:22:12 +00:00
{
struct proc *np;
unsigned *sp;
for(np = &proc[1]; np < &proc[NPROC]; np++)
if(np->state == UNUSED)
break;
if(np >= &proc[NPROC])
return 0;
2006-06-15 19:58:01 +00:00
np->pid = next_pid++;
np->ppid = curproc->pid;
2006-06-15 16:02:20 +00:00
np->sz = curproc->sz;
np->mem = kalloc(curproc->sz);
2006-06-12 15:22:12 +00:00
if(np->mem == 0)
return 0;
2006-06-15 16:02:20 +00:00
memcpy(np->mem, curproc->mem, np->sz);
2006-06-12 15:22:12 +00:00
np->kstack = kalloc(KSTACKSIZE);
if(np->kstack == 0){
2006-06-15 16:02:20 +00:00
kfree(np->mem, curproc->sz);
2006-06-12 15:22:12 +00:00
return 0;
}
setupsegs(np);
// set up kernel stack to return to user space
2006-06-15 16:02:20 +00:00
np->tf = (struct Trapframe *) (np->kstack + KSTACKSIZE - sizeof(struct Trapframe));
*(np->tf) = *(curproc->tf);
2006-06-12 15:22:12 +00:00
sp = (unsigned *) np->tf;
*(--sp) = (unsigned) &trapret; // for return from swtch()
*(--sp) = 0; // previous bp for leave in swtch()
np->esp = (unsigned) sp;
np->ebp = (unsigned) sp;
2006-06-15 16:02:20 +00:00
np->state = RUNNABLE;
cprintf("newproc %x\n", np);
2006-06-12 15:22:12 +00:00
return np;
}
/*
* find a runnable process and switch to it.
*/
void
2006-06-15 16:02:20 +00:00
swtch()
2006-06-12 15:22:12 +00:00
{
struct proc *np;
while(1){
2006-06-15 16:02:20 +00:00
for(np = curproc + 1; np != curproc; np++){
2006-06-12 15:22:12 +00:00
if(np == &proc[NPROC])
np = &proc[0];
if(np->state == RUNNABLE)
break;
}
if(np->state == RUNNABLE)
break;
// idle...
}
2006-06-15 16:02:20 +00:00
curproc->ebp = read_ebp();
curproc->esp = read_esp();
cprintf("swtch %x -> %x\n", curproc, np);
2006-06-12 15:22:12 +00:00
2006-06-15 16:02:20 +00:00
curproc = np;
2006-06-13 15:50:06 +00:00
2006-06-12 15:22:12 +00:00
// XXX callee-saved registers?
2006-06-15 19:58:01 +00:00
// h/w sets busy bit in TSS descriptor sometimes, and faults
// if it's set in LTR. so clear tss descriptor busy bit.
curproc->gdt[SEG_TSS].sd_type = STS_T32A;
// XXX probably ought to lgdt on trap return too, in case
// a system call has moved a program or changed its size.
2006-06-13 15:50:06 +00:00
asm volatile("lgdt %0" : : "g" (np->gdt_pd.pd_lim));
ltr(SEG_TSS << 3);
2006-06-12 15:22:12 +00:00
// this happens to work, but probably isn't safe:
2006-06-13 15:50:06 +00:00
// it's not clear that np->ebp is guaranteed to evaluate
2006-06-12 15:22:12 +00:00
// correctly after changing the stack pointer.
asm volatile("movl %0, %%esp" : : "g" (np->esp));
asm volatile("movl %0, %%ebp" : : "g" (np->ebp));
}
2006-06-15 19:58:01 +00:00
void
sleep(void *chan)
{
curproc->chan = chan;
curproc->state = WAITING;
swtch();
}
void
wakeup(void *chan)
{
struct proc *p;
for(p = proc; p < &proc[NPROC]; p++)
if(p->state == WAITING && p->chan == chan)
p->state = RUNNABLE;
}