// Copyright 2016 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use io; use libc::{self, size_t}; use mem; use ptr; use sys::process::zircon::{Handle, zx_handle_t}; use sys::process::process_common::*; //////////////////////////////////////////////////////////////////////////////// // Command //////////////////////////////////////////////////////////////////////////////// impl Command { pub fn spawn(&mut self, default: Stdio, needs_stdin: bool) -> io::Result<(Process, StdioPipes)> { let envp = self.capture_env(); if self.saw_nul() { return Err(io::Error::new(io::ErrorKind::InvalidInput, "nul byte found in provided data")); } let (ours, theirs) = self.setup_io(default, needs_stdin)?; let process_handle = unsafe { self.do_exec(theirs, envp.as_ref())? }; Ok((Process { handle: Handle::new(process_handle) }, ours)) } pub fn exec(&mut self, default: Stdio) -> io::Error { if self.saw_nul() { return io::Error::new(io::ErrorKind::InvalidInput, "nul byte found in provided data") } match self.setup_io(default, true) { Ok((_, _)) => { // FIXME: This is tough because we don't support the exec syscalls unimplemented!(); }, Err(e) => e, } } unsafe fn do_exec(&mut self, stdio: ChildPipes, maybe_envp: Option<&CStringArray>) -> io::Result { use sys::process::zircon::*; let job_handle = zx_job_default(); let envp = match maybe_envp { Some(envp) => envp.as_ptr(), None => ptr::null(), }; // To make sure launchpad_destroy gets called on the launchpad if this function fails struct LaunchpadDestructor(*mut launchpad_t); impl Drop for LaunchpadDestructor { fn drop(&mut self) { unsafe { launchpad_destroy(self.0); } } } // Duplicate the job handle let mut job_copy: zx_handle_t = ZX_HANDLE_INVALID; zx_cvt(zx_handle_duplicate(job_handle, ZX_RIGHT_SAME_RIGHTS, &mut job_copy))?; // Create a launchpad let mut launchpad: *mut launchpad_t = ptr::null_mut(); zx_cvt(launchpad_create(job_copy, self.get_argv()[0], &mut launchpad))?; let launchpad_destructor = LaunchpadDestructor(launchpad); // Set the process argv zx_cvt(launchpad_set_args(launchpad, self.get_argv().len() as i32 - 1, self.get_argv().as_ptr()))?; // Setup the environment vars zx_cvt(launchpad_set_environ(launchpad, envp))?; zx_cvt(launchpad_add_vdso_vmo(launchpad))?; // Load the executable zx_cvt(launchpad_elf_load(launchpad, launchpad_vmo_from_file(self.get_argv()[0])))?; zx_cvt(launchpad_load_vdso(launchpad, ZX_HANDLE_INVALID))?; zx_cvt(launchpad_clone(launchpad, LP_CLONE_FDIO_NAMESPACE | LP_CLONE_FDIO_CWD))?; // Clone stdin, stdout, and stderr if let Some(fd) = stdio.stdin.fd() { zx_cvt(launchpad_transfer_fd(launchpad, fd, 0))?; } else { zx_cvt(launchpad_clone_fd(launchpad, 0, 0))?; } if let Some(fd) = stdio.stdout.fd() { zx_cvt(launchpad_transfer_fd(launchpad, fd, 1))?; } else { zx_cvt(launchpad_clone_fd(launchpad, 1, 1))?; } if let Some(fd) = stdio.stderr.fd() { zx_cvt(launchpad_transfer_fd(launchpad, fd, 2))?; } else { zx_cvt(launchpad_clone_fd(launchpad, 2, 2))?; } // We don't want FileDesc::drop to be called on any stdio. It would close their fds. The // fds will be closed once the child process finishes. mem::forget(stdio); for callback in self.get_closures().iter_mut() { callback()?; } // `launchpad_go` destroys the launchpad, so we must not mem::forget(launchpad_destructor); let mut process_handle: zx_handle_t = 0; let mut err_msg: *const libc::c_char = ptr::null(); zx_cvt(launchpad_go(launchpad, &mut process_handle, &mut err_msg))?; // FIXME: See if we want to do something with that err_msg Ok(process_handle) } } //////////////////////////////////////////////////////////////////////////////// // Processes //////////////////////////////////////////////////////////////////////////////// pub struct Process { handle: Handle, } impl Process { pub fn id(&self) -> u32 { self.handle.raw() as u32 } pub fn kill(&mut self) -> io::Result<()> { use sys::process::zircon::*; unsafe { zx_cvt(zx_task_kill(self.handle.raw()))?; } Ok(()) } pub fn wait(&mut self) -> io::Result { use default::Default; use sys::process::zircon::*; let mut proc_info: zx_info_process_t = Default::default(); let mut actual: size_t = 0; let mut avail: size_t = 0; unsafe { zx_cvt(zx_object_wait_one(self.handle.raw(), ZX_TASK_TERMINATED, ZX_TIME_INFINITE, ptr::null_mut()))?; zx_cvt(zx_object_get_info(self.handle.raw(), ZX_INFO_PROCESS, &mut proc_info as *mut _ as *mut libc::c_void, mem::size_of::(), &mut actual, &mut avail))?; } if actual != 1 { return Err(io::Error::new(io::ErrorKind::InvalidData, "Failed to get exit status of process")); } Ok(ExitStatus::new(proc_info.rec.return_code)) } pub fn try_wait(&mut self) -> io::Result> { use default::Default; use sys::process::zircon::*; let mut proc_info: zx_info_process_t = Default::default(); let mut actual: size_t = 0; let mut avail: size_t = 0; unsafe { let status = zx_object_wait_one(self.handle.raw(), ZX_TASK_TERMINATED, 0, ptr::null_mut()); match status { 0 => { }, // Success x if x == ERR_TIMED_OUT => { return Ok(None); }, _ => { panic!("Failed to wait on process handle: {}", status); }, } zx_cvt(zx_object_get_info(self.handle.raw(), ZX_INFO_PROCESS, &mut proc_info as *mut _ as *mut libc::c_void, mem::size_of::(), &mut actual, &mut avail))?; } if actual != 1 { return Err(io::Error::new(io::ErrorKind::InvalidData, "Failed to get exit status of process")); } Ok(Some(ExitStatus::new(proc_info.rec.return_code))) } }