X-Git-Url: https://scm.lunaixsky.com/lunaix-os.git/blobdiff_plain/74926d2db1d9f3228acdfca03013a8ba0ac1d8c0..8c6f505faaa66e18cdca108dca549d4ad806a077:/lunaix-os/kernel/loader/exec.c?ds=sidebyside

diff --git a/lunaix-os/kernel/loader/exec.c b/lunaix-os/kernel/loader/exec.c
index 6c33495..331cacc 100644
--- a/lunaix-os/kernel/loader/exec.c
+++ b/lunaix-os/kernel/loader/exec.c
@@ -7,12 +7,18 @@
 #include <lunaix/spike.h>
 #include <lunaix/status.h>
 #include <lunaix/syscall.h>
+#include <lunaix/syscall_utils.h>
 
 #include <klibc/string.h>
 
 size_t
 exec_str_size(const char** str_arr, size_t* length)
 {
+    if (!str_arr) {
+        *length = 0;
+        return 0;
+    }
+
     const char* chr = *str_arr;
     size_t sz = 0, len = 0;
 
@@ -27,11 +33,43 @@ exec_str_size(const char** str_arr, size_t* length)
     return sz + 1;
 }
 
+void
+__heap_copied(struct mm_region* region)
+{
+    mm_index((void**)&region->proc_vms->heap, region);
+}
+
+int
+__exec_remap_heap(struct ld_param* param, struct proc_mm* pvms)
+{
+    if (pvms->heap) {
+        mem_unmap_region(param->vms_mnt, pvms->heap);
+    }
+
+    struct mmap_param map_param = { .pvms = pvms,
+                                    .vms_mnt = param->vms_mnt,
+                                    .flags = MAP_ANON | MAP_PRIVATE,
+                                    .type = REGION_TYPE_HEAP,
+                                    .proct = PROT_READ | PROT_WRITE,
+                                    .mlen = PG_SIZE };
+    int status = 0;
+    struct mm_region* heap;
+    if ((status = mem_map(NULL, &heap, param->info.end, NULL, &map_param))) {
+        param->status |= LD_STAT_FKUP;
+        return status;
+    }
+
+    heap->region_copied = __heap_copied;
+    mm_index((void**)&pvms->heap, heap);
+
+    return status;
+}
+
 int
-exec_loadto(struct ld_param* param,
-            struct v_file* executable,
-            const char** argv,
-            const char** envp)
+exec_load(struct ld_param* param,
+          struct v_file* executable,
+          const char** argv,
+          const char** envp)
 {
     int errno = 0;
 
@@ -49,57 +87,60 @@ exec_loadto(struct ld_param* param,
         goto done;
     }
 
-    struct mmap_param map_param = { .regions = &param->proc->mm.regions,
-                                    .vms_mnt = param->vms_mnt,
-                                    .flags = MAP_ANON | MAP_PRIVATE | MAP_FIXED,
-                                    .type = REGION_TYPE_VARS,
-                                    .proct = PROT_READ,
-                                    .length = MAX_VAR_PAGES * PG_SIZE };
+    struct proc_mm* pvms = &param->proc->mm;
+    struct mmap_param map_vars = { .pvms = pvms,
+                                   .vms_mnt = param->vms_mnt,
+                                   .flags = MAP_ANON | MAP_PRIVATE | MAP_FIXED,
+                                   .type = REGION_TYPE_VARS,
+                                   .proct = PROT_READ,
+                                   .mlen = MAX_VAR_PAGES * PG_SIZE };
 
     void* mapped;
-    isr_param* intr_ctx = &param->proc->intr_ctx;
 
-    // TODO reinitialize heap
+    if ((errno = __exec_remap_heap(param, pvms))) {
+        goto done;
+    }
+
+    if ((errno = mem_map(&mapped, NULL, UMMAP_END, NULL, &map_vars))) {
+        goto done;
+    }
 
     if (param->vms_mnt == VMS_SELF) {
         // we are loading executable into current addr space
-        if ((errno = mem_map(&mapped, NULL, UMMAP_END, NULL, &map_param))) {
-            goto done;
-        }
 
-        memcpy(mapped, (void*)argv, sz_argv);
-        memcpy(mapped + sz_argv, (void*)envp, sz_envp);
+        // make some handy infos available to user space
+        ptr_t arg_start = mapped + sizeof(struct usr_exec_param);
+        if (argv)
+            memcpy(arg_start, (void*)argv, sz_argv);
+        if (envp)
+            memcpy(arg_start + sz_argv, (void*)envp, sz_envp);
 
-        ptr_t* ustack = (void*)USTACK_TOP;
-        size_t* argc = &((size_t*)&ustack[-1])[-1];
+        ptr_t* ustack = (ptr_t*)USTACK_TOP;
+        struct usr_exec_param* exec_param = mapped;
 
         ustack[-1] = (ptr_t)mapped;
-        *argc = argv_len;
-
-        // TODO handle envp.
+        param->info.stack_top = &ustack[-1];
 
-        intr_ctx->esp = argc;
+        *exec_param = (struct usr_exec_param){ .argc = argv_len,
+                                               .argv = arg_start,
+                                               .envc = envp_len,
+                                               .envp = arg_start + sz_argv,
+                                               .info = param->info };
     } else {
         // TODO need to find a way to inject argv and envp remotely
         fail("not implemented");
     }
 
-    intr_ctx->eip = param->ehdr_out.e_entry;
-    // we will jump to new entry point upon syscall's return
-    // so execve will not return from the perspective of it's invoker
-
+    param->info.entry = param->info.ehdr_out.e_entry;
 done:
     return errno;
 }
 
-__DEFINE_LXSYSCALL3(int,
-                    execve,
-                    const char*,
-                    filename,
-                    const char*,
-                    argv[],
-                    const char*,
-                    envp[])
+int
+exec_load_byname(struct ld_param* param,
+                 const char* filename,
+                 const char** argv,
+                 const char** envp)
 {
     int errno = 0;
     struct v_dnode* dnode;
@@ -113,20 +154,44 @@ __DEFINE_LXSYSCALL3(int,
         goto done;
     }
 
+    if ((errno = exec_load(param, file, argv, envp))) {
+        vfs_pclose(file, __current->pid);
+    }
+
+done:
+    return errno;
+}
+
+__DEFINE_LXSYSCALL3(int,
+                    execve,
+                    const char*,
+                    filename,
+                    const char*,
+                    argv[],
+                    const char*,
+                    envp[])
+{
+    int errno = 0;
     struct ld_param ldparam;
     ld_create_param(&ldparam, __current, VMS_SELF);
 
-    if ((errno = exec_loadto(&ldparam, file, argv, envp))) {
-        vfs_pclose(file, __current->pid);
-
+    if ((errno = exec_load_byname(&ldparam, filename, argv, envp))) {
         if ((ldparam.status & LD_STAT_FKUP)) {
             // we fucked up our address space.
             terminate_proc(11451);
             schedule();
             fail("should not reach");
         }
+        goto done;
     }
 
+    volatile struct exec_param* execp = __current->intr_ctx.execp;
+    execp->esp = ldparam.info.stack_top;
+    execp->eip = ldparam.info.entry;
+
+    // we will jump to new entry point (_u_start) upon syscall's
+    // return so execve 'will not return' from the perspective of it's invoker
+
 done:
-    return errno;
+    return DO_STATUS(errno);
 }
\ No newline at end of file