2006-06-12 17:22:12 +02:00
|
|
|
#include "types.h"
|
|
|
|
#include "mmu.h"
|
|
|
|
#include "x86.h"
|
|
|
|
#include "param.h"
|
2006-09-06 20:40:28 +02:00
|
|
|
#include "file.h"
|
2006-06-22 22:47:23 +02:00
|
|
|
#include "proc.h"
|
2006-06-12 17:22:12 +02:00
|
|
|
#include "defs.h"
|
2006-07-12 03:48:35 +02:00
|
|
|
#include "spinlock.h"
|
|
|
|
|
2006-08-11 00:08:14 +02:00
|
|
|
struct spinlock proc_table_lock;
|
2006-06-12 17:22:12 +02:00
|
|
|
|
|
|
|
struct proc proc[NPROC];
|
2006-06-22 22:47:23 +02:00
|
|
|
struct proc *curproc[NCPU];
|
2006-08-16 00:18:20 +02:00
|
|
|
int next_pid = 1;
|
2006-07-16 03:15:28 +02:00
|
|
|
extern void forkret(void);
|
2006-07-17 03:58:13 +02:00
|
|
|
extern void forkret1(struct trapframe*);
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2006-08-11 00:08:14 +02:00
|
|
|
void
|
|
|
|
pinit(void)
|
|
|
|
{
|
|
|
|
initlock(&proc_table_lock, "proc_table");
|
|
|
|
}
|
|
|
|
|
2006-09-06 19:50:20 +02:00
|
|
|
// Set up CPU's segment descriptors and task state for a
|
|
|
|
// given process.
|
|
|
|
// If p==0, set up for "idle" state for when scheduler()
|
|
|
|
// is idling, not running any process.
|
2006-06-12 17:22:12 +02:00
|
|
|
void
|
|
|
|
setupsegs(struct proc *p)
|
|
|
|
{
|
2006-08-16 00:18:20 +02:00
|
|
|
struct cpu *c = &cpus[cpu()];
|
|
|
|
|
|
|
|
c->ts.ss0 = SEG_KDATA << 3;
|
|
|
|
if(p){
|
|
|
|
c->ts.esp0 = (uint)(p->kstack + KSTACKSIZE);
|
|
|
|
} else {
|
|
|
|
c->ts.esp0 = 0xffffffff;
|
|
|
|
}
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2006-08-16 00:18:20 +02:00
|
|
|
c->gdt[0] = SEG_NULL;
|
2007-08-14 06:55:45 +02:00
|
|
|
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0x100000 + 64*1024-1, 0);
|
2006-08-16 00:18:20 +02:00
|
|
|
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
|
2007-08-14 06:55:45 +02:00
|
|
|
c->gdt[SEG_TSS] = SEG16(STS_T32A, (uint)&c->ts, sizeof(c->ts)-1, 0);
|
2006-08-16 00:18:20 +02:00
|
|
|
c->gdt[SEG_TSS].s = 0;
|
|
|
|
if(p){
|
2007-08-14 06:55:45 +02:00
|
|
|
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, (uint)p->mem, p->sz-1, DPL_USER);
|
|
|
|
c->gdt[SEG_UDATA] = SEG(STA_W, (uint)p->mem, p->sz-1, DPL_USER);
|
2006-08-16 00:18:20 +02:00
|
|
|
} else {
|
|
|
|
c->gdt[SEG_UCODE] = SEG_NULL;
|
|
|
|
c->gdt[SEG_UDATA] = SEG_NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
lgdt(c->gdt, sizeof c->gdt);
|
|
|
|
ltr(SEG_TSS << 3);
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
|
|
|
|
2006-09-08 16:26:51 +02:00
|
|
|
// Grow current process's memory by n bytes.
|
|
|
|
// Return old size on success, -1 on failure.
|
|
|
|
int
|
|
|
|
growproc(int n)
|
|
|
|
{
|
|
|
|
char *newmem, *oldmem;
|
|
|
|
|
|
|
|
newmem = kalloc(cp->sz + n);
|
|
|
|
if(newmem == 0)
|
|
|
|
return 0xffffffff;
|
|
|
|
memmove(newmem, cp->mem, cp->sz);
|
|
|
|
memset(newmem + cp->sz, 0, n);
|
|
|
|
oldmem = cp->mem;
|
|
|
|
cp->mem = newmem;
|
|
|
|
kfree(oldmem, cp->sz);
|
|
|
|
cp->sz += n;
|
|
|
|
return cp->sz - n;
|
|
|
|
}
|
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
// Look in the process table for an UNUSED proc.
|
|
|
|
// If found, change state to EMBRYO and return it.
|
|
|
|
// Otherwise return 0.
|
|
|
|
struct proc*
|
|
|
|
allocproc(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct proc *p;
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
for(i = 0; i < NPROC; i++){
|
|
|
|
p = &proc[i];
|
|
|
|
if(p->state == UNUSED){
|
|
|
|
p->state = EMBRYO;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
// Create a new process copying p as the parent.
|
2006-09-06 19:27:19 +02:00
|
|
|
// Does not copy the kernel stack.
|
2006-07-16 03:47:40 +02:00
|
|
|
// Instead, sets up stack to return as if from system call.
|
|
|
|
// Caller must arrange for process to run (set state to RUNNABLE).
|
2006-09-06 19:27:19 +02:00
|
|
|
struct proc*
|
|
|
|
copyproc(struct proc *p)
|
2006-06-12 17:22:12 +02:00
|
|
|
{
|
2006-07-16 03:47:40 +02:00
|
|
|
int i;
|
2006-06-12 17:22:12 +02:00
|
|
|
struct proc *np;
|
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
// Allocate process.
|
2006-07-12 03:48:35 +02:00
|
|
|
acquire(&proc_table_lock);
|
2006-07-16 03:47:40 +02:00
|
|
|
if((np = allocproc()) == 0){
|
2006-07-12 03:48:35 +02:00
|
|
|
release(&proc_table_lock);
|
2006-06-12 17:22:12 +02:00
|
|
|
return 0;
|
2006-07-12 03:48:35 +02:00
|
|
|
}
|
2006-06-15 21:58:01 +02:00
|
|
|
np->pid = next_pid++;
|
2006-07-12 03:48:35 +02:00
|
|
|
release(&proc_table_lock);
|
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
// Allocate kernel stack.
|
2007-08-21 21:22:08 +02:00
|
|
|
if((np->kstack = kalloc(KSTACKSIZE)) == 0){
|
2006-07-12 03:48:35 +02:00
|
|
|
np->state = UNUSED;
|
2006-06-12 17:22:12 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2006-07-17 03:58:13 +02:00
|
|
|
np->tf = (struct trapframe*)(np->kstack + KSTACKSIZE) - 1;
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2007-08-21 21:22:08 +02:00
|
|
|
if(p){ // Copy process state from p.
|
|
|
|
np->ppid = p->pid;
|
|
|
|
memmove(np->tf, p->tf, sizeof *np->tf);
|
|
|
|
|
|
|
|
np->sz = p->sz;
|
|
|
|
if((np->mem = kalloc(np->sz)) == 0){
|
|
|
|
kfree(np->kstack, KSTACKSIZE);
|
|
|
|
np->kstack = 0;
|
|
|
|
np->state = UNUSED;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
memmove(np->mem, p->mem, np->sz);
|
|
|
|
|
|
|
|
for(i = 0; i < NOFILE; i++){
|
|
|
|
np->ofile[i] = p->ofile[i];
|
|
|
|
if(np->ofile[i])
|
|
|
|
fileincref(np->ofile[i]);
|
|
|
|
}
|
|
|
|
np->cwd = iincref(p->cwd);
|
|
|
|
}
|
2006-07-16 03:47:40 +02:00
|
|
|
|
|
|
|
// Set up new jmpbuf to start executing at forkret (see below).
|
Changes to allow use of native x86 ELF compilers, which on my
Linux 2.4 box using gcc 3.4.6 don't seem to follow the same
conventions as the i386-jos-elf-gcc compilers.
Can run make 'TOOLPREFIX=' or edit the Makefile.
curproc[cpu()] can now be NULL, indicating that no proc is running.
This seemed safer to me than having curproc[0] and curproc[1]
both pointing at proc[0] potentially.
The old implementation of swtch depended on the stack frame layout
used inside swtch being okay to return from on the other stack
(exactly the V6 you are not expected to understand this).
It also could be called in two contexts: at boot time, to schedule
the very first process, and later, on behalf of a process, to sleep
or schedule some other process.
I split this into two functions: scheduler and swtch.
The scheduler is now a separate never-returning function, invoked
by each cpu once set up. The scheduler looks like:
scheduler() {
setjmp(cpu.context);
pick proc to schedule
blah blah blah
longjmp(proc.context)
}
The new swtch is intended to be called only when curproc[cpu()] is not NULL,
that is, only on behalf of a user proc. It does:
swtch() {
if(setjmp(proc.context) == 0)
longjmp(cpu.context)
}
to save the current proc context and then jump over to the scheduler,
running on the cpu stack.
Similarly the system call stubs are now in assembly in usys.S to avoid
needing to know the details of stack frame layout used by the compiler.
Also various changes in the debugging prints.
2006-07-11 03:07:40 +02:00
|
|
|
memset(&np->jmpbuf, 0, sizeof np->jmpbuf);
|
2006-07-17 03:52:13 +02:00
|
|
|
np->jmpbuf.eip = (uint)forkret;
|
2006-07-18 21:22:37 +02:00
|
|
|
np->jmpbuf.esp = (uint)np->tf - 4;
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2007-08-21 21:22:08 +02:00
|
|
|
// Clear %eax so that fork system call returns 0 in child.
|
|
|
|
np->tf->eax = 0;
|
2006-08-15 17:53:46 +02:00
|
|
|
|
2006-06-12 17:22:12 +02:00
|
|
|
return np;
|
|
|
|
}
|
|
|
|
|
2006-09-07 16:12:30 +02:00
|
|
|
//PAGEBREAK: 42
|
2006-09-06 19:27:19 +02:00
|
|
|
// Per-CPU process scheduler.
|
2006-07-16 03:15:28 +02:00
|
|
|
// Each CPU calls scheduler() after setting itself up.
|
|
|
|
// Scheduler never returns. It loops, doing:
|
|
|
|
// - choose a process to run
|
|
|
|
// - longjmp to start running that process
|
|
|
|
// - eventually that process transfers control back
|
2007-08-08 10:38:38 +02:00
|
|
|
// via longjmp back to the scheduler.
|
2006-06-12 17:22:12 +02:00
|
|
|
void
|
Changes to allow use of native x86 ELF compilers, which on my
Linux 2.4 box using gcc 3.4.6 don't seem to follow the same
conventions as the i386-jos-elf-gcc compilers.
Can run make 'TOOLPREFIX=' or edit the Makefile.
curproc[cpu()] can now be NULL, indicating that no proc is running.
This seemed safer to me than having curproc[0] and curproc[1]
both pointing at proc[0] potentially.
The old implementation of swtch depended on the stack frame layout
used inside swtch being okay to return from on the other stack
(exactly the V6 you are not expected to understand this).
It also could be called in two contexts: at boot time, to schedule
the very first process, and later, on behalf of a process, to sleep
or schedule some other process.
I split this into two functions: scheduler and swtch.
The scheduler is now a separate never-returning function, invoked
by each cpu once set up. The scheduler looks like:
scheduler() {
setjmp(cpu.context);
pick proc to schedule
blah blah blah
longjmp(proc.context)
}
The new swtch is intended to be called only when curproc[cpu()] is not NULL,
that is, only on behalf of a user proc. It does:
swtch() {
if(setjmp(proc.context) == 0)
longjmp(cpu.context)
}
to save the current proc context and then jump over to the scheduler,
running on the cpu stack.
Similarly the system call stubs are now in assembly in usys.S to avoid
needing to know the details of stack frame layout used by the compiler.
Also various changes in the debugging prints.
2006-07-11 03:07:40 +02:00
|
|
|
scheduler(void)
|
2006-06-12 17:22:12 +02:00
|
|
|
{
|
2006-07-16 03:15:28 +02:00
|
|
|
struct proc *p;
|
2006-07-01 23:26:01 +02:00
|
|
|
int i;
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
for(;;){
|
|
|
|
// Loop over process table looking for process to run.
|
|
|
|
acquire(&proc_table_lock);
|
2006-08-29 21:06:37 +02:00
|
|
|
|
2006-07-01 23:26:01 +02:00
|
|
|
for(i = 0; i < NPROC; i++){
|
2006-07-16 03:15:28 +02:00
|
|
|
p = &proc[i];
|
|
|
|
if(p->state != RUNNABLE)
|
|
|
|
continue;
|
2006-09-06 19:27:19 +02:00
|
|
|
|
|
|
|
// Switch to chosen process. It is the process's job
|
2006-07-16 03:15:28 +02:00
|
|
|
// to release proc_table_lock and then reacquire it
|
|
|
|
// before jumping back to us.
|
2006-08-16 00:18:20 +02:00
|
|
|
|
|
|
|
setupsegs(p);
|
2007-08-10 18:37:27 +02:00
|
|
|
cp = p;
|
2006-07-16 03:15:28 +02:00
|
|
|
p->state = RUNNING;
|
|
|
|
if(setjmp(&cpus[cpu()].jmpbuf) == 0)
|
|
|
|
longjmp(&p->jmpbuf);
|
2006-09-06 19:27:19 +02:00
|
|
|
|
|
|
|
// Process is done running for now.
|
2006-07-16 03:15:28 +02:00
|
|
|
// It should have changed its p->state before coming back.
|
2007-08-10 18:37:27 +02:00
|
|
|
cp = 0;
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-08-16 00:18:20 +02:00
|
|
|
setupsegs(0);
|
2006-07-12 03:48:35 +02:00
|
|
|
}
|
2006-08-11 00:08:14 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
release(&proc_table_lock);
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
2006-07-16 03:15:28 +02:00
|
|
|
}
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Enter scheduler. Must already hold proc_table_lock
|
|
|
|
// and have changed curproc[cpu()]->state.
|
|
|
|
void
|
|
|
|
sched(void)
|
|
|
|
{
|
2007-08-09 19:32:40 +02:00
|
|
|
if(cp->state == RUNNING)
|
2007-08-08 10:57:37 +02:00
|
|
|
panic("sched running");
|
2006-09-07 18:54:00 +02:00
|
|
|
if(!holding(&proc_table_lock))
|
2007-08-08 10:57:37 +02:00
|
|
|
panic("sched proc_table_lock");
|
2006-09-07 18:54:00 +02:00
|
|
|
if(cpus[cpu()].nlock != 1)
|
|
|
|
panic("sched locks");
|
|
|
|
|
2007-08-10 18:37:27 +02:00
|
|
|
if(setjmp(&cp->jmpbuf) == 0)
|
2006-07-16 03:15:28 +02:00
|
|
|
longjmp(&cpus[cpu()].jmpbuf);
|
Changes to allow use of native x86 ELF compilers, which on my
Linux 2.4 box using gcc 3.4.6 don't seem to follow the same
conventions as the i386-jos-elf-gcc compilers.
Can run make 'TOOLPREFIX=' or edit the Makefile.
curproc[cpu()] can now be NULL, indicating that no proc is running.
This seemed safer to me than having curproc[0] and curproc[1]
both pointing at proc[0] potentially.
The old implementation of swtch depended on the stack frame layout
used inside swtch being okay to return from on the other stack
(exactly the V6 you are not expected to understand this).
It also could be called in two contexts: at boot time, to schedule
the very first process, and later, on behalf of a process, to sleep
or schedule some other process.
I split this into two functions: scheduler and swtch.
The scheduler is now a separate never-returning function, invoked
by each cpu once set up. The scheduler looks like:
scheduler() {
setjmp(cpu.context);
pick proc to schedule
blah blah blah
longjmp(proc.context)
}
The new swtch is intended to be called only when curproc[cpu()] is not NULL,
that is, only on behalf of a user proc. It does:
swtch() {
if(setjmp(proc.context) == 0)
longjmp(cpu.context)
}
to save the current proc context and then jump over to the scheduler,
running on the cpu stack.
Similarly the system call stubs are now in assembly in usys.S to avoid
needing to know the details of stack frame layout used by the compiler.
Also various changes in the debugging prints.
2006-07-11 03:07:40 +02:00
|
|
|
}
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Give up the CPU for one scheduling round.
|
Changes to allow use of native x86 ELF compilers, which on my
Linux 2.4 box using gcc 3.4.6 don't seem to follow the same
conventions as the i386-jos-elf-gcc compilers.
Can run make 'TOOLPREFIX=' or edit the Makefile.
curproc[cpu()] can now be NULL, indicating that no proc is running.
This seemed safer to me than having curproc[0] and curproc[1]
both pointing at proc[0] potentially.
The old implementation of swtch depended on the stack frame layout
used inside swtch being okay to return from on the other stack
(exactly the V6 you are not expected to understand this).
It also could be called in two contexts: at boot time, to schedule
the very first process, and later, on behalf of a process, to sleep
or schedule some other process.
I split this into two functions: scheduler and swtch.
The scheduler is now a separate never-returning function, invoked
by each cpu once set up. The scheduler looks like:
scheduler() {
setjmp(cpu.context);
pick proc to schedule
blah blah blah
longjmp(proc.context)
}
The new swtch is intended to be called only when curproc[cpu()] is not NULL,
that is, only on behalf of a user proc. It does:
swtch() {
if(setjmp(proc.context) == 0)
longjmp(cpu.context)
}
to save the current proc context and then jump over to the scheduler,
running on the cpu stack.
Similarly the system call stubs are now in assembly in usys.S to avoid
needing to know the details of stack frame layout used by the compiler.
Also various changes in the debugging prints.
2006-07-11 03:07:40 +02:00
|
|
|
void
|
2006-07-16 03:47:40 +02:00
|
|
|
yield(void)
|
Changes to allow use of native x86 ELF compilers, which on my
Linux 2.4 box using gcc 3.4.6 don't seem to follow the same
conventions as the i386-jos-elf-gcc compilers.
Can run make 'TOOLPREFIX=' or edit the Makefile.
curproc[cpu()] can now be NULL, indicating that no proc is running.
This seemed safer to me than having curproc[0] and curproc[1]
both pointing at proc[0] potentially.
The old implementation of swtch depended on the stack frame layout
used inside swtch being okay to return from on the other stack
(exactly the V6 you are not expected to understand this).
It also could be called in two contexts: at boot time, to schedule
the very first process, and later, on behalf of a process, to sleep
or schedule some other process.
I split this into two functions: scheduler and swtch.
The scheduler is now a separate never-returning function, invoked
by each cpu once set up. The scheduler looks like:
scheduler() {
setjmp(cpu.context);
pick proc to schedule
blah blah blah
longjmp(proc.context)
}
The new swtch is intended to be called only when curproc[cpu()] is not NULL,
that is, only on behalf of a user proc. It does:
swtch() {
if(setjmp(proc.context) == 0)
longjmp(cpu.context)
}
to save the current proc context and then jump over to the scheduler,
running on the cpu stack.
Similarly the system call stubs are now in assembly in usys.S to avoid
needing to know the details of stack frame layout used by the compiler.
Also various changes in the debugging prints.
2006-07-11 03:07:40 +02:00
|
|
|
{
|
2006-07-16 03:15:28 +02:00
|
|
|
acquire(&proc_table_lock);
|
2007-08-09 19:32:40 +02:00
|
|
|
cp->state = RUNNABLE;
|
2006-07-16 03:15:28 +02:00
|
|
|
sched();
|
|
|
|
release(&proc_table_lock);
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
2006-06-15 21:58:01 +02:00
|
|
|
|
2006-08-29 23:35:30 +02:00
|
|
|
// A fork child's very first scheduling by scheduler()
|
2007-08-08 10:38:38 +02:00
|
|
|
// will longjmp here. "Return" to user space.
|
2006-07-16 03:47:40 +02:00
|
|
|
void
|
|
|
|
forkret(void)
|
|
|
|
{
|
|
|
|
// Still holding proc_table_lock from scheduler.
|
|
|
|
release(&proc_table_lock);
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
// Jump into assembly, never to return.
|
2007-08-10 18:37:27 +02:00
|
|
|
forkret1(cp->tf);
|
2006-07-16 03:47:40 +02:00
|
|
|
}
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Atomically release lock and sleep on chan.
|
|
|
|
// Reacquires lock when reawakened.
|
2006-06-15 21:58:01 +02:00
|
|
|
void
|
2006-07-16 03:15:28 +02:00
|
|
|
sleep(void *chan, struct spinlock *lk)
|
2006-06-15 21:58:01 +02:00
|
|
|
{
|
2007-08-09 19:32:40 +02:00
|
|
|
if(cp == 0)
|
Changes to allow use of native x86 ELF compilers, which on my
Linux 2.4 box using gcc 3.4.6 don't seem to follow the same
conventions as the i386-jos-elf-gcc compilers.
Can run make 'TOOLPREFIX=' or edit the Makefile.
curproc[cpu()] can now be NULL, indicating that no proc is running.
This seemed safer to me than having curproc[0] and curproc[1]
both pointing at proc[0] potentially.
The old implementation of swtch depended on the stack frame layout
used inside swtch being okay to return from on the other stack
(exactly the V6 you are not expected to understand this).
It also could be called in two contexts: at boot time, to schedule
the very first process, and later, on behalf of a process, to sleep
or schedule some other process.
I split this into two functions: scheduler and swtch.
The scheduler is now a separate never-returning function, invoked
by each cpu once set up. The scheduler looks like:
scheduler() {
setjmp(cpu.context);
pick proc to schedule
blah blah blah
longjmp(proc.context)
}
The new swtch is intended to be called only when curproc[cpu()] is not NULL,
that is, only on behalf of a user proc. It does:
swtch() {
if(setjmp(proc.context) == 0)
longjmp(cpu.context)
}
to save the current proc context and then jump over to the scheduler,
running on the cpu stack.
Similarly the system call stubs are now in assembly in usys.S to avoid
needing to know the details of stack frame layout used by the compiler.
Also various changes in the debugging prints.
2006-07-11 03:07:40 +02:00
|
|
|
panic("sleep");
|
2006-07-15 14:03:57 +02:00
|
|
|
|
2006-07-17 07:00:25 +02:00
|
|
|
if(lk == 0)
|
|
|
|
panic("sleep without lk");
|
|
|
|
|
2006-09-06 19:27:19 +02:00
|
|
|
// Must acquire proc_table_lock in order to
|
2006-07-16 03:15:28 +02:00
|
|
|
// change p->state and then call sched.
|
2006-09-06 19:27:19 +02:00
|
|
|
// Once we hold proc_table_lock, we can be
|
2006-07-16 03:15:28 +02:00
|
|
|
// guaranteed that we won't miss any wakeup
|
|
|
|
// (wakeup runs with proc_table_lock locked),
|
|
|
|
// so it's okay to release lk.
|
|
|
|
if(lk != &proc_table_lock){
|
|
|
|
acquire(&proc_table_lock);
|
|
|
|
release(lk);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Go to sleep.
|
2007-08-09 19:32:40 +02:00
|
|
|
cp->chan = chan;
|
|
|
|
cp->state = SLEEPING;
|
2006-07-16 03:15:28 +02:00
|
|
|
sched();
|
2006-07-15 14:03:57 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Tidy up.
|
2007-08-09 19:32:40 +02:00
|
|
|
cp->chan = 0;
|
2006-07-16 03:15:28 +02:00
|
|
|
|
|
|
|
// Reacquire original lock.
|
|
|
|
if(lk != &proc_table_lock){
|
|
|
|
release(&proc_table_lock);
|
|
|
|
acquire(lk);
|
|
|
|
}
|
2006-06-15 21:58:01 +02:00
|
|
|
}
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Wake up all processes sleeping on chan.
|
|
|
|
// Proc_table_lock must be held.
|
2006-06-15 21:58:01 +02:00
|
|
|
void
|
2006-07-15 14:03:57 +02:00
|
|
|
wakeup1(void *chan)
|
2006-06-15 21:58:01 +02:00
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
|
2006-07-15 14:03:57 +02:00
|
|
|
for(p = proc; p < &proc[NPROC]; p++)
|
2006-07-16 03:15:28 +02:00
|
|
|
if(p->state == SLEEPING && p->chan == chan)
|
2006-06-15 21:58:01 +02:00
|
|
|
p->state = RUNNABLE;
|
2006-07-15 14:03:57 +02:00
|
|
|
}
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Wake up all processes sleeping on chan.
|
|
|
|
// Proc_table_lock is acquired and released.
|
2006-07-15 14:03:57 +02:00
|
|
|
void
|
|
|
|
wakeup(void *chan)
|
|
|
|
{
|
|
|
|
acquire(&proc_table_lock);
|
|
|
|
wakeup1(chan);
|
2006-07-12 03:48:35 +02:00
|
|
|
release(&proc_table_lock);
|
2006-06-15 21:58:01 +02:00
|
|
|
}
|
2006-07-11 19:39:45 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Kill the process with the given pid.
|
|
|
|
// Process won't actually exit until it returns
|
|
|
|
// to user space (see trap in trap.c).
|
|
|
|
int
|
|
|
|
proc_kill(int pid)
|
2006-07-11 19:39:45 +02:00
|
|
|
{
|
2006-07-16 03:15:28 +02:00
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
acquire(&proc_table_lock);
|
|
|
|
for(p = proc; p < &proc[NPROC]; p++){
|
|
|
|
if(p->pid == pid){
|
|
|
|
p->killed = 1;
|
|
|
|
// Wake process from sleep if necessary.
|
|
|
|
if(p->state == SLEEPING)
|
|
|
|
p->state = RUNNABLE;
|
|
|
|
release(&proc_table_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
release(&proc_table_lock);
|
|
|
|
return -1;
|
2006-07-11 19:39:45 +02:00
|
|
|
}
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Exit the current process. Does not return.
|
2006-09-06 19:27:19 +02:00
|
|
|
// Exited processes remain in the zombie state
|
2006-07-16 03:15:28 +02:00
|
|
|
// until their parent calls wait() to find out they exited.
|
2006-07-11 19:39:45 +02:00
|
|
|
void
|
2006-07-17 03:25:22 +02:00
|
|
|
proc_exit(void)
|
2006-07-11 19:39:45 +02:00
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
int fd;
|
|
|
|
|
2007-08-08 10:57:37 +02:00
|
|
|
if(cp->pid == 1)
|
|
|
|
panic("init exiting");
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Close all open files.
|
2006-07-11 19:39:45 +02:00
|
|
|
for(fd = 0; fd < NOFILE; fd++){
|
2006-09-06 20:38:56 +02:00
|
|
|
if(cp->ofile[fd]){
|
2006-09-06 20:43:45 +02:00
|
|
|
fileclose(cp->ofile[fd]);
|
2006-09-06 20:38:56 +02:00
|
|
|
cp->ofile[fd] = 0;
|
2006-07-11 19:39:45 +02:00
|
|
|
}
|
|
|
|
}
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-08-29 21:59:52 +02:00
|
|
|
idecref(cp->cwd);
|
|
|
|
cp->cwd = 0;
|
2006-07-11 19:39:45 +02:00
|
|
|
|
2006-07-12 03:48:35 +02:00
|
|
|
acquire(&proc_table_lock);
|
2006-07-11 19:39:45 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Wake up our parent.
|
2006-07-11 19:39:45 +02:00
|
|
|
for(p = proc; p < &proc[NPROC]; p++)
|
|
|
|
if(p->pid == cp->ppid)
|
2006-07-15 14:03:57 +02:00
|
|
|
wakeup1(p);
|
2006-07-11 19:39:45 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Reparent our children to process 1.
|
2006-07-11 19:39:45 +02:00
|
|
|
for(p = proc; p < &proc[NPROC]; p++)
|
2007-08-08 10:57:37 +02:00
|
|
|
if(p->ppid == cp->pid){
|
2006-07-16 03:15:28 +02:00
|
|
|
p->ppid = 1;
|
2007-08-08 10:57:37 +02:00
|
|
|
wakeup1(&proc[1]); // init
|
|
|
|
}
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Jump into the scheduler, never to return.
|
2006-08-29 21:59:52 +02:00
|
|
|
cp->killed = 0;
|
2006-07-16 03:15:28 +02:00
|
|
|
cp->state = ZOMBIE;
|
|
|
|
sched();
|
|
|
|
panic("zombie exit");
|
2006-07-11 19:39:45 +02:00
|
|
|
}
|
2006-07-12 13:15:38 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Wait for a child process to exit and return its pid.
|
|
|
|
// Return -1 if this process has no children.
|
2006-07-15 19:24:54 +02:00
|
|
|
int
|
|
|
|
proc_wait(void)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
2006-07-16 03:15:28 +02:00
|
|
|
int i, havekids, pid;
|
2006-07-15 19:24:54 +02:00
|
|
|
|
|
|
|
acquire(&proc_table_lock);
|
2006-07-16 03:15:28 +02:00
|
|
|
for(;;){
|
2006-08-29 23:35:30 +02:00
|
|
|
// Scan through table looking for zombie children.
|
2006-07-16 03:15:28 +02:00
|
|
|
havekids = 0;
|
|
|
|
for(i = 0; i < NPROC; i++){
|
|
|
|
p = &proc[i];
|
2006-09-07 03:56:22 +02:00
|
|
|
if(p->state == UNUSED)
|
|
|
|
continue;
|
|
|
|
if(p->ppid == cp->pid){
|
2006-07-16 03:15:28 +02:00
|
|
|
if(p->state == ZOMBIE){
|
|
|
|
// Found one.
|
|
|
|
kfree(p->mem, p->sz);
|
|
|
|
kfree(p->kstack, KSTACKSIZE);
|
|
|
|
pid = p->pid;
|
|
|
|
p->state = UNUSED;
|
|
|
|
p->pid = 0;
|
2006-09-07 03:56:22 +02:00
|
|
|
p->ppid = 0;
|
2007-08-08 10:38:38 +02:00
|
|
|
p->name[0] = 0;
|
2006-07-16 03:15:28 +02:00
|
|
|
release(&proc_table_lock);
|
|
|
|
return pid;
|
|
|
|
}
|
|
|
|
havekids = 1;
|
2006-07-15 19:24:54 +02:00
|
|
|
}
|
|
|
|
}
|
2006-09-06 17:32:21 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// No point waiting if we don't have any children.
|
2007-08-08 12:29:42 +02:00
|
|
|
if(!havekids || cp->killed){
|
2006-07-15 19:24:54 +02:00
|
|
|
release(&proc_table_lock);
|
|
|
|
return -1;
|
|
|
|
}
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Wait for children to exit. (See wakeup1 call in proc_exit.)
|
2006-07-15 19:24:54 +02:00
|
|
|
sleep(cp, &proc_table_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-07 17:45:38 +02:00
|
|
|
// Print a process listing to console. For debugging.
|
|
|
|
// Runs when user types ^P on console.
|
|
|
|
// No lock to avoid wedging a stuck machine further.
|
|
|
|
void
|
|
|
|
procdump(void)
|
|
|
|
{
|
2007-08-08 10:38:38 +02:00
|
|
|
static char *states[] = {
|
2007-08-08 11:42:36 +02:00
|
|
|
[UNUSED] "unused",
|
|
|
|
[EMBRYO] "embryo",
|
|
|
|
[SLEEPING] "sleep ",
|
|
|
|
[RUNNABLE] "runble",
|
|
|
|
[RUNNING] "run ",
|
|
|
|
[ZOMBIE] "zombie"
|
2007-08-08 10:38:38 +02:00
|
|
|
};
|
2007-08-20 21:37:15 +02:00
|
|
|
int i, j;
|
2006-09-07 17:45:38 +02:00
|
|
|
struct proc *p;
|
2007-08-08 10:38:38 +02:00
|
|
|
char *state;
|
2007-08-20 21:37:15 +02:00
|
|
|
uint pc[10];
|
2006-09-07 17:45:38 +02:00
|
|
|
|
|
|
|
for(i = 0; i < NPROC; i++) {
|
|
|
|
p = &proc[i];
|
|
|
|
if(p->state == UNUSED)
|
|
|
|
continue;
|
2007-08-08 11:43:07 +02:00
|
|
|
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
|
2007-08-08 10:38:38 +02:00
|
|
|
state = states[p->state];
|
2007-08-08 11:42:36 +02:00
|
|
|
else
|
|
|
|
state = "???";
|
2007-08-20 21:37:15 +02:00
|
|
|
cprintf("%d %s %s", p->pid, state, p->name);
|
|
|
|
if(p->state == SLEEPING) {
|
|
|
|
getcallerpcs((uint*)p->jmpbuf.ebp+2, pc);
|
|
|
|
for(j=0; j<10 && pc[j] != 0; j++)
|
|
|
|
cprintf(" %p", pc[j]);
|
|
|
|
}
|
|
|
|
cprintf("\n");
|
2006-09-07 17:45:38 +02:00
|
|
|
}
|
|
|
|
}
|
2006-09-08 16:26:51 +02:00
|
|
|
|