summaryrefslogtreecommitdiffstats
path: root/library/std/src/os/unix/process.rs
diff options
context:
space:
mode:
Diffstat (limited to 'library/std/src/os/unix/process.rs')
-rw-r--r--library/std/src/os/unix/process.rs466
1 files changed, 466 insertions, 0 deletions
diff --git a/library/std/src/os/unix/process.rs b/library/std/src/os/unix/process.rs
new file mode 100644
index 000000000..09b2bfe39
--- /dev/null
+++ b/library/std/src/os/unix/process.rs
@@ -0,0 +1,466 @@
+//! Unix-specific extensions to primitives in the [`std::process`] module.
+//!
+//! [`std::process`]: crate::process
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::ffi::OsStr;
+use crate::io;
+use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
+use crate::process;
+use crate::sealed::Sealed;
+use crate::sys;
+use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
+
+#[cfg(not(any(target_os = "vxworks", target_os = "espidf", target_os = "horizon")))]
+type UserId = u32;
+#[cfg(not(any(target_os = "vxworks", target_os = "espidf", target_os = "horizon")))]
+type GroupId = u32;
+
+#[cfg(any(target_os = "vxworks", target_os = "espidf", target_os = "horizon"))]
+type UserId = u16;
+#[cfg(any(target_os = "vxworks", target_os = "espidf", target_os = "horizon"))]
+type GroupId = u16;
+
+/// Unix-specific extensions to the [`process::Command`] builder.
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait CommandExt: Sealed {
+ /// Sets the child process's user ID. This translates to a
+ /// `setuid` call in the child process. Failure in the `setuid`
+ /// call will cause the spawn to fail.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn uid(&mut self, id: UserId) -> &mut process::Command;
+
+ /// Similar to `uid`, but sets the group ID of the child process. This has
+ /// the same semantics as the `uid` field.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn gid(&mut self, id: GroupId) -> &mut process::Command;
+
+ /// Sets the supplementary group IDs for the calling process. Translates to
+ /// a `setgroups` call in the child process.
+ #[unstable(feature = "setgroups", issue = "90747")]
+ fn groups(&mut self, groups: &[GroupId]) -> &mut process::Command;
+
+ /// Schedules a closure to be run just before the `exec` function is
+ /// invoked.
+ ///
+ /// The closure is allowed to return an I/O error whose OS error code will
+ /// be communicated back to the parent and returned as an error from when
+ /// the spawn was requested.
+ ///
+ /// Multiple closures can be registered and they will be called in order of
+ /// their registration. If a closure returns `Err` then no further closures
+ /// will be called and the spawn operation will immediately return with a
+ /// failure.
+ ///
+ /// # Notes and Safety
+ ///
+ /// This closure will be run in the context of the child process after a
+ /// `fork`. This primarily means that any modifications made to memory on
+ /// behalf of this closure will **not** be visible to the parent process.
+ /// This is often a very constrained environment where normal operations
+ /// like `malloc`, accessing environment variables through [`std::env`]
+ /// or acquiring a mutex are not guaranteed to work (due to
+ /// other threads perhaps still running when the `fork` was run).
+ ///
+ /// For further details refer to the [POSIX fork() specification]
+ /// and the equivalent documentation for any targeted
+ /// platform, especially the requirements around *async-signal-safety*.
+ ///
+ /// This also means that all resources such as file descriptors and
+ /// memory-mapped regions got duplicated. It is your responsibility to make
+ /// sure that the closure does not violate library invariants by making
+ /// invalid use of these duplicates.
+ ///
+ /// Panicking in the closure is safe only if all the format arguments for the
+ /// panic message can be safely formatted; this is because although
+ /// `Command` calls [`std::panic::always_abort`](crate::panic::always_abort)
+ /// before calling the pre_exec hook, panic will still try to format the
+ /// panic message.
+ ///
+ /// When this closure is run, aspects such as the stdio file descriptors and
+ /// working directory have successfully been changed, so output to these
+ /// locations might not appear where intended.
+ ///
+ /// [POSIX fork() specification]:
+ /// https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html
+ /// [`std::env`]: mod@crate::env
+ #[stable(feature = "process_pre_exec", since = "1.34.0")]
+ unsafe fn pre_exec<F>(&mut self, f: F) -> &mut process::Command
+ where
+ F: FnMut() -> io::Result<()> + Send + Sync + 'static;
+
+ /// Schedules a closure to be run just before the `exec` function is
+ /// invoked.
+ ///
+ /// This method is stable and usable, but it should be unsafe. To fix
+ /// that, it got deprecated in favor of the unsafe [`pre_exec`].
+ ///
+ /// [`pre_exec`]: CommandExt::pre_exec
+ #[stable(feature = "process_exec", since = "1.15.0")]
+ #[deprecated(since = "1.37.0", note = "should be unsafe, use `pre_exec` instead")]
+ fn before_exec<F>(&mut self, f: F) -> &mut process::Command
+ where
+ F: FnMut() -> io::Result<()> + Send + Sync + 'static,
+ {
+ unsafe { self.pre_exec(f) }
+ }
+
+ /// Performs all the required setup by this `Command`, followed by calling
+ /// the `execvp` syscall.
+ ///
+ /// On success this function will not return, and otherwise it will return
+ /// an error indicating why the exec (or another part of the setup of the
+ /// `Command`) failed.
+ ///
+ /// `exec` not returning has the same implications as calling
+ /// [`process::exit`] – no destructors on the current stack or any other
+ /// thread’s stack will be run. Therefore, it is recommended to only call
+ /// `exec` at a point where it is fine to not run any destructors. Note,
+ /// that the `execvp` syscall independently guarantees that all memory is
+ /// freed and all file descriptors with the `CLOEXEC` option (set by default
+ /// on all file descriptors opened by the standard library) are closed.
+ ///
+ /// This function, unlike `spawn`, will **not** `fork` the process to create
+ /// a new child. Like spawn, however, the default behavior for the stdio
+ /// descriptors will be to inherited from the current process.
+ ///
+ /// # Notes
+ ///
+ /// The process may be in a "broken state" if this function returns in
+ /// error. For example the working directory, environment variables, signal
+ /// handling settings, various user/group information, or aspects of stdio
+ /// file descriptors may have changed. If a "transactional spawn" is
+ /// required to gracefully handle errors it is recommended to use the
+ /// cross-platform `spawn` instead.
+ #[stable(feature = "process_exec2", since = "1.9.0")]
+ fn exec(&mut self) -> io::Error;
+
+ /// Set executable argument
+ ///
+ /// Set the first process argument, `argv[0]`, to something other than the
+ /// default executable path.
+ #[stable(feature = "process_set_argv0", since = "1.45.0")]
+ fn arg0<S>(&mut self, arg: S) -> &mut process::Command
+ where
+ S: AsRef<OsStr>;
+
+ /// Sets the process group ID (PGID) of the child process. Equivalent to a
+ /// `setpgid` call in the child process, but may be more efficient.
+ ///
+ /// Process groups determine which processes receive signals.
+ ///
+ /// # Examples
+ ///
+ /// Pressing Ctrl-C in a terminal will send SIGINT to all processes in
+ /// the current foreground process group. By spawning the `sleep`
+ /// subprocess in a new process group, it will not receive SIGINT from the
+ /// terminal.
+ ///
+ /// The parent process could install a signal handler and manage the
+ /// subprocess on its own terms.
+ ///
+ /// A process group ID of 0 will use the process ID as the PGID.
+ ///
+ /// ```no_run
+ /// use std::process::Command;
+ /// use std::os::unix::process::CommandExt;
+ ///
+ /// Command::new("sleep")
+ /// .arg("10")
+ /// .process_group(0)
+ /// .spawn()?
+ /// .wait()?;
+ /// #
+ /// # Ok::<_, Box<dyn std::error::Error>>(())
+ /// ```
+ #[stable(feature = "process_set_process_group", since = "1.64.0")]
+ fn process_group(&mut self, pgroup: i32) -> &mut process::Command;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl CommandExt for process::Command {
+ fn uid(&mut self, id: UserId) -> &mut process::Command {
+ self.as_inner_mut().uid(id);
+ self
+ }
+
+ fn gid(&mut self, id: GroupId) -> &mut process::Command {
+ self.as_inner_mut().gid(id);
+ self
+ }
+
+ fn groups(&mut self, groups: &[GroupId]) -> &mut process::Command {
+ self.as_inner_mut().groups(groups);
+ self
+ }
+
+ unsafe fn pre_exec<F>(&mut self, f: F) -> &mut process::Command
+ where
+ F: FnMut() -> io::Result<()> + Send + Sync + 'static,
+ {
+ self.as_inner_mut().pre_exec(Box::new(f));
+ self
+ }
+
+ fn exec(&mut self) -> io::Error {
+ // NOTE: This may *not* be safe to call after `libc::fork`, because it
+ // may allocate. That may be worth fixing at some point in the future.
+ self.as_inner_mut().exec(sys::process::Stdio::Inherit)
+ }
+
+ fn arg0<S>(&mut self, arg: S) -> &mut process::Command
+ where
+ S: AsRef<OsStr>,
+ {
+ self.as_inner_mut().set_arg_0(arg.as_ref());
+ self
+ }
+
+ fn process_group(&mut self, pgroup: i32) -> &mut process::Command {
+ self.as_inner_mut().pgroup(pgroup);
+ self
+ }
+}
+
+/// Unix-specific extensions to [`process::ExitStatus`] and
+/// [`ExitStatusError`](process::ExitStatusError).
+///
+/// On Unix, `ExitStatus` **does not necessarily represent an exit status**, as
+/// passed to the `_exit` system call or returned by
+/// [`ExitStatus::code()`](crate::process::ExitStatus::code). It represents **any wait status**
+/// as returned by one of the `wait` family of system
+/// calls.
+///
+/// A Unix wait status (a Rust `ExitStatus`) can represent a Unix exit status, but can also
+/// represent other kinds of process event.
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait ExitStatusExt: Sealed {
+ /// Creates a new `ExitStatus` or `ExitStatusError` from the raw underlying integer status
+ /// value from `wait`
+ ///
+ /// The value should be a **wait status, not an exit status**.
+ ///
+ /// # Panics
+ ///
+ /// Panics on an attempt to make an `ExitStatusError` from a wait status of `0`.
+ ///
+ /// Making an `ExitStatus` always succeeds and never panics.
+ #[stable(feature = "exit_status_from", since = "1.12.0")]
+ fn from_raw(raw: i32) -> Self;
+
+ /// If the process was terminated by a signal, returns that signal.
+ ///
+ /// In other words, if `WIFSIGNALED`, this returns `WTERMSIG`.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn signal(&self) -> Option<i32>;
+
+ /// If the process was terminated by a signal, says whether it dumped core.
+ #[stable(feature = "unix_process_wait_more", since = "1.58.0")]
+ fn core_dumped(&self) -> bool;
+
+ /// If the process was stopped by a signal, returns that signal.
+ ///
+ /// In other words, if `WIFSTOPPED`, this returns `WSTOPSIG`. This is only possible if the status came from
+ /// a `wait` system call which was passed `WUNTRACED`, and was then converted into an `ExitStatus`.
+ #[stable(feature = "unix_process_wait_more", since = "1.58.0")]
+ fn stopped_signal(&self) -> Option<i32>;
+
+ /// Whether the process was continued from a stopped status.
+ ///
+ /// Ie, `WIFCONTINUED`. This is only possible if the status came from a `wait` system call
+ /// which was passed `WCONTINUED`, and was then converted into an `ExitStatus`.
+ #[stable(feature = "unix_process_wait_more", since = "1.58.0")]
+ fn continued(&self) -> bool;
+
+ /// Returns the underlying raw `wait` status.
+ ///
+ /// The returned integer is a **wait status, not an exit status**.
+ #[stable(feature = "unix_process_wait_more", since = "1.58.0")]
+ fn into_raw(self) -> i32;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl ExitStatusExt for process::ExitStatus {
+ fn from_raw(raw: i32) -> Self {
+ process::ExitStatus::from_inner(From::from(raw))
+ }
+
+ fn signal(&self) -> Option<i32> {
+ self.as_inner().signal()
+ }
+
+ fn core_dumped(&self) -> bool {
+ self.as_inner().core_dumped()
+ }
+
+ fn stopped_signal(&self) -> Option<i32> {
+ self.as_inner().stopped_signal()
+ }
+
+ fn continued(&self) -> bool {
+ self.as_inner().continued()
+ }
+
+ fn into_raw(self) -> i32 {
+ self.as_inner().into_raw().into()
+ }
+}
+
+#[unstable(feature = "exit_status_error", issue = "84908")]
+impl ExitStatusExt for process::ExitStatusError {
+ fn from_raw(raw: i32) -> Self {
+ process::ExitStatus::from_raw(raw)
+ .exit_ok()
+ .expect_err("<ExitStatusError as ExitStatusExt>::from_raw(0) but zero is not an error")
+ }
+
+ fn signal(&self) -> Option<i32> {
+ self.into_status().signal()
+ }
+
+ fn core_dumped(&self) -> bool {
+ self.into_status().core_dumped()
+ }
+
+ fn stopped_signal(&self) -> Option<i32> {
+ self.into_status().stopped_signal()
+ }
+
+ fn continued(&self) -> bool {
+ self.into_status().continued()
+ }
+
+ fn into_raw(self) -> i32 {
+ self.into_status().into_raw()
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl FromRawFd for process::Stdio {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> process::Stdio {
+ let fd = sys::fd::FileDesc::from_raw_fd(fd);
+ let io = sys::process::Stdio::Fd(fd);
+ process::Stdio::from_inner(io)
+ }
+}
+
+#[stable(feature = "io_safety", since = "1.63.0")]
+impl From<OwnedFd> for process::Stdio {
+ #[inline]
+ fn from(fd: OwnedFd) -> process::Stdio {
+ let fd = sys::fd::FileDesc::from_inner(fd);
+ let io = sys::process::Stdio::Fd(fd);
+ process::Stdio::from_inner(io)
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawFd for process::ChildStdin {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().as_raw_fd()
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawFd for process::ChildStdout {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().as_raw_fd()
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawFd for process::ChildStderr {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().as_raw_fd()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawFd for process::ChildStdin {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_inner().into_raw_fd()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawFd for process::ChildStdout {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_inner().into_raw_fd()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawFd for process::ChildStderr {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_inner().into_raw_fd()
+ }
+}
+
+#[stable(feature = "io_safety", since = "1.63.0")]
+impl AsFd for crate::process::ChildStdin {
+ #[inline]
+ fn as_fd(&self) -> BorrowedFd<'_> {
+ self.as_inner().as_fd()
+ }
+}
+
+#[stable(feature = "io_safety", since = "1.63.0")]
+impl From<crate::process::ChildStdin> for OwnedFd {
+ #[inline]
+ fn from(child_stdin: crate::process::ChildStdin) -> OwnedFd {
+ child_stdin.into_inner().into_inner().into_inner()
+ }
+}
+
+#[stable(feature = "io_safety", since = "1.63.0")]
+impl AsFd for crate::process::ChildStdout {
+ #[inline]
+ fn as_fd(&self) -> BorrowedFd<'_> {
+ self.as_inner().as_fd()
+ }
+}
+
+#[stable(feature = "io_safety", since = "1.63.0")]
+impl From<crate::process::ChildStdout> for OwnedFd {
+ #[inline]
+ fn from(child_stdout: crate::process::ChildStdout) -> OwnedFd {
+ child_stdout.into_inner().into_inner().into_inner()
+ }
+}
+
+#[stable(feature = "io_safety", since = "1.63.0")]
+impl AsFd for crate::process::ChildStderr {
+ #[inline]
+ fn as_fd(&self) -> BorrowedFd<'_> {
+ self.as_inner().as_fd()
+ }
+}
+
+#[stable(feature = "io_safety", since = "1.63.0")]
+impl From<crate::process::ChildStderr> for OwnedFd {
+ #[inline]
+ fn from(child_stderr: crate::process::ChildStderr) -> OwnedFd {
+ child_stderr.into_inner().into_inner().into_inner()
+ }
+}
+
+/// Returns the OS-assigned process identifier associated with this process's parent.
+#[must_use]
+#[stable(feature = "unix_ppid", since = "1.27.0")]
+pub fn parent_id() -> u32 {
+ crate::sys::os::getppid()
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-29 00:36:51 +0000