WebSVN – HelenOS – Diff – /branches/dynload/kernel/generic/src/proc/task.c

  */
 avltree_t tasks_tree;
 static task_id_t task_counter = 0;
+/**
+ * Points to the binary image used as the program loader. All non-initial
+ * tasks are created from this executable image.
+ */
+void *program_loader = NULL;
 /** Initialize tasks
+ *
  * Initialize kernel tasks support.
+ *
  */
     TASK = NULL;
+}
 /** Create new task with 1 thread and run it
+ *
+ * @param as Address space containing a binary program image.
- * @param program_addr Address of program executable image.
+ * @param entry_addr Program entry-point address in program address space.
  * @param name Program name.
+ *
  * @return Task of the running program or NULL on error.
  */
-task_t *task_run_program(void *program_addr, char *name)
+task_t *task_create_from_as(as_t *as, uintptr_t entry_addr, char *name)
+{
-    as_t *as;
     as_area_t *a;
-    unsigned int rc;
     thread_t *t;
     task_t *task;
     uspace_arg_t *kernel_uarg;
-    as = as_create(0);
-    ASSERT(as);
-    rc = elf_load((elf_header_t *) program_addr, as);
-    if (rc != EE_OK) {
-        as_destroy(as);
-        return NULL;
-    }
     kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
-    kernel_uarg->uspace_entry =
+    kernel_uarg->uspace_entry = (void *) entry_addr;
-        (void *) ((elf_header_t *) program_addr)->e_entry;
     kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
     kernel_uarg->uspace_thread_function = NULL;
     kernel_uarg->uspace_thread_arg = NULL;
     kernel_uarg->uspace_uarg = NULL;
      */
     t = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,
         "uinit", false);
     ASSERT(t);
-    thread_ready(t);
     return task;
+}
+/** Parse an executable image in the physical memory.
+ *
+ * If the image belongs to a program loader, it is registered as such,
+ * (and *task is set to NULL). Otherwise a task is created from the
+ * executable image. The task is returned in *task.
+ *
+ * @param program_addr Address of program executable image.
+ * @param name Program name.
+ * @param task Where to store the pointer to the newly created task.
+ *
+ * @return EOK on success or negative error code.
+ */
+int task_parse_initial(void *program_addr, char *name, task_t **task)
+{
+    as_t *as;
+    unsigned int rc;
+    as = as_create(0);
+    ASSERT(as);
+    rc = elf_load((elf_header_t *) program_addr, as, 0);
+    if (rc != EE_OK) {
+        as_destroy(as);
+        *task = NULL;
+        if (rc != EE_LOADER)
+            return ENOTSUP;
+        /* Register image as the program loader */
+        ASSERT(program_loader == NULL);
+        program_loader = program_addr;
+        return EOK;
+    }
+    *task = task_create_from_as(as, ((elf_header_t *) program_addr)->e_entry,
+        name);
+    return EOK;
+}
+/** Create a task from the program loader image.
+ *
+ * @param program_addr Address of program executable image.
+ * @param name Program name.
+ *
+ * @return Task of the running program or NULL on error.
+ */
+task_t *task_create_from_loader(char *name)
+{
+    as_t *as;
+    unsigned int rc;
+    as = as_create(0);
+    ASSERT(as);
+    rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
+    if (rc != EE_OK) {
+        as_destroy(as);
+        return NULL;
+    }
+    return task_create_from_as(
+        as, ((elf_header_t *) program_loader)->e_entry, name);
+}
+/** Make task ready.
+ *
+ * Switch task's thread to the ready state.
+ *
+ * @param ta Task to make ready.
+ */
+void task_ready(task_t *t)
+{
+    thread_t *th;
+    th = list_get_instance(t->th_head.next, thread_t, th_link);
+    thread_ready(th);
+}
 /** Syscall for reading task ID from userspace.
+ *
  * @param uspace_task_id Userspace address of 8-byte buffer where to store
  * current task ID.
+ *
      */
     return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
         sizeof(TASK->taskid));
+}
+/** Syscall for creating a new task from userspace.
+ *
+ * Creates a new task from the program loader image and stores its
+ * task id into the provided buffer.
+ *
+ * @param uspace_task_id Userspace address of 8-byte buffer where to store
+ * current task ID.
+ *
+ * @return 0 on success or an error code from @ref errno.h.
+ */
+unative_t sys_task_spawn(task_id_t *uspace_task_id)
+{
+    task_t *t;
+    task_id_t fake_id;
+    int rc;
+    /* Before we even try creating the task, see if we can write the id */
+    rc = (unative_t) copy_to_uspace(uspace_task_id, &fake_id,
+        sizeof(fake_id));
+    if (rc != 0)
+        return rc;
+    t = task_create_from_loader("loader");
+    /* No need to aquire lock before task_ready() */
+    rc = (unative_t) copy_to_uspace(uspace_task_id, &t->taskid,
+        sizeof(t->taskid));
+    if (rc != 0) {
+        /* Ooops */
+        task_kill(t->taskid);
+        return rc;
+    }
+    task_ready(t);
+    return EOK;
+}
 /** Find task structure corresponding to task ID.
+ *
  * The tasks_lock must be already held by the caller of this function
  * and interrupts must be disabled.
+ *

Subversion Repositories HelenOS

(root)/branches/dynload/kernel/generic/src/proc/task.c – Rev 2927 → 3001