/* see <kern/proc.h> for definitions of scheduler classes */
struct proc *
newproc(int argc, char *argv[], char *envp[], long sched)
{
long id = taskgetid();
struct proc *proc = (id >= 0) ? &proctab[id] : NULL;
struct task *task = (id >= 0) ? &tasktab[id] : NULL;
if (proc) {
procinit(id, sched);
proc->argc = argc;
proc->argv = argv;
proc->envp = envp;
}
return proc;
}
/* see <kern/proc.h> for definitions of scheduler classes */
struct proc *
newproc(int argc, char *argv[], char *envp[], long sched)
{
long taskid = taskgetid();
struct proc *proc = &proctab[taskid];
struct task *task = &tasktab[taskid];
task->state = TASKNEW;
task->sched = sched;
task->proc = proc;
proc->task = task;
proc->argc = argc;
proc->argv = argv;
proc->envp = envp;
return proc;
}
long
procinit(long id, long sched)
{
volatile struct cpu *cpu;
struct proc *proc;
struct task *task;
long prio;
long val;
struct taskstk *stk;
void *ptr;
uint8_t *u8ptr;
if (id < TASKNPREDEF) {
// cpu = &cputab[0];
cpu = k_curcpu;
proc = &proctab[id];
task = &tasktab[id];
prio = SCHEDSYSPRIOMIN;
task->sched = SCHEDSYSTEM;
task->prio = prio;
proc->pagedir = (pde_t *)kernpagedir;
proc->pagetab = (pte_t *)&_pagetab;
task->state = TASKREADY;
if (cpu->info.flg & CPUHASFXSR) {
task->flg |= CPUHASFXSR;
}
k_curcpu = cpu;
k_curunit = 0;
k_curtask = task;
k_curpid = id;
return id;
} else {
cpu = &cputab[0];
id = taskgetid();
proc = &proctab[id];
task = &tasktab[id];
task->state = TASKNEW;
proc->pid = id;
proc->nice = 0;
proc->task = task;
k_curtask = task;
task->proc = proc;
val = 0;
if (cpu->flg & CPUHASFXSR) {
val = CPUHASFXSR;
task->flg |= val;
}
val = 0;
task->flg = val;
task->score = val;
task->slice = val;
task->runtime = val;
task->slptime = val;
task->ntick = val;
val = cpu->ntick;
task->lastrun = val;
task->firstrun = val;
task->lasttick = val;
if (sched == SCHEDNOCLASS) {
prio = SCHEDUSERPRIOMIN;
task->sched = SCHEDNORMAL;
task->prio = prio;
} else {
prio = schedclassminprio(sched);
task->sched = sched;
task->prio = prio;
}
if (task->state == TASKNEW) {
/* initialise page directory */
ptr = kwalloc(NPDE * sizeof(pde_t));
if (ptr) {
kbzero(ptr, NPDE * sizeof(pde_t));
proc->pagedir = ptr;
} else {
kfree(proc);
return -1;
}
#if (VMFLATPHYSTAB)
/* initialise page tables */
ptr = kwalloc(PAGETABSIZE);
if (ptr) {
kbzero(ptr, PAGETABSIZE);
proc->pagetab = ptr;
} else {
kfree(proc->pagedir);
kfree(proc);
return -1;
}
#endif
/* initialise descriptor table */
ptr = kmalloc(NPROCFD * sizeof(struct desc));
if (ptr) {
kbzero(ptr, NPROCFD * sizeof(struct desc));
proc->desctab = ptr;
proc->ndesctab = NPROCFD;
} else {
if (id >= TASKNPREDEF) {
kfree(proc->pagetab);
kfree(proc->pagedir);
kfree(proc);
}
}
}
}
return id;
}
long
procinit(long id)
{
long taskid = ((id < TASKNPREDEF && (id >= 0))
? id
: taskgetid());
struct proc *proc = &proctab[taskid];
struct task *task = &tasktab[taskid];
struct taskstk *stk;
void *ptr;
uint8_t *u8ptr;
if (taskid < TASKNPREDEF) {
/* bootstrap */
if (k_curcpu->info->flags & CPUHASFXSR) {
task->m_tcb.fxsave = 1;
} else {
task->m_tcb.fxsave = 0;
}
proc->task = task;
task->proc = proc;
task->state = TASKREADY;
task->nice = 0;
task->sched = SCHEDNORMAL;
task->prio = id;
k_curproc = proc;
k_curtask = task;
}
if (proc) {
if (taskid >= TASKNPREDEF) {
/* initialise page directory */
ptr = kmalloc(NPDE * sizeof(pde_t));
if (ptr) {
kbzero(ptr, NPDE * sizeof(pde_t));
proc->vmpagemap.dir = ptr;
} else {
kfree(proc);
return -1;
}
ptr = kmalloc(KERNSTKSIZE);
if (ptr) {
u8ptr = ptr;
stk = &task->kstk;
u8ptr += KERNSTKSIZE;
kbzero(ptr, KERNSTKSIZE);
stk->top = u8ptr;
stk->sp = u8ptr;
stk->base = ptr;
stk->size = KERNSTKSIZE;
}
ptr = kmalloc(TASKSTKSIZE);
if (ptr) {
u8ptr = ptr;
stk = &task->ustk;
u8ptr += KERNSTKSIZE;
kbzero(ptr, TASKSTKSIZE);
stk->top = u8ptr;
stk->sp = u8ptr;
stk->base = ptr;
stk->size = TASKSTKSIZE;
} else {
kfree(proc->vmpagemap.dir);
kfree(task->kstk.base);
kfree(proc);
return -1;
}
/* initialise descriptor table */
ptr = kmalloc(TASKNDESC * sizeof(struct desc));
if (ptr) {
kbzero(ptr, TASKNDESC * sizeof(struct desc));
proc->desctab = ptr;
proc->ndesctab = TASKNDESC;
} else {
kfree(proc->vmpagemap.dir);
kfree(task->ustk.base);
kfree(task->kstk.base);
kfree(proc);
return -1;
}
#if 0
/* initialise VM structures */
ptr = kmalloc(NPAGEMAX * sizeof(struct userpage));
if (ptr) {
kbzero(ptr, NPAGEMAX * sizeof(struct userpage));
proc->pagetab = ptr;
proc->npagetab = NPAGEMAX;
} else {
kfree(proc->vmpagemap.dir);
kfree(task->ustk.base);
kfree(task->kstk.base);
kfree(proc->desctab);
kfree(proc);
return -1;
}
#endif
task->state = TASKREADY;
}
}
return 0;
}
