Function exec_inner

crates/stdlib/src/posixsubprocess.rs:274–404

(
    args: &ForkExecArgs<'_>,
    procargs: ProcArgs<'_>,
    ctx: &mut ExecErrorContext,
    vm: &VirtualMachine,
)

}

fn exec_inner(
    args: &ForkExecArgs<'_>,
    procargs: ProcArgs<'_>,
    ctx: &mut ExecErrorContext,
    vm: &VirtualMachine,
) -> nix::Result<Never> {
    for &fd in args.fds_to_keep.as_slice() {
        if fd.as_raw_fd() != args.errpipe_write.as_raw_fd() {
            posix::set_inheritable(fd, true)?
        }
    }

    for &fd in &[args.p2cwrite, args.c2pread, args.errread] {
        if let MaybeFd::Valid(fd) = fd {
            unistd::close(fd)?;
        }
    }
    unistd::close(args.errpipe_read)?;

    let c2pwrite = match args.c2pwrite {
        MaybeFd::Valid(c2pwrite) if c2pwrite.as_raw_fd() == 0 => {
            let fd = unistd::dup(c2pwrite)?;
            posix::set_inheritable(fd.as_fd(), true)?;
            MaybeFd::Valid(fd.into())
        }
        fd => fd,
    };

    let mut errwrite = args.errwrite;
    loop {
        match errwrite {
            MaybeFd::Valid(fd) if fd.as_raw_fd() == 0 || fd.as_raw_fd() == 1 => {
                let fd = unistd::dup(fd)?;
                posix::set_inheritable(fd.as_fd(), true)?;
                errwrite = MaybeFd::Valid(fd.into());
            }
            _ => break,
        }
    }

    fn dup_into_stdio<F>(fd: MaybeFd, io_fd: i32, dup2_stdio: F) -> nix::Result<()>
    where
        F: Fn(Fd) -> nix::Result<()>,
    {
        match fd {
            MaybeFd::Valid(fd) if fd.as_raw_fd() == io_fd => {
                posix::set_inheritable(fd.as_fd(), true)
            }
            MaybeFd::Valid(fd) => dup2_stdio(fd),
            MaybeFd::Invalid => Ok(()),
        }
    }
    dup_into_stdio(args.p2cread, 0, unistd::dup2_stdin)?;
    dup_into_stdio(c2pwrite, 1, unistd::dup2_stdout)?;
    dup_into_stdio(errwrite, 2, unistd::dup2_stderr)?;

    if let Some(ref cwd) = args.cwd {
        unistd::chdir(cwd.s.as_c_str()).inspect_err(|_| *ctx = ExecErrorContext::ChDir)?