Function sys_exec

kernel/src/syscalls.rs:582–796

Create a new process # Input - Pointer to ELF binary data (Arg1, syscall RDI) - Length of ELF binary data (high 32 bits of syscall_id) - STDIN & STDOUT rendezvous handles (Arg2, syscall RSI) - Pointer to parameter string (Arg3, syscall RDX) - Length of parameter string (16 bits of syscall_id) - Flags controlling permissions (8 bits of syscall_id) - I/O privileges: EXEC_PERM_IO - Thread fork? -

(
    context_ptr: *mut Context,
    syscall_id: u64,
    bin: *const u8, // Binary data (ELF format)
    stdio: u64, // The stdin/stdout rendezvous handles
    param: *const u8)

///    - Exec?
///    - Interrupts
fn sys_exec(
    context_ptr: *mut Context,
    syscall_id: u64,
    bin: *const u8, // Binary data (ELF format)
    stdio: u64, // The stdin/stdout rendezvous handles
    param: *const u8) { // String specifying the process VFS, command-line arguments, and environment variales

    let context = unsafe {&mut (*context_ptr)};

    // Low 8 bits of syscall_id contain syscall number
    // Remaining 48 bits are used to store the length
    // of the bin and param parameters, and the
    // capability flags.
    let bin_length = syscall_id >> 32; // High 32 bits
    let param_length = (syscall_id >> 16) & 0xFFFF;
    let flags = (syscall_id >> 8) & 0xFF;

    // Handles
    let stdin_handle = (stdio >> 32) & 0xFFFF_FFFF; // High 32 bits
    let stdout_handle = stdio & 0xFFFF_FFFF; // Low 32 bits

    if let Some(mut thread) = process::take_current_thread() {
        thread.set_context(context_ptr);

        if bin_length == 0 {
            // No data
            thread.return_error(SYSCALL_ERROR_PARAM);
            process::set_current_thread(thread);
            return;
        }

        // Get the Rendezvous handles for stdin & stdout
        let stdin = if let Some(rdv) = thread.take_rendezvous(stdin_handle) {
            rdv
        } else {
            // Invalid handle
            thread.return_error(SYSCALL_ERROR_INVALID_HANDLE);
            process::set_current_thread(thread);
            return;
        };

        let stdout = if let Some(rdv) = thread.take_rendezvous(stdout_handle) {
            rdv
        } else {
            // Invalid handle
            thread.return_error(SYSCALL_ERROR_INVALID_HANDLE);
            process::set_current_thread(thread);
            return;
        };

        // Check I/O privileges. Caller must have I/O privileges
        let io_privileges = (flags & EXEC_PERM_IO == EXEC_PERM_IO) &&
            ((context.rflags & 0x3000) == 0x3000);

        // Get the arguments and VFS for this process

        let (mounts, args, envs) = if param_length == 0 {
            // Default is shared VFS and no arguments