Method execute

src/execution/mod.rs:247–293

(
        &self,
        binary: &Path,
        extra_args: Vec<S>,
        extra_envs: Vec<(S, S)>,
        current_dir: Option<PathBuf>,
        stderr: Option<Stdio>,
        enough_timeout: bool,

    }

    pub fn execute<S: AsRef<OsStr> + Debug>(
        &self,
        binary: &Path,
        extra_args: Vec<S>,
        extra_envs: Vec<(S, S)>,
        current_dir: Option<PathBuf>,
        stderr: Option<Stdio>,
        enough_timeout: bool,
    ) -> Result<Option<ProgramError>> {
        let mut child = self.spawn(
            binary,
            extra_args,
            extra_envs,
            current_dir,
            stderr,
            enough_timeout,
        );

        let timeout = if enough_timeout {
            crate::config::SANITIZATION_TIMEOUT + 1
        } else {
            crate::config::EXECUTION_TIMEOUT + 1
        };
        let timeout = Duration::from_secs(timeout + 3);
        let status_code = match child.wait_timeout(timeout)? {
            Some(status) => status,
            None => {
                child.kill()?;
                child.wait()?;
                return Ok(Some(ProgramError::Hang(format!(
                    "Execute hang!\n Cmd: {child:#?}"
                ))));
            }
        };

        if is_exit_normally(status_code.code()) {
            return Ok(None);
        }
        let mut err_msg = String::new();
        if let Some(childerr) = child.stderr.take() {
            err_msg = get_child_err(childerr);
        }
        if err_msg.contains("libFuzzer: timeout") {
            return Ok(Some(ProgramError::Hang(err_msg)));
        }
        Ok(Some(ProgramError::Execute(err_msg)))
    }

    pub fn execute_pool(&self, binary: &Path, corpus: &Path) -> Option<ProgramError> {
        let cpu_count = max_cpu_count();