Cleanup elf loader, print more useful error messages

Author: jackpot51

kernel/arch/context.rs

@@ -161,8 +161,9 @@ pub unsafe fn context_switch(interrupted: bool) {
 }
 
 /// Clone context
-///
+/// # Safety
 /// Unsafe due to interrupt disabling, C memory handling, and raw pointers
+#[cfg(target_arch="x86")]
 pub unsafe extern "cdecl" fn context_clone(parent_ptr: *const Context,
                                            flags: usize,
                                            clone_pid: usize) {
@@ -262,6 +263,110 @@ pub unsafe extern "cdecl" fn context_clone(parent_ptr: *const Context,
     do_sys_exit(0);
 }
 
+/// Clone context
+/// # Safety
+/// Unsafe due to interrupt disabling, C memory handling, and raw pointers
+#[cfg(target_arch="x86_64")]
+pub unsafe extern "cdecl" fn context_clone(/*Throw away extra params from ABI*/_rdi: usize, _rsi: usize, _rdx: usize, _rcx: usize, _r8: usize, _r9: usize,
+                                           parent_ptr: *const Context,
+                                           flags: usize,
+                                           clone_pid: usize) {
+    {
+        let mut contexts = ::env().contexts.lock();
+
+        let kernel_stack = memory::alloc(CONTEXT_STACK_SIZE + 512);
+        if kernel_stack > 0 {
+            let parent = &*parent_ptr;
+
+            ::memcpy(kernel_stack as *mut u8,
+                     parent.kernel_stack as *const u8,
+                     CONTEXT_STACK_SIZE + 512);
+
+            let context = box Context {
+                pid: clone_pid,
+                ppid: parent.pid,
+                name: parent.name.clone(),
+                interrupted: parent.interrupted,
+                exited: parent.exited,
+                slices: CONTEXT_SLICES,
+                slice_total: 0,
+
+                kernel_stack: kernel_stack,
+                sp: parent.sp - parent.kernel_stack + kernel_stack,
+                flags: parent.flags,
+                fx: kernel_stack + CONTEXT_STACK_SIZE,
+                stack: if let Some(ref entry) = parent.stack {
+                    let physical_address = memory::alloc(entry.virtual_size);
+                    if physical_address > 0 {
+                        ::memcpy(physical_address as *mut u8,
+                                 entry.physical_address as *const u8,
+                                 entry.virtual_size);
+                        Some(ContextMemory {
+                            physical_address: physical_address,
+                            virtual_address: entry.virtual_address,
+                            virtual_size: entry.virtual_size,
+                            writeable: entry.writeable,
+                            allocated: true,
+                        })
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                },
+                loadable: parent.loadable,
+
+                cwd: if flags & CLONE_FS == CLONE_FS {
+                    parent.cwd.clone()
+                } else {
+                    Arc::new(UnsafeCell::new((*parent.cwd.get()).clone()))
+                },
+                memory: if flags & CLONE_VM == CLONE_VM {
+                    parent.memory.clone()
+                } else {
+                    let mut mem: Vec<ContextMemory> = Vec::new();
+                    for entry in (*parent.memory.get()).iter() {
+                        let physical_address = memory::alloc(entry.virtual_size);
+                        if physical_address > 0 {
+                            ::memcpy(physical_address as *mut u8,
+                                     entry.physical_address as *const u8,
+                                     entry.virtual_size);
+                            mem.push(ContextMemory {
+                                physical_address: physical_address,
+                                virtual_address: entry.virtual_address,
+                                virtual_size: entry.virtual_size,
+                                writeable: entry.writeable,
+                                allocated: true,
+                            });
+                        }
+                    }
+                    Arc::new(UnsafeCell::new(mem))
+                },
+                files: if flags & CLONE_FILES == CLONE_FILES {
+                    parent.files.clone()
+                } else {
+                    let mut files: Vec<ContextFile> = Vec::new();
+                    for file in (*parent.files.get()).iter() {
+                        if let Ok(resource) = file.resource.dup() {
+                            files.push(ContextFile {
+                                fd: file.fd,
+                                resource: resource,
+                            });
+                        }
+                    }
+                    Arc::new(UnsafeCell::new(files))
+                },
+
+                statuses: Vec::new(),
+            };
+
+            contexts.push(context);
+        }
+    }
+
+    do_sys_exit(0);
+}
+
 // Must have absolutely no pushes or pops
 #[cfg(target_arch = "x86")]
 #[allow(unused_variables)]
@@ -282,7 +387,8 @@ pub unsafe extern "cdecl" fn context_userspace(ip: usize,
 // Must have absolutely no pushes or pops
 #[cfg(target_arch = "x86_64")]
 #[allow(unused_variables)]
-pub unsafe extern "cdecl" fn context_userspace(ip: usize,
+pub unsafe extern "cdecl" fn context_userspace(/*Throw away extra params from ABI*/ _rdi: usize, _rsi: usize, _rdx: usize, _rcx: usize, _r8: usize, _r9: usize,
+                                               ip: usize,
                                                cs: usize,
                                                flags: usize,
                                                sp: usize,
@@ -296,9 +402,22 @@ pub unsafe extern "cdecl" fn context_userspace(ip: usize,
 }
 
 /// Reads a Boxed function and executes it
-///
+/// # Safety
+/// Unsafe due to raw memory handling and FnBox
+#[cfg(target_arch="x86")]
+unsafe extern "cdecl" fn context_box(box_fn_ptr: usize) {
+    let box_fn = ptr::read(box_fn_ptr as *mut Box<FnBox()>);
+    memory::unalloc(box_fn_ptr);
+    box_fn();
+    do_sys_exit(0);
+}
+
+/// Reads a Boxed function and executes it
+/// # Safety
 /// Unsafe due to raw memory handling and FnBox
-pub unsafe extern "cdecl" fn context_box(box_fn_ptr: usize) {
+#[cfg(target_arch="x86_64")]
+unsafe extern "cdecl" fn context_box(/*Throw away extra params from ABI*/ _rdi: usize, _rsi: usize, _rdx: usize, _rcx: usize, _r8: usize, _r9: usize,
+                                    box_fn_ptr: usize) {
     let box_fn = ptr::read(box_fn_ptr as *mut Box<FnBox()>);
     memory::unalloc(box_fn_ptr);
     box_fn();