2006-06-12 17:22:12 +02:00
|
|
|
#include "types.h"
|
2007-08-28 01:26:33 +02:00
|
|
|
#include "defs.h"
|
|
|
|
#include "param.h"
|
2011-07-29 13:31:27 +02:00
|
|
|
#include "memlayout.h"
|
2006-06-12 17:22:12 +02:00
|
|
|
#include "mmu.h"
|
|
|
|
#include "x86.h"
|
2006-06-22 22:47:23 +02:00
|
|
|
#include "proc.h"
|
2006-07-12 03:48:35 +02:00
|
|
|
#include "spinlock.h"
|
|
|
|
|
2009-05-31 07:12:21 +02:00
|
|
|
struct {
|
|
|
|
struct spinlock lock;
|
|
|
|
struct proc proc[NPROC];
|
|
|
|
} ptable;
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2007-08-23 16:35:28 +02:00
|
|
|
static struct proc *initproc;
|
|
|
|
|
2007-08-22 08:01:32 +02:00
|
|
|
int nextpid = 1;
|
2006-07-16 03:15:28 +02:00
|
|
|
extern void forkret(void);
|
2009-07-12 04:28:29 +02:00
|
|
|
extern void trapret(void);
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2010-09-02 20:30:06 +02:00
|
|
|
static void wakeup1(void *chan);
|
|
|
|
|
2006-08-11 00:08:14 +02:00
|
|
|
void
|
|
|
|
pinit(void)
|
|
|
|
{
|
2009-05-31 07:12:21 +02:00
|
|
|
initlock(&ptable.lock, "ptable");
|
2006-08-11 00:08:14 +02:00
|
|
|
}
|
|
|
|
|
2009-09-03 09:46:15 +02:00
|
|
|
//PAGEBREAK: 32
|
2007-08-22 08:01:32 +02:00
|
|
|
// Look in the process table for an UNUSED proc.
|
2010-09-13 21:34:44 +02:00
|
|
|
// If found, change state to EMBRYO and initialize
|
|
|
|
// state required to run in the kernel.
|
2007-08-22 08:01:32 +02:00
|
|
|
// Otherwise return 0.
|
|
|
|
static struct proc*
|
|
|
|
allocproc(void)
|
2006-06-12 17:22:12 +02:00
|
|
|
{
|
2007-08-22 08:01:32 +02:00
|
|
|
struct proc *p;
|
2009-07-12 04:28:29 +02:00
|
|
|
char *sp;
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2009-05-31 07:12:21 +02:00
|
|
|
acquire(&ptable.lock);
|
2009-07-12 04:28:29 +02:00
|
|
|
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
|
|
|
|
if(p->state == UNUSED)
|
2009-05-31 02:28:45 +02:00
|
|
|
goto found;
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.lock);
|
2007-08-22 08:01:32 +02:00
|
|
|
return 0;
|
2009-05-31 02:28:45 +02:00
|
|
|
|
|
|
|
found:
|
2009-07-12 04:28:29 +02:00
|
|
|
p->state = EMBRYO;
|
|
|
|
p->pid = nextpid++;
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.lock);
|
2009-05-31 02:28:45 +02:00
|
|
|
|
2011-09-01 18:02:49 +02:00
|
|
|
// Allocate kernel stack.
|
2010-08-31 18:54:47 +02:00
|
|
|
if((p->kstack = kalloc()) == 0){
|
2009-05-31 02:28:45 +02:00
|
|
|
p->state = UNUSED;
|
|
|
|
return 0;
|
|
|
|
}
|
2009-07-12 04:28:29 +02:00
|
|
|
sp = p->kstack + KSTACKSIZE;
|
|
|
|
|
|
|
|
// Leave room for trap frame.
|
|
|
|
sp -= sizeof *p->tf;
|
|
|
|
p->tf = (struct trapframe*)sp;
|
|
|
|
|
|
|
|
// Set up new context to start executing at forkret,
|
2010-09-13 21:34:44 +02:00
|
|
|
// which returns to trapret.
|
2009-07-12 04:28:29 +02:00
|
|
|
sp -= 4;
|
|
|
|
*(uint*)sp = (uint)trapret;
|
|
|
|
|
|
|
|
sp -= sizeof *p->context;
|
|
|
|
p->context = (struct context*)sp;
|
|
|
|
memset(p->context, 0, sizeof *p->context);
|
2009-05-31 02:28:45 +02:00
|
|
|
p->context->eip = (uint)forkret;
|
2010-09-13 21:34:44 +02:00
|
|
|
|
2009-05-31 02:28:45 +02:00
|
|
|
return p;
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
|
|
|
|
2009-09-03 09:46:15 +02:00
|
|
|
//PAGEBREAK: 32
|
2009-08-08 10:07:30 +02:00
|
|
|
// Set up first user process.
|
|
|
|
void
|
|
|
|
userinit(void)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
extern char _binary_initcode_start[], _binary_initcode_size[];
|
|
|
|
|
|
|
|
p = allocproc();
|
|
|
|
initproc = p;
|
2011-08-10 03:37:35 +02:00
|
|
|
if((p->pgdir = setupkvm(kalloc)) == 0)
|
2010-07-02 20:51:53 +02:00
|
|
|
panic("userinit: out of memory?");
|
2010-09-02 21:37:05 +02:00
|
|
|
inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size);
|
|
|
|
p->sz = PGSIZE;
|
2009-08-08 10:07:30 +02:00
|
|
|
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;
|
2010-07-02 20:51:53 +02:00
|
|
|
p->tf->esp = PGSIZE;
|
2009-08-08 10:07:30 +02:00
|
|
|
p->tf->eip = 0; // beginning of initcode.S
|
|
|
|
|
|
|
|
safestrcpy(p->name, "initcode", sizeof(p->name));
|
|
|
|
p->cwd = namei("/");
|
|
|
|
|
|
|
|
p->state = RUNNABLE;
|
|
|
|
}
|
|
|
|
|
2006-09-08 16:26:51 +02:00
|
|
|
// Grow current process's memory by n bytes.
|
2009-05-31 02:28:45 +02:00
|
|
|
// Return 0 on success, -1 on failure.
|
2006-09-08 16:26:51 +02:00
|
|
|
int
|
|
|
|
growproc(int n)
|
|
|
|
{
|
2011-01-11 19:01:13 +01:00
|
|
|
uint sz;
|
|
|
|
|
|
|
|
sz = proc->sz;
|
2010-08-10 23:08:41 +02:00
|
|
|
if(n > 0){
|
2011-01-11 19:01:13 +01:00
|
|
|
if((sz = allocuvm(proc->pgdir, sz, sz + n)) == 0)
|
2010-08-10 23:08:41 +02:00
|
|
|
return -1;
|
|
|
|
} else if(n < 0){
|
2011-01-11 19:01:13 +01:00
|
|
|
if((sz = deallocuvm(proc->pgdir, sz, sz + n)) == 0)
|
2010-08-10 23:08:41 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2010-09-03 00:28:36 +02:00
|
|
|
proc->sz = sz;
|
2010-08-06 17:12:18 +02:00
|
|
|
switchuvm(proc);
|
2009-05-31 02:28:45 +02:00
|
|
|
return 0;
|
2006-09-08 16:26:51 +02:00
|
|
|
}
|
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
// Create a new process copying p as the parent.
|
2007-08-22 08:01:32 +02:00
|
|
|
// Sets up stack to return as if from system call.
|
|
|
|
// Caller must set state of returned proc to RUNNABLE.
|
2009-05-31 02:38:51 +02:00
|
|
|
int
|
|
|
|
fork(void)
|
2006-06-12 17:22:12 +02:00
|
|
|
{
|
2009-05-31 02:38:51 +02:00
|
|
|
int i, pid;
|
2006-06-12 17:22:12 +02:00
|
|
|
struct proc *np;
|
|
|
|
|
2006-07-16 03:47:40 +02:00
|
|
|
// Allocate process.
|
2007-08-22 08:01:32 +02:00
|
|
|
if((np = allocproc()) == 0)
|
2009-05-31 02:38:51 +02:00
|
|
|
return -1;
|
2006-07-12 03:48:35 +02:00
|
|
|
|
2009-05-31 02:28:45 +02:00
|
|
|
// Copy process state from p.
|
2011-01-11 19:01:13 +01:00
|
|
|
if((np->pgdir = copyuvm(proc->pgdir, proc->sz)) == 0){
|
2010-08-31 18:54:47 +02:00
|
|
|
kfree(np->kstack);
|
2009-05-31 02:28:45 +02:00
|
|
|
np->kstack = 0;
|
2006-07-12 03:48:35 +02:00
|
|
|
np->state = UNUSED;
|
2009-05-31 02:38:51 +02:00
|
|
|
return -1;
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
2010-07-02 20:51:53 +02:00
|
|
|
np->sz = proc->sz;
|
2009-08-31 08:02:08 +02:00
|
|
|
np->parent = proc;
|
|
|
|
*np->tf = *proc->tf;
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2009-05-31 02:38:51 +02:00
|
|
|
// Clear %eax so that fork returns 0 in the child.
|
|
|
|
np->tf->eax = 0;
|
2007-08-21 21:22:08 +02:00
|
|
|
|
2009-05-31 02:38:51 +02:00
|
|
|
for(i = 0; i < NOFILE; i++)
|
2009-08-31 08:02:08 +02:00
|
|
|
if(proc->ofile[i])
|
|
|
|
np->ofile[i] = filedup(proc->ofile[i]);
|
|
|
|
np->cwd = idup(proc->cwd);
|
2009-05-31 02:38:51 +02:00
|
|
|
|
|
|
|
pid = np->pid;
|
|
|
|
np->state = RUNNABLE;
|
2010-07-02 20:51:53 +02:00
|
|
|
safestrcpy(np->name, proc->name, sizeof(proc->name));
|
2009-05-31 02:38:51 +02:00
|
|
|
return pid;
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
|
|
|
|
2010-09-02 10:15:17 +02:00
|
|
|
// Exit the current process. Does not return.
|
|
|
|
// An exited process remains in the zombie state
|
|
|
|
// until its parent calls wait() to find out it exited.
|
|
|
|
void
|
|
|
|
exit(void)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if(proc == initproc)
|
|
|
|
panic("init exiting");
|
|
|
|
|
|
|
|
// Close all open files.
|
|
|
|
for(fd = 0; fd < NOFILE; fd++){
|
|
|
|
if(proc->ofile[fd]){
|
|
|
|
fileclose(proc->ofile[fd]);
|
|
|
|
proc->ofile[fd] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
iput(proc->cwd);
|
|
|
|
proc->cwd = 0;
|
|
|
|
|
|
|
|
acquire(&ptable.lock);
|
|
|
|
|
|
|
|
// Parent might be sleeping in wait().
|
|
|
|
wakeup1(proc->parent);
|
|
|
|
|
|
|
|
// Pass abandoned children to init.
|
|
|
|
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
|
|
|
|
if(p->parent == proc){
|
|
|
|
p->parent = initproc;
|
|
|
|
if(p->state == ZOMBIE)
|
|
|
|
wakeup1(initproc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Jump into the scheduler, never to return.
|
|
|
|
proc->state = ZOMBIE;
|
|
|
|
sched();
|
|
|
|
panic("zombie exit");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for a child process to exit and return its pid.
|
|
|
|
// Return -1 if this process has no children.
|
|
|
|
int
|
|
|
|
wait(void)
|
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
int havekids, pid;
|
|
|
|
|
|
|
|
acquire(&ptable.lock);
|
|
|
|
for(;;){
|
|
|
|
// Scan through table looking for zombie children.
|
|
|
|
havekids = 0;
|
|
|
|
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
|
|
|
|
if(p->parent != proc)
|
|
|
|
continue;
|
|
|
|
havekids = 1;
|
|
|
|
if(p->state == ZOMBIE){
|
|
|
|
// 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);
|
|
|
|
return pid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// No point waiting if we don't have any children.
|
|
|
|
if(!havekids || proc->killed){
|
|
|
|
release(&ptable.lock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for children to exit. (See wakeup1 call in proc_exit.)
|
|
|
|
sleep(proc, &ptable.lock); //DOC: wait-sleep
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
2007-08-30 19:39:56 +02:00
|
|
|
// - swtch to start running that process
|
|
|
|
// - eventually that process transfers control
|
|
|
|
// via swtch 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
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
for(;;){
|
2009-07-12 04:28:29 +02:00
|
|
|
// Enable interrupts on this processor.
|
2007-09-27 23:25:37 +02:00
|
|
|
sti();
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Loop over process table looking for process to run.
|
2009-05-31 07:12:21 +02:00
|
|
|
acquire(&ptable.lock);
|
|
|
|
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
|
2006-07-16 03:15:28 +02:00
|
|
|
if(p->state != RUNNABLE)
|
|
|
|
continue;
|
2006-09-06 19:27:19 +02:00
|
|
|
|
|
|
|
// Switch to chosen process. It is the process's job
|
2009-05-31 07:12:21 +02:00
|
|
|
// to release ptable.lock and then reacquire it
|
2006-07-16 03:15:28 +02:00
|
|
|
// before jumping back to us.
|
2009-08-31 08:02:08 +02:00
|
|
|
proc = p;
|
2010-08-06 17:12:18 +02:00
|
|
|
switchuvm(p);
|
2006-07-16 03:15:28 +02:00
|
|
|
p->state = RUNNING;
|
2009-08-31 08:02:08 +02:00
|
|
|
swtch(&cpu->scheduler, proc->context);
|
2010-08-06 17:12:18 +02:00
|
|
|
switchkvm();
|
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.
|
2009-08-31 08:02:08 +02:00
|
|
|
proc = 0;
|
2006-07-12 03:48:35 +02:00
|
|
|
}
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.lock);
|
2007-09-27 23:25:37 +02:00
|
|
|
|
2006-06-12 17:22:12 +02:00
|
|
|
}
|
2006-07-16 03:15:28 +02:00
|
|
|
}
|
2006-06-12 17:22:12 +02:00
|
|
|
|
2009-07-12 04:28:29 +02:00
|
|
|
// Enter scheduler. Must hold only ptable.lock
|
2009-08-31 08:02:08 +02:00
|
|
|
// and have changed proc->state.
|
2006-07-16 03:15:28 +02:00
|
|
|
void
|
|
|
|
sched(void)
|
|
|
|
{
|
2008-10-15 07:01:39 +02:00
|
|
|
int intena;
|
|
|
|
|
2009-05-31 07:12:21 +02:00
|
|
|
if(!holding(&ptable.lock))
|
|
|
|
panic("sched ptable.lock");
|
2009-08-31 08:02:08 +02:00
|
|
|
if(cpu->ncli != 1)
|
2006-09-07 18:54:00 +02:00
|
|
|
panic("sched locks");
|
2009-08-31 08:02:08 +02:00
|
|
|
if(proc->state == RUNNING)
|
2009-07-12 04:28:29 +02:00
|
|
|
panic("sched running");
|
|
|
|
if(readeflags()&FL_IF)
|
|
|
|
panic("sched interruptible");
|
2009-08-31 08:02:08 +02:00
|
|
|
intena = cpu->intena;
|
|
|
|
swtch(&proc->context, cpu->scheduler);
|
|
|
|
cpu->intena = intena;
|
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
|
|
|
{
|
2009-07-12 04:28:29 +02:00
|
|
|
acquire(&ptable.lock); //DOC: yieldlock
|
2009-08-31 08:02:08 +02:00
|
|
|
proc->state = RUNNABLE;
|
2006-07-16 03:15:28 +02:00
|
|
|
sched();
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.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-30 19:39:56 +02:00
|
|
|
// will swtch here. "Return" to user space.
|
2006-07-16 03:47:40 +02:00
|
|
|
void
|
|
|
|
forkret(void)
|
|
|
|
{
|
2011-08-23 02:05:15 +02:00
|
|
|
static int first = 1;
|
2009-05-31 07:12:21 +02:00
|
|
|
// Still holding ptable.lock from scheduler.
|
|
|
|
release(&ptable.lock);
|
2011-08-23 02:05:15 +02:00
|
|
|
|
|
|
|
if (first) {
|
2011-08-23 02:07:18 +02:00
|
|
|
// Some initialization functions must be run in the context
|
|
|
|
// of a regular process (e.g., they call sleep), and thus cannot
|
|
|
|
// be run from main().
|
2011-08-23 02:05:15 +02:00
|
|
|
first = 0;
|
|
|
|
initlog();
|
|
|
|
}
|
2009-07-12 04:28:29 +02:00
|
|
|
|
|
|
|
// Return to "caller", actually trapret (see allocproc).
|
2006-07-16 03:47:40 +02:00
|
|
|
}
|
|
|
|
|
2006-07-16 03:15:28 +02:00
|
|
|
// Atomically release lock and sleep on chan.
|
2009-08-31 08:02:08 +02:00
|
|
|
// Reacquires lock when awakened.
|
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
|
|
|
{
|
2009-08-31 08:02:08 +02:00
|
|
|
if(proc == 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");
|
|
|
|
|
2009-05-31 07:12:21 +02:00
|
|
|
// Must acquire ptable.lock in order to
|
2006-07-16 03:15:28 +02:00
|
|
|
// change p->state and then call sched.
|
2009-05-31 07:12:21 +02:00
|
|
|
// Once we hold ptable.lock, we can be
|
2006-07-16 03:15:28 +02:00
|
|
|
// guaranteed that we won't miss any wakeup
|
2009-05-31 07:12:21 +02:00
|
|
|
// (wakeup runs with ptable.lock locked),
|
2006-07-16 03:15:28 +02:00
|
|
|
// so it's okay to release lk.
|
2009-07-13 03:33:37 +02:00
|
|
|
if(lk != &ptable.lock){ //DOC: sleeplock0
|
|
|
|
acquire(&ptable.lock); //DOC: sleeplock1
|
2006-07-16 03:15:28 +02:00
|
|
|
release(lk);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Go to sleep.
|
2009-08-31 08:02:08 +02:00
|
|
|
proc->chan = chan;
|
|
|
|
proc->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.
|
2009-08-31 08:02:08 +02:00
|
|
|
proc->chan = 0;
|
2006-07-16 03:15:28 +02:00
|
|
|
|
|
|
|
// Reacquire original lock.
|
2009-07-13 03:33:37 +02:00
|
|
|
if(lk != &ptable.lock){ //DOC: sleeplock2
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.lock);
|
2006-07-16 03:15:28 +02:00
|
|
|
acquire(lk);
|
|
|
|
}
|
2006-06-15 21:58:01 +02:00
|
|
|
}
|
|
|
|
|
2007-08-22 08:01:32 +02:00
|
|
|
//PAGEBREAK!
|
2006-07-16 03:15:28 +02:00
|
|
|
// Wake up all processes sleeping on chan.
|
2009-05-31 07:12:21 +02:00
|
|
|
// The ptable lock must be held.
|
2007-08-24 22:22:55 +02:00
|
|
|
static void
|
2006-07-15 14:03:57 +02:00
|
|
|
wakeup1(void *chan)
|
2006-06-15 21:58:01 +02:00
|
|
|
{
|
|
|
|
struct proc *p;
|
|
|
|
|
2009-05-31 07:13:51 +02:00
|
|
|
for(p = ptable.proc; p < &ptable.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.
|
2006-07-15 14:03:57 +02:00
|
|
|
void
|
|
|
|
wakeup(void *chan)
|
|
|
|
{
|
2009-05-31 07:12:21 +02:00
|
|
|
acquire(&ptable.lock);
|
2006-07-15 14:03:57 +02:00
|
|
|
wakeup1(chan);
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.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.
|
2009-08-31 08:02:08 +02:00
|
|
|
// Process won't exit until it returns
|
2006-07-16 03:15:28 +02:00
|
|
|
// to user space (see trap in trap.c).
|
|
|
|
int
|
2007-08-28 21:14:43 +02:00
|
|
|
kill(int pid)
|
2006-07-11 19:39:45 +02:00
|
|
|
{
|
2006-07-16 03:15:28 +02:00
|
|
|
struct proc *p;
|
|
|
|
|
2009-05-31 07:12:21 +02:00
|
|
|
acquire(&ptable.lock);
|
|
|
|
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
|
2006-07-16 03:15:28 +02:00
|
|
|
if(p->pid == pid){
|
|
|
|
p->killed = 1;
|
|
|
|
// Wake process from sleep if necessary.
|
|
|
|
if(p->state == SLEEPING)
|
|
|
|
p->state = RUNNABLE;
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.lock);
|
2006-07-16 03:15:28 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2009-05-31 07:12:21 +02:00
|
|
|
release(&ptable.lock);
|
2006-07-16 03:15:28 +02:00
|
|
|
return -1;
|
2006-07-11 19:39:45 +02:00
|
|
|
}
|
|
|
|
|
2011-02-20 03:17:55 +01:00
|
|
|
//PAGEBREAK: 36
|
|
|
|
// 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)
|
|
|
|
{
|
|
|
|
static char *states[] = {
|
|
|
|
[UNUSED] "unused",
|
|
|
|
[EMBRYO] "embryo",
|
|
|
|
[SLEEPING] "sleep ",
|
|
|
|
[RUNNABLE] "runble",
|
|
|
|
[RUNNING] "run ",
|
|
|
|
[ZOMBIE] "zombie"
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
struct proc *p;
|
|
|
|
char *state;
|
|
|
|
uint pc[10];
|
|
|
|
|
|
|
|
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
|
|
|
|
if(p->state == UNUSED)
|
|
|
|
continue;
|
|
|
|
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
|
|
|
|
state = states[p->state];
|
|
|
|
else
|
|
|
|
state = "???";
|
|
|
|
cprintf("%d %s %s", p->pid, state, p->name);
|
|
|
|
if(p->state == SLEEPING){
|
|
|
|
getcallerpcs((uint*)p->context->ebp+2, pc);
|
|
|
|
for(i=0; i<10 && pc[i] != 0; i++)
|
|
|
|
cprintf(" %p", pc[i]);
|
|
|
|
}
|
|
|
|
cprintf("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|