Changeset c98e6ee in mainline for kernel/generic/src

Timestamp:

2008-07-08T16:05:45Z (17 years ago)

Author:

Jiri Svoboda <jirik.svoboda@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f93f168

Parents:

b7f9087

Message:

Merge program-loader related stuff from dynload branch to trunk. (huge)

Location:

kernel/generic/src

Files:

• lib/elf.c (modified) (5 diffs)
• main/kinit.c (modified) (4 diffs)
• mm/as.c (modified) (2 diffs)
• proc/program.c (added)
• proc/task.c (modified) (3 diffs)
• proc/thread.c (modified) (1 diff)
• synch/smc.c (added)
• syscall/syscall.c (modified) (3 diffs)

kernel/generic/src/lib/elf.c

@@ -58 +58 @@
 
 static int segment_header(elf_segment_header_t *entry, elf_header_t *elf,
-    as_t *as);
+    as_t *as, int flags);
 static int section_header(elf_section_header_t *entry, elf_header_t *elf,
     as_t *as);
@@ -68 +68 @@
  * @param header Pointer to ELF header in memory
  * @param as Created and properly mapped address space
+ * @param flags A combination of ELD_F_*
  * @return EE_OK on success
  */
-unsigned int elf_load(elf_header_t *header, as_t * as)
+unsigned int elf_load(elf_header_t *header, as_t * as, int flags)
 {
         int i, rc;
@@ -111 +112 @@
                 seghdr = &((elf_segment_header_t *)(((uint8_t *) header) +
                     header->e_phoff))[i];
-                rc = segment_header(seghdr, header, as);
+                rc = segment_header(seghdr, header, as, flags);
                 if (rc != EE_OK)
                         return rc;
@@ -152 +153 @@
  */
 static int segment_header(elf_segment_header_t *entry, elf_header_t *elf,
-    as_t *as)
-{
+    as_t *as, int flags)
+{
+        char *interp;
+
         switch (entry->p_type) {
         case PT_NULL:
@@ -163 +166 @@
         case PT_DYNAMIC:
         case PT_INTERP:
+                interp = (char *)elf + entry->p_offset;
+                /* FIXME */
+                /*if (memcmp((uintptr_t)interp, (uintptr_t)ELF_INTERP_ZSTR,
+                    ELF_INTERP_ZLEN) != 0) {
+                        return EE_UNSUPPORTED;
+                }*/
+                if ((flags & ELD_F_LOADER) == 0) {
+                        return EE_LOADER;
+                }
+                break;
         case PT_SHLIB:
         case PT_NOTE:

kernel/generic/src/main/kinit.c

@@ -48 +48 @@
 #include <proc/task.h>
 #include <proc/thread.h>
+#include <proc/program.h>
 #include <panic.h>
 #include <func.h>
@@ -160 +161 @@
          */
         count_t i;
-        thread_t *threads[CONFIG_INIT_TASKS];
+        program_t programs[CONFIG_INIT_TASKS];
         
         for (i = 0; i < init.cnt; i++) {
@@ -168 +169 @@
                 }
 
-                threads[i] = thread_create_program((void *) init.tasks[i].addr,
-                    "uspace");
-                
-                if (threads[i] != NULL) {
+                int rc = program_create_from_image((void *) init.tasks[i].addr,
+                    &programs[i]);
+
+                if (rc == 0 && programs[i].task != NULL) {
                         /*
                          * Set capabilities to init userspace tasks.
                          */
-                        cap_set(threads[i]->task, CAP_CAP | CAP_MEM_MANAGER |
+                        cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
                             CAP_IO_MANAGER | CAP_PREEMPT_CONTROL | CAP_IRQ_REG);
+
                         
                         if (!ipc_phone_0)
-                                ipc_phone_0 = &threads[i]->task->answerbox;
+                                ipc_phone_0 = &programs[i].task->answerbox;
+                } else if (rc == 0) {
+                        /* It was the program loader and was registered */
                 } else {
+                        /* RAM disk image */
                         int rd = init_rd((rd_header_t *) init.tasks[i].addr,
                             init.tasks[i].size);
@@ -194 +199 @@
          */
         for (i = 0; i < init.cnt; i++) {
-                if (threads[i] != NULL) {
+                if (programs[i].task != NULL) {
                         thread_usleep(50000);
-                        thread_ready(threads[i]);
+                        program_ready(&programs[i]);
                 }
         }

kernel/generic/src/mm/as.c

@@ -772 +772 @@
 }
 
+/** Change adress area flags.
+ *
+ * The idea is to have the same data, but with a different access mode.
+ * This is needed e.g. for writing code into memory and then executing it.
+ * In order for this to work properly, this may copy the data
+ * into private anonymous memory (unless it's already there).
+ *
+ * @param as Address space.
+ * @param flags Flags of the area memory.
+ * @param address Address withing the area to be changed.
+ *
+ * @return Zero on success or a value from @ref errno.h on failure. 
+ */
+int as_area_change_flags(as_t *as, int flags, uintptr_t address)
+{
+        as_area_t *area;
+        uintptr_t base;
+        link_t *cur;
+        ipl_t ipl;
+        int page_flags;
+        uintptr_t *old_frame;
+        index_t frame_idx;
+        count_t used_pages;
+
+        /* Flags for the new memory mapping */
+        page_flags = area_flags_to_page_flags(flags);
+
+        ipl = interrupts_disable();
+        mutex_lock(&as->lock);
+
+        area = find_area_and_lock(as, address);
+        if (!area) {
+                mutex_unlock(&as->lock);
+                interrupts_restore(ipl);
+                return ENOENT;
+        }
+
+        if (area->sh_info || area->backend != &anon_backend) {
+                /* Copying shared areas not supported yet */
+                /* Copying non-anonymous memory not supported yet */
+                mutex_unlock(&area->lock);
+                mutex_unlock(&as->lock);
+                interrupts_restore(ipl);
+                return ENOTSUP;
+        }
+
+        base = area->base;
+
+        /*
+         * Compute total number of used pages in the used_space B+tree
+         */
+        used_pages = 0;
+
+        for (cur = area->used_space.leaf_head.next;
+            cur != &area->used_space.leaf_head; cur = cur->next) {
+                btree_node_t *node;
+                unsigned int i;
+                
+                node = list_get_instance(cur, btree_node_t, leaf_link);
+                for (i = 0; i < node->keys; i++) {
+                        used_pages += (count_t) node->value[i];
+                }
+        }
+
+        /* An array for storing frame numbers */
+        old_frame = malloc(used_pages * sizeof(uintptr_t), 0);
+
+        /*
+         * Start TLB shootdown sequence.
+         */
+        tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base, area->pages);
+
+        /*
+         * Remove used pages from page tables and remember their frame
+         * numbers.
+         */
+        frame_idx = 0;
+
+        for (cur = area->used_space.leaf_head.next;
+            cur != &area->used_space.leaf_head; cur = cur->next) {
+                btree_node_t *node;
+                unsigned int i;
+                
+                node = list_get_instance(cur, btree_node_t, leaf_link);
+                for (i = 0; i < node->keys; i++) {
+                        uintptr_t b = node->key[i];
+                        count_t j;
+                        pte_t *pte;
+                        
+                        for (j = 0; j < (count_t) node->value[i]; j++) {
+                                page_table_lock(as, false);
+                                pte = page_mapping_find(as, b + j * PAGE_SIZE);
+                                ASSERT(pte && PTE_VALID(pte) &&
+                                    PTE_PRESENT(pte));
+                                old_frame[frame_idx++] = PTE_GET_FRAME(pte);
+
+                                /* Remove old mapping */
+                                page_mapping_remove(as, b + j * PAGE_SIZE);
+                                page_table_unlock(as, false);
+                        }
+                }
+        }
+
+        /*
+         * Finish TLB shootdown sequence.
+         */
+
+        tlb_invalidate_pages(as->asid, area->base, area->pages);
+        /*
+         * Invalidate potential software translation caches (e.g. TSB on
+         * sparc64).
+         */
+        as_invalidate_translation_cache(as, area->base, area->pages);
+        tlb_shootdown_finalize();
+
+        /*
+         * Map pages back in with new flags. This step is kept separate
+         * so that there's no instant when the memory area could be
+         * accesed with both the old and the new flags at once.
+         */
+        frame_idx = 0;
+
+        for (cur = area->used_space.leaf_head.next;
+            cur != &area->used_space.leaf_head; cur = cur->next) {
+                btree_node_t *node;
+                unsigned int i;
+                
+                node = list_get_instance(cur, btree_node_t, leaf_link);
+                for (i = 0; i < node->keys; i++) {
+                        uintptr_t b = node->key[i];
+                        count_t j;
+                        
+                        for (j = 0; j < (count_t) node->value[i]; j++) {
+                                page_table_lock(as, false);
+
+                                /* Insert the new mapping */
+                                page_mapping_insert(as, b + j * PAGE_SIZE,
+                                    old_frame[frame_idx++], page_flags);
+
+                                page_table_unlock(as, false);
+                        }
+                }
+        }
+
+        free(old_frame);
+
+        mutex_unlock(&area->lock);
+        mutex_unlock(&as->lock);
+        interrupts_restore(ipl);
+
+        return 0;
+}
+
+
 /** Handle page fault within the current address space.
  *
@@ -1767 +1921 @@
 }
 
+/** Wrapper for as_area_change_flags(). */
+unative_t sys_as_area_change_flags(uintptr_t address, int flags)
+{
+        return (unative_t) as_area_change_flags(AS, flags, address);
+}
+
 /** Wrapper for as_area_destroy(). */
 unative_t sys_as_area_destroy(uintptr_t address)

kernel/generic/src/proc/task.c

@@ -36 +36 @@
  */
 
-#include <main/uinit.h>
 #include <proc/thread.h>
 #include <proc/task.h>
-#include <proc/uarg.h>
 #include <mm/as.h>
 #include <mm/slab.h>
@@ -47 +45 @@
 #include <arch.h>
 #include <arch/barrier.h>
-#include <panic.h>
 #include <adt/avl.h>
 #include <adt/btree.h>
 #include <adt/list.h>
 #include <ipc/ipc.h>
-#include <security/cap.h>
-#include <memstr.h>
+#include <ipc/ipcrsc.h>
 #include <print.h>
-#include <lib/elf.h>
 #include <errno.h>
 #include <func.h>
 #include <syscall/copy.h>
-
-#ifndef LOADED_PROG_STACK_PAGES_NO
-#define LOADED_PROG_STACK_PAGES_NO 1
-#endif
 
 /** Spinlock protecting the tasks_tree AVL tree. */
@@ -252 +243 @@
 }
 
-unative_t sys_task_spawn(void *image, size_t size)
-{
-        void *kimage = malloc(size, 0);
-        if (kimage == NULL)
-                return ENOMEM;
-        
-        int rc = copy_from_uspace(kimage, image, size);
-        if (rc != EOK)
-                return rc;
-
-        /*
-         * Not very efficient and it would be better to call it on code only,
-         * but this whole function is a temporary hack anyway and one day it
-         * will go in favor of the userspace dynamic loader.
-         */
-        smc_coherence_block(kimage, size);
-        
-        uspace_arg_t *kernel_uarg;
-        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
-        if (kernel_uarg == NULL) {
-                free(kimage);
-                return ENOMEM;
-        }
-        
-        kernel_uarg->uspace_entry =
-            (void *) ((elf_header_t *) kimage)->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;
-        
-        as_t *as = as_create(0);
-        if (as == NULL) {
-                free(kernel_uarg);
-                free(kimage);
-                return ENOMEM;
-        }
-        
-        unsigned int erc = elf_load((elf_header_t *) kimage, as);
-        if (erc != EE_OK) {
-                as_destroy(as);
-                free(kernel_uarg);
-                free(kimage);
-                return ENOENT;
-        }
-        
-        as_area_t *area = as_area_create(as,
-            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
-            LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
-            AS_AREA_ATTR_NONE, &anon_backend, NULL);
-        if (area == NULL) {
-                as_destroy(as);
-                free(kernel_uarg);
-                free(kimage);
-                return ENOMEM;
-        }
-        
-        task_t *task = task_create(as, "app");
-        if (task == NULL) {
-                as_destroy(as);
-                free(kernel_uarg);
-                free(kimage);
-                return ENOENT;
-        }
-        
-        // FIXME: control the capabilities
-        cap_set(task, cap_get(TASK));
-        
-        thread_t *thread = thread_create(uinit, kernel_uarg, task,
-            THREAD_FLAG_USPACE, "user", false);
-        if (thread == NULL) {
-                task_destroy(task);
-                as_destroy(as);
-                free(kernel_uarg);
-                free(kimage);
-                return ENOENT;
-        }
-        
-        thread_ready(thread);
-        
-        return EOK;
-}
-
 /** Find task structure corresponding to task ID.
  *

kernel/generic/src/proc/thread.c

@@ -673 +673 @@
 }
 
-
-/** Create new user task with 1 thread from image
- *
- * @param program_addr Address of program executable image.
- * @param name Program name.
- *
- * @return Initialized main thread of the task or NULL on error.
- */
-thread_t *thread_create_program(void *program_addr, char *name)
-{
-        as_t *as;
-        as_area_t *area;
-        unsigned int rc;
-        task_t *task;
-        uspace_arg_t *kernel_uarg;
-        
-        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
-        if (kernel_uarg == NULL)
-                return NULL;
-        
-        kernel_uarg->uspace_entry =
-            (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;
-
-        as = as_create(0);
-        if (as == NULL) {
-                free(kernel_uarg);
-                return NULL;
-        }
-
-        rc = elf_load((elf_header_t *) program_addr, as);
-        if (rc != EE_OK) {
-                free(kernel_uarg);
-                as_destroy(as);
-                return NULL;
-        }
-        
-        /*
-         * Create the data as_area.
-         */
-        area = as_area_create(as,
-                AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
-                LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
-                AS_AREA_ATTR_NONE, &anon_backend, NULL);
-        if (area == NULL) {
-                free(kernel_uarg);
-                as_destroy(as);
-                return NULL;
-        } 
-        
-        task = task_create(as, name);
-        if (task == NULL) {
-                free(kernel_uarg);
-                as_destroy(as);
-                return NULL;
-        }
-        
-        /*
-         * Create the main thread.
-         */
-        return thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,
-            "uinit", false);
-}
-
-
 /** Update accounting of current thread.
  *

kernel/generic/src/syscall/syscall.c

@@ -39 +39 @@
 #include <proc/thread.h>
 #include <proc/task.h>
+#include <proc/program.h>
 #include <mm/as.h>
 #include <print.h>
@@ -47 +48 @@
 #include <ipc/sysipc.h>
 #include <synch/futex.h>
+#include <synch/smc.h>
 #include <ddi/ddi.h>
 #include <security/cap.h>
@@ -124 +126 @@
         
         (syshandler_t) sys_task_get_id,
-        (syshandler_t) sys_task_spawn,
+        (syshandler_t) sys_program_spawn_loader,
         
         /* Synchronization related syscalls. */
         (syshandler_t) sys_futex_sleep_timeout,
         (syshandler_t) sys_futex_wakeup,
+        (syshandler_t) sys_smc_coherence,
         
         /* Address space related syscalls. */
         (syshandler_t) sys_as_area_create,
         (syshandler_t) sys_as_area_resize,
+        (syshandler_t) sys_as_area_change_flags,
         (syshandler_t) sys_as_area_destroy,