From af03975dc187ae48fbb040c4e80f4e4551013c4d Mon Sep 17 00:00:00 2001 From: Bahadir Balban Date: Thu, 11 Sep 2008 16:56:41 +0300 Subject: [PATCH] Towards adding sys_clone() Stopped working on self_spawn() - going to finish clone() syscall first. Arch-specific clone() library call that does ipc() and cloned child setup. - Need to finish thread_create() that satisfy clone() necessities. i.e. setting up its stack. Question: Does the pager (and thus the microkernel) have to explicitly set SP_USR? Once the call is known to be successful, the library could set it. --- src/api/thread.c | 73 +++++++++++++++++++---------- tasks/libl4/include/l4lib/ipcdefs.h | 1 + tasks/libl4/src/arm/syscalls.S | 42 +++++++++++++++++ tasks/libposix/fork.c | 36 ++++++++++++++ tasks/mm0/main.c | 43 ++++++++++++++--- tasks/mm0/src/clone.c | 70 ++++++++++++++++++++++++++- 6 files changed, 230 insertions(+), 35 deletions(-) diff --git a/src/api/thread.c b/src/api/thread.c index 6c75890..acd9eb7 100644 --- a/src/api/thread.c +++ b/src/api/thread.c @@ -128,6 +128,47 @@ int arch_setup_new_thread(struct ktcb *new, struct ktcb *orig) return 0; } +int thread_setup_new_ids(struct task_ids *ids, unsigned int flags, + struct tcb *new, struct tcb *orig) +{ + /* For tid, allocate requested id if it's available, else a new one */ + if ((ids->tid = id_get(thread_id_pool, ids->tid)) < 0) + ids->tid = id_new(thread_id_pool); + + /* + * If thread space is new or copied, + * allocate a new space id and tgid + */ + if (flags == THREAD_CREATE_NEWSPC || + flags == THREAD_CREATE_COPYSPC) { + /* + * Allocate requested id if + * it's available, else a new one + */ + if ((ids->spid = id_get(space_id_pool, + ids->spid)) < 0) + ids->spid = id_new(space_id_pool); + + /* It also gets a thread group id */ + if ((ids->tgid = id_get(tgroup_id_pool, + ids->tgid)) < 0) + ids->tgid = id_new(tgroup_id_pool); + } + + /* If thread space is the same, tgid is either new or existing one */ + if (flags == THREAD_CREATE_SAMESPC) { + /* Check if same tgid is expected */ + if (ids->tgid != task->tgid) { + if ((ids->tgid = id_get(tgroup_id_pool, + ids->tgid)) < 0) + ids->tgid = id_new(tgroup_id_pool); + } + } + + /* Set all ids */ + set_task_ids(new, ids); +} + /* * Creates a thread, with a new thread id, and depending on the flags, * either creates a new space, uses the same space as another thread, @@ -137,7 +178,7 @@ int arch_setup_new_thread(struct ktcb *new, struct ktcb *orig) */ int thread_create(struct task_ids *ids, unsigned int flags) { - struct ktcb *task, *new = (struct ktcb *)zalloc_page(); + struct ktcb *task = 0, *new = (struct ktcb *)zalloc_page(); flags &= THREAD_FLAGS_MASK; if (flags == THREAD_CREATE_NEWSPC) { @@ -161,30 +202,8 @@ int thread_create(struct task_ids *ids, unsigned int flags) BUG(); } out: - /* Allocate requested id if it's available, else a new one */ - if ((ids->tid = id_get(thread_id_pool, ids->tid)) < 0) - ids->tid = id_new(thread_id_pool); - - /* If thread space is new or copied, it gets a new space id */ - if (flags == THREAD_CREATE_NEWSPC || - flags == THREAD_CREATE_COPYSPC) { - /* - * Allocate requested id if - * it's available, else a new one - */ - if ((ids->spid = id_get(space_id_pool, - ids->spid)) < 0) - ids->spid = id_new(space_id_pool); - - /* It also gets a thread group id */ - if ((ids->tgid = id_get(tgroup_id_pool, - ids->tgid)) < 0) - ids->tgid = id_new(tgroup_id_pool); - - } - - /* Set all ids */ - set_task_ids(new, ids); + /* Set up new thread's tid, spid, tgid according to flags */ + thread_setup_new_ids(ids, flags, new, task); /* Set task state. */ new->state = TASK_INACTIVE; @@ -198,7 +217,8 @@ out: * system call return environment so that it can safely * return as a copy of its original thread. */ - if (flags == THREAD_CREATE_COPYSPC) + if (flags == THREAD_CREATE_COPYSPC || + flags == THREAD_CREATE_SAMESPC) arch_setup_new_thread(new, task); /* Add task to global hlist of tasks */ @@ -231,6 +251,7 @@ int sys_thread_control(syscall_context_t *regs) case THREAD_RESUME: ret = thread_resume(ids); break; + /* TODO: THREAD_DESTROY! */ default: ret = -EINVAL; } diff --git a/tasks/libl4/include/l4lib/ipcdefs.h b/tasks/libl4/include/l4lib/ipcdefs.h index 1bd50ac..ce20974 100644 --- a/tasks/libl4/include/l4lib/ipcdefs.h +++ b/tasks/libl4/include/l4lib/ipcdefs.h @@ -46,6 +46,7 @@ #define L4_IPC_TAG_STAT 23 #define L4_IPC_TAG_FSTAT 24 #define L4_IPC_TAG_FSYNC 25 /* Pager notifies vfs of file close */ +#define L4_IPC_TAG_CLONE 26 /* Pager notifies vfs of file close */ /* Tags for ipc between fs0 and mm0 */ diff --git a/tasks/libl4/src/arm/syscalls.S b/tasks/libl4/src/arm/syscalls.S index e9fed92..fe92e1c 100644 --- a/tasks/libl4/src/arm/syscalls.S +++ b/tasks/libl4/src/arm/syscalls.S @@ -39,6 +39,48 @@ BEGIN_PROC(l4_kread) */ END_PROC(l4_kread) +/* + * For clone() we need special assembler handling + * Same signature as ipc(): @r0 = to, @r1 = from + * + * NOTE: MR_RETURN register is hardcoded here. + * It must be updated if MR_RETURN offset is changed! + */ +BEGIN_PROC(clone_asm) + stmfd sp!, {r4-r8,lr} @ Save context. + utcb_address r12 @ Get utcb address. + ldmia r12!, {r3-r8} @ Load 6 Message registers from utcb. MR0-MR5 + ldr r12, =__l4_ipc + mov lr, pc + ldr pc, [r12] @ Perform the ipc() + + /* + * At this moment: + * - MR_RETURN tells us whether we are parent or child (or have failed). + * - Child has new SP set, with |func_ptr|arg1|{End of stack}SP<-| on stack. + * - Child needs exit logic when its function is finished. + */ + cmp r0, #0 @ Check ipc success + blt ipc_failed + cmp r2, #0 @ Check ipc return register MR_RETURN. + blt clone_failed @ Ipc was ok but clone() failed. + bgt parent_return @ It has child pid, goto parent return. +child: + ldr r0, [sp, #-4]! @ Load child's first argument. + mov lr, pc @ Save return address + ldr pc, [sp, #-4]! @ Load function pointer from stack +child_exit: + b child_exit @ We infinitely loop for now. + + @ Return with normal ipc return sequence +parent_return: +clone_failed: +ipc_failed: + utcb_address r12 @ Get utcb + stmia r12, {r3-r8} @ Store mrs. + ldmfd sp!, {r4-r8,pc} @ Return restoring pc and context. +END_PROC(clone_asm) + /* * Inter-process communication. Loads message registers as arguments before the call, * and stores them as results after the call. @r0 = to, @r1 = from. diff --git a/tasks/libposix/fork.c b/tasks/libposix/fork.c index b532544..b05fc5d 100644 --- a/tasks/libposix/fork.c +++ b/tasks/libposix/fork.c @@ -47,3 +47,39 @@ int fork(void) return ret; } +extern int arch_clone(int, int); + +int clone(int (*fn)(void *), void *child_stack, int flags, void *arg, ...) +{ + /* Set up the child stack */ + unsigned int *stack = child_stack; + int ret; + + /* First word of new stack is arg */ + stack[-1] = (unsigned long)arg; + + /* Second word of new stack is function address */ + stack[-2] = (unsigned long)fn; + + /* Write the tag */ + l4_set_tag(L4_IPC_TAG_CLONE); + + /* Write the args as in usual ipc */ + write_mr(L4SYS_ARG0, flags); + write_mr(L4SYS_ARG1, (unsigned long)child_stack); + + /* Perform an ipc but with different return logic. See implementation. */ + if ((ret = arch_clone(PAGER_TID, PAGER_TID)) < 0) { + printf("%s: L4 IPC Error: %d.\n", __FUNCTION__, ret); + return ret; + } + + if ((ret = l4_get_retval()) < 0) { + printf("%s: CLONE Error: %d.\n", __FUNCTION__, ret); + return ret; + } + return ret; +} + + + diff --git a/tasks/mm0/main.c b/tasks/mm0/main.c index 5f8b865..61349ef 100644 --- a/tasks/mm0/main.c +++ b/tasks/mm0/main.c @@ -150,11 +150,16 @@ void handle_requests(void) } } +#if 0 +/* + * Executes the given function in a new thread in the current + * address space but on a brand new stack. + */ int self_spawn(void) { struct task_ids ids; struct tcb *self, *self_child; - // void *stack; + unsigned long stack, stack_size; BUG_ON(!(self = find_task(self_tid()))); @@ -166,6 +171,10 @@ int self_spawn(void) self_child = task_create(self, &ids, THREAD_CREATE_SAMESPC, TCB_SHARED_VM | TCB_SHARED_FILES); + if (IS_ERR(self_child = tcb_alloc_init(TCB_SHARED_VM + | TCB_SHARED_FILES))) + BUG(); + /* * Create a new utcb. Every pager thread will * need its own utcb to answer calls. @@ -176,24 +185,44 @@ int self_spawn(void) task_map_prefault_utcb(self_child, self_child); /* - * TODO: Set up a child stack by mmapping an anonymous - * region of mmap's choice. TODO: Time to add MAP_GROWSDOWN ??? + * Set up a child stack by mmapping an anonymous region. */ - if (do_mmap(0, 0, self, 0, - VM_READ | VM_WRITE | VMA_ANONYMOUS | VMA_PRIVATE, 1) < 0) + stack_size = self->stack_end - self->stack_start; + if (IS_ERR(stack = do_mmap(0, 0, self, 0, + VM_READ | VM_WRITE | VMA_ANONYMOUS + | VMA_PRIVATE | VMA_GROWSDOWN, + __pfn(stack_size)))) { + printf("%s: Error spawning %s, Error code: %d\n", + __FUNCTION__, __TASKNAME__, (int)stack); BUG(); + } - /* TODO: Notify vfs ??? */ + /* Modify stack marker of child tcb */ + self_child->stack_end = stack; + self_child->stack_start = stack - stack_size; + + /* Prefault child stack */ + for (int i = 0; i < __pfn(stack_size); i++) + prefault_page(self_child, + self_child->stack_start + __pfn_to_addr(i), + VM_READ | VM_WRITE); + + /* Copy current stack to child */ + memcpy((void *)self_child->stack_start, + (void *)self->stack_start, stack_size); /* TODO: Modify registers ???, it depends on what state is copied in C0 */ + /* TODO: Notify vfs ??? */ + task_add_global(self_child); + if (l4_thread_control(THREAD_CREATE | THREAD_CREATE_SAMESPC, ids) l4_thread_control(THREAD_RUN, &ids); return 0; } - +#endif void main(void) { diff --git a/tasks/mm0/src/clone.c b/tasks/mm0/src/clone.c index 317f288..7d7c63b 100755 --- a/tasks/mm0/src/clone.c +++ b/tasks/mm0/src/clone.c @@ -63,8 +63,11 @@ int do_fork(struct tcb *parent) * Create a new L4 thread with parent's page tables * kernel stack and kernel-side tcb copied */ - child = task_create(parent, &ids, THREAD_CREATE_COPYSPC, - TCB_NO_SHARING); + if (IS_ERR(child = task_create(parent, &ids, THREAD_CREATE_COPYSPC, + TCB_NO_SHARING))) { + l4_ipc_return((int)child); + return 0; + } /* Create new utcb for child since it can't use its parent's */ child->utcb = utcb_vaddr_new(); @@ -110,3 +113,66 @@ int sys_fork(l4id_t sender) return do_fork(parent); } + + +int sys_clone(l4id_t sender, void *child_stack, unsigned int flags) +{ + struct task_ids ids; + struct vm_file *utcb_shm; + struct tcb *parent, *child; + unsigned long stack, stack_size; + + BUG_ON(!(parent = find_task(sender))); + + ids.tid = TASK_ID_INVALID; + ids.spid = parent->spid; + ids.tgid = parent->tgid; + + if (IS_ERR(child = task_create(parent, &ids, THREAD_CREATE_SAMESPC, + TCB_SHARED_VM | TCB_SHARED_FILES))) { + l4_ipc_return((int)child); + return 0; + } + + /* Allocate a unique utcb address for child */ + child->utcb = utcb_vaddr_new(); + + /* + * Create the utcb shared memory segment + * available for child to shmat() + */ + if (IS_ERR(utcb_shm = shm_new((key_t)child->utcb, + __pfn(DEFAULT_UTCB_SIZE)))) { + l4_ipc_return((int)utcb_shm); + return 0; + } + + /* Map and prefault child's utcb to vfs task */ + task_map_prefault_utcb(find_task(VFS_TID), child); + + /* Set up child stack marks with given stack argument */ + child->stack_end = (unsigned long)child_stack; + child->stack_start = 0; + + /* We can now notify vfs about forked process */ + vfs_notify_fork(child, parent); + + /* Add child to global task list */ + task_add_global(child); + + printf("%s/%s: Starting forked child.\n", __TASKNAME__, __FUNCTION__); + /* Start forked child. */ + l4_thread_control(THREAD_RUN, &ids); + + /* Return back to parent */ + l4_ipc_return(child->tid); + + return 0; +} + + + + + + +