int CreateAddressSpace (struct AddressSpace *as)
{
struct MemRegion *mr;
KPRINTF ("CreateAddressSpace()");
MutexLock (&vm_mutex);
if (PmapInit(as) == TRUE)
{
LIST_INIT (&as->sorted_memregion_list);
LIST_INIT (&as->free_memregion_list);
as->hint = NULL;
as->page_cnt = 0;
if ((mr = LIST_HEAD (&unused_memregion_list)) != NULL)
{
LIST_REM_HEAD (&unused_memregion_list, unused_entry);
LIST_ADD_HEAD (&as->free_memregion_list, mr, free_entry);
LIST_ADD_HEAD (&as->sorted_memregion_list, mr, sorted_entry);
free_memregion_cnt --;
LIST_INIT (&mr->pageframe_list);
mr->as = as;
mr->type = MR_TYPE_FREE;
mr->prot = VM_PROT_NONE;
mr->flags = MR_FLAGS_NONE;
mr->base_addr = VM_USER_BASE;
mr->ceiling_addr = VM_USER_CEILING;
as->active = TRUE;
MutexUnlock (&vm_mutex);
return 0;
}
PmapDestroy(as);
}
as->active = FALSE;
KPRINTF ("Failed to allocate address-space");
MutexUnlock (&vm_mutex);
return -1;
}
int AllocDupAddressSpace (struct AddressSpace *src_as, struct AddressSpace *dst_as)
{
struct MemRegion *src_mr, *dst_mr;
int error = 0;
MutexLock (&vm_mutex);
if (PmapInit (dst_as) == TRUE)
{
LIST_INIT (&dst_as->sorted_memregion_list);
LIST_INIT (&dst_as->free_memregion_list);
dst_as->hint = NULL;
dst_as->page_cnt = src_as->page_cnt;
src_mr = LIST_HEAD (¤t_process->user_as->sorted_memregion_list);
while (src_mr != NULL && error == 0)
{
if ((dst_mr = LIST_HEAD (&unused_memregion_list)) != NULL)
{
LIST_REM_HEAD (&unused_memregion_list, unused_entry);
LIST_ADD_TAIL (&dst_as->sorted_memregion_list, dst_mr, sorted_entry);
free_memregion_cnt--;
dst_mr->base_addr = src_mr->base_addr;
dst_mr->ceiling_addr = src_mr->ceiling_addr;
dst_mr->as = dst_as;
dst_mr->type = src_mr->type;
dst_mr->prot = src_mr->prot;
dst_mr->flags = src_mr->flags;
dst_mr->pageframe_hint = NULL;
LIST_INIT (&dst_mr->pageframe_list);
if (dst_mr->type == MR_TYPE_ANON)
{
if (AllocDupPageframes (dst_mr, src_mr) != 0)
{
error = -1;
}
}
else if (dst_mr->type == MR_TYPE_FREE)
{
LIST_ADD_TAIL (&dst_as->free_memregion_list, dst_mr, free_entry);
}
}
else
{
error = -1;
}
src_mr = LIST_NEXT (src_mr, sorted_entry);
}
}
else
{
error = -1;
}
MutexUnlock (&vm_mutex);
KASSERT (error != -1);
return error;
}
struct Process *CreateProcess (void (*entry)(void), void *stack, int policy, int priority, bits32_t flags, struct CPU *cpu)
{
int handle;
struct Process *proc;
proc = AllocProcess();
handle = AllocHandle();
KASSERT (handle >= 0);
SetObject (proc, handle, HANDLE_TYPE_PROCESS, proc);
proc->handle = handle;
proc->exit_status = 0;
proc->flags = flags;
// FIXME: Move into AllocProcess ????????????????
LIST_INIT (&proc->pending_handle_list);
LIST_INIT (&proc->close_handle_list);
PmapInit (proc);
proc->task_state.cpu = cpu;
proc->task_state.flags = 0;
proc->task_state.pc = (uint32)entry;
proc->task_state.r0 = 0;
if (proc->flags & PROCF_DAEMON) {
proc->task_state.cpsr = cpsr_dnm_state | SYS_MODE | CPSR_DEFAULT_BITS;
}
else {
proc->task_state.cpsr = cpsr_dnm_state | USR_MODE | CPSR_DEFAULT_BITS;
}
proc->task_state.r1 = 0;
proc->task_state.r2 = 0;
proc->task_state.r3 = 0;
proc->task_state.r4 = 0;
proc->task_state.r5 = 0;
proc->task_state.r6 = 0;
proc->task_state.r7 = 0;
proc->task_state.r8 = 0;
proc->task_state.r9 = 0;
proc->task_state.r10 = 0;
proc->task_state.r11 = 0;
proc->task_state.r12 = 0;
proc->task_state.sp = (uint32)stack;
proc->task_state.lr = 0;
if (policy == SCHED_RR || policy == SCHED_FIFO)
{
proc->quanta_used = 0;
proc->sched_policy = policy;
proc->tickets = priority;
SchedReady (proc);
}
else if (policy == SCHED_OTHER)
{
proc->quanta_used = 0;
proc->sched_policy = policy;
proc->tickets = priority;
proc->stride = STRIDE1 / proc->tickets;
proc->remaining = proc->stride;
proc->pass = global_pass;
SchedReady (proc);
}
else if (policy == SCHED_IDLE)
{
cpu->idle_process = proc;
}
return proc;
}
