add process group extensions and PidFd

Author: hypengw

src/std/CMakeLists.txt

@@ -171,6 +171,10 @@ target_sources(
          src/os/handle.cppm
          src/os/socket.cppm
          src/os/unix/ffi.cppm
+         src/os/unix/process.cppm
+         src/os/linux/process.cppm
+         src/os/linux/pidfd.cppm
+         src/sys/process/linux.cppm
          src/os/windows/ffi.cppm
          src/sys/io/stdio.cppm
          src/sys/mod.cppm
@@ -280,6 +284,7 @@ target_sources(
           src/fs/mod.cpp
           src/env.cpp
           src/os/fd.cpp
+          src/os/linux/process.cpp
           src/os/handle.cpp
           src/os/socket.cpp
           ${rstd_std_platform_sources})

src/std/src/os/linux/pidfd.cppm

@@ -0,0 +1,56 @@
+module;
+#include <rstd/macro.hpp>
+export module rstd:os.linux.pidfd;
+export import :os.fd;
+export import :process.exit_status;
+export import :io.error;
+
+#if RSTD_OS_LINUX
+export namespace rstd::os::linux::process
+{
+
+/// An owned process descriptor. Destruction closes it without killing or reaping.
+class PidFd {
+    fd::OwnedFd descriptor_;
+    explicit PidFd(fd::OwnedFd descriptor): descriptor_(rstd::move(descriptor)) {}
+
+public:
+    PidFd(PidFd&&) noexcept                    = default;
+    auto operator=(PidFd&&) noexcept -> PidFd& = default;
+    auto as_raw_fd() const noexcept -> fd::RawFd { return descriptor_.as_raw_fd(); }
+    auto as_fd() const noexcept [[clang::lifetimebound]] -> fd::BorrowedFd {
+        return descriptor_.as_fd();
+    }
+    auto into_raw_fd() && noexcept -> fd::RawFd { return rstd::move(descriptor_).into_raw_fd(); }
+    static auto from_raw_fd(fd::RawFd descriptor) -> PidFd {
+        return PidFd(fd::OwnedFd::from_raw_fd(descriptor));
+    }
+    static auto from_owned_fd(fd::OwnedFd descriptor) -> PidFd {
+        return PidFd(rstd::move(descriptor));
+    }
+    auto into_owned_fd() && -> fd::OwnedFd { return rstd::move(descriptor_); }
+    auto kill() const -> io::Result<empty>;
+    /// Reaps without closing stdin. Repeated waits can fail on older kernels.
+    auto wait() const -> io::Result<rstd::process::ExitStatus>;
+    auto try_wait() const -> io::Result<Option<rstd::process::ExitStatus>>;
+};
+
+} // namespace rstd::os::linux::process
+
+namespace rstd
+{
+
+template<>
+struct Impl<os::fd::IntoRawFd, os::linux::process::PidFd> : ImplBase<os::linux::process::PidFd> {
+    auto into_raw_fd() noexcept -> os::fd::RawFd { return rstd::move(this->self()).into_raw_fd(); }
+};
+
+template<>
+struct Impl<os::fd::FromRawFd, os::linux::process::PidFd> {
+    static auto from_raw_fd(os::fd::RawFd fd) -> os::linux::process::PidFd {
+        return os::linux::process::PidFd::from_raw_fd(fd);
+    }
+};
+
+} // namespace rstd
+#endif

src/std/src/os/linux/process.cpp

@@ -0,0 +1,34 @@
+module;
+#include <rstd/macro.hpp>
+module rstd;
+#if RSTD_OS_LINUX
+import :sys.process.linux;
+import :sys.libc;
+
+using namespace rstd::prelude;
+
+auto pidfd_status(int fd, bool nonblocking) -> rstd::io::Result<Option<rstd::process::ExitStatus>> {
+    auto result = rstd::sys::process::pidfd_wait(fd, nonblocking);
+    if (result.error) return Err(rstd::io::error::Error::from_raw_os_error(i32(result.error)));
+    if (! result.available) return Ok(None());
+    return Ok(Some(result.signaled ? rstd::process::ExitStatus::from_signal(i32(result.status))
+                                   : rstd::process::ExitStatus::from_code(i32(result.status))));
+}
+
+auto rstd::os::linux::process::PidFd::kill() const -> io::Result<empty> {
+    auto error = sys::process::pidfd_send_signal(as_raw_fd(), sys::libc::SIGKILL, false);
+    if (error) return Err(io::error::Error::from_raw_os_error(i32(error)));
+    return Ok(empty {});
+}
+
+auto rstd::os::linux::process::PidFd::wait() const -> io::Result<rstd::process::ExitStatus> {
+    auto result = pidfd_status(as_raw_fd(), false);
+    if (result.is_err()) return Err(rstd::move(result).unwrap_err());
+    return Ok(result.unwrap().unwrap());
+}
+
+auto rstd::os::linux::process::PidFd::try_wait() const
+    -> io::Result<Option<rstd::process::ExitStatus>> {
+    return pidfd_status(as_raw_fd(), true);
+}
+#endif

src/std/src/os/linux/process.cppm

@@ -0,0 +1,36 @@
+module;
+#include <rstd/macro.hpp>
+export module rstd:os.linux.process;
+export import :process.command;
+#if RSTD_OS_LINUX
+export import :os.linux.pidfd;
+
+export namespace rstd::os::linux::process
+{
+
+struct CommandExt {
+    /// Requests a race-free pidfd at spawn. Absence does not fail spawning.
+    static auto create_pidfd(rstd::process::Command& command, bool value)
+        -> rstd::process::Command& {
+        command.create_pidfd_ = value;
+        return command;
+    }
+};
+
+struct ChildExt {
+    static auto pidfd(const rstd::process::Child& child [[clang::lifetimebound]])
+        -> io::Result<ref<PidFd>> {
+        if (child.pidfd_.is_some())
+            return Ok(ref<PidFd>::from_raw_parts(rstd::addressof(*child.pidfd_)));
+        return Err(
+            io::error::Error::from_kind(io::error::ErrorKind { io::error::ErrorKind::Other }));
+    }
+    /// Consumes Child on success; returns the original Child when no pidfd exists.
+    static auto into_pidfd(rstd::process::Child child) -> Result<PidFd, rstd::process::Child> {
+        if (child.pidfd_.is_none()) return Err(rstd::move(child));
+        return Ok(child.pidfd_.take().unwrap());
+    }
+};
+
+} // namespace rstd::os::linux::process
+#endif

src/std/src/os/mod.cppm

@@ -3,4 +3,6 @@ export import :os.fd;
 export import :os.handle;
 export import :os.socket;
 export import :os.unix.ffi;
+export import :os.unix.process;
+export import :os.linux.process;
 export import :os.windows.ffi;

src/std/src/os/unix/process.cppm

@@ -0,0 +1,32 @@
+module;
+#include <rstd/macro.hpp>
+export module rstd:os.unix.process;
+export import :process.command;
+
+#if RSTD_OS_UNIX
+export namespace rstd::os::unix::process
+{
+
+struct CommandExt {
+    /// Zero makes the child the leader of a new process group.
+    static auto process_group(rstd::process::Command& command, i32 pgroup)
+        -> rstd::process::Command& {
+        command.process_group_ = Some(pgroup);
+        return command;
+    }
+};
+
+struct ChildExt {
+    static auto send_signal(const rstd::process::Child& child, i32 signal) -> io::Result<empty> {
+        return child.send_signal(signal, false);
+    }
+    /// For the PID fallback, the child must be its process group's leader.
+    static auto send_process_group_signal(const rstd::process::Child& child, i32 signal)
+        -> io::Result<empty> {
+        return child.send_signal(signal, true);
+    }
+    static auto kill_process_group(rstd::process::Child& child) -> io::Result<empty>;
+};
+
+} // namespace rstd::os::unix::process
+#endif

src/std/src/process/command.cppm

@@ -5,8 +5,27 @@ export module rstd:process.command;
 export import :process.exit_status;
 export import :io;
 export import :path;
+export import :os.fd;
 export import rstd.alloc;
 import :sys.io.stdio;
+#if RSTD_OS_LINUX
+export import :os.linux.pidfd;
+#endif
+
+#if RSTD_OS_UNIX
+export namespace rstd::os::unix::process
+{
+struct CommandExt;
+struct ChildExt;
+} // namespace rstd::os::unix::process
+#endif
+#if RSTD_OS_LINUX
+export namespace rstd::os::linux::process
+{
+struct CommandExt;
+struct ChildExt;
+} // namespace rstd::os::linux::process
+#endif
 
 using ::alloc::ffi::CString;
 using ::alloc::string::String;
@@ -39,6 +58,12 @@ struct ChildStdin {
     ChildStdin& operator=(ChildStdin&&) = delete;
     ChildStdin()                        = default;
     explicit ChildStdin(int f): fd(f) {}
+#if RSTD_OS_UNIX
+    auto as_raw_fd() const noexcept -> os::fd::RawFd { return fd; }
+    auto as_fd() const noexcept [[clang::lifetimebound]] -> os::fd::BorrowedFd {
+        return os::fd::BorrowedFd::borrow_raw(fd);
+    }
+#endif
 };
 
 /// A handle to a child process's standard output (read end of pipe).
@@ -49,6 +74,12 @@ struct ChildStdout {
     ChildStdout& operator=(ChildStdout&&) = delete;
     ChildStdout()                         = default;
     explicit ChildStdout(int f): fd(f) {}
+#if RSTD_OS_UNIX
+    auto as_raw_fd() const noexcept -> os::fd::RawFd { return fd; }
+    auto as_fd() const noexcept [[clang::lifetimebound]] -> os::fd::BorrowedFd {
+        return os::fd::BorrowedFd::borrow_raw(fd);
+    }
+#endif
 };
 
 /// A handle to a child process's standard error (read end of pipe).
@@ -59,6 +90,12 @@ struct ChildStderr {
     ChildStderr& operator=(ChildStderr&&) = delete;
     ChildStderr()                         = default;
     explicit ChildStderr(int f): fd(f) {}
+#if RSTD_OS_UNIX
+    auto as_raw_fd() const noexcept -> os::fd::RawFd { return fd; }
+    auto as_fd() const noexcept [[clang::lifetimebound]] -> os::fd::BorrowedFd {
+        return os::fd::BorrowedFd::borrow_raw(fd);
+    }
+#endif
 };
 
 } // namespace rstd::process
@@ -106,6 +143,20 @@ export namespace rstd::process
 
 /// A child process handle.
 struct Child {
+private:
+    friend sys::process_impl::Spawn;
+#if RSTD_OS_UNIX
+    friend os::unix::process::ChildExt;
+#endif
+#if RSTD_OS_LINUX
+    friend os::linux::process::ChildExt;
+    Option<os::linux::process::PidFd> pidfd_;
+#endif
+#if RSTD_OS_UNIX
+    auto send_signal(i32 signal, bool group) const -> io::Result<empty>;
+#endif
+
+public:
     int pid { -1 };
 #if RSTD_OS_WINDOWS
     void* process_handle { nullptr };
@@ -143,7 +194,11 @@ struct Child {
 
     ~Child();
     Child(Child&& o) noexcept
-        : pid(o.pid),
+        :
+#if RSTD_OS_LINUX
+          pidfd_(o.pidfd_.take()),
+#endif
+          pid(o.pid),
 #if RSTD_OS_WINDOWS
           process_handle(o.process_handle),
 #endif
@@ -171,6 +226,14 @@ class Command {
     Stdio           cfg_stdout_ { Stdio::inherit() };
     Stdio           cfg_stderr_ { Stdio::inherit() };
     bool            env_clear_ { false };
+#if RSTD_OS_UNIX
+    Option<i32> process_group_;
+    friend os::unix::process::CommandExt;
+#endif
+#if RSTD_OS_LINUX
+    bool create_pidfd_ { false };
+    friend os::linux::process::CommandExt;
+#endif
 
     friend sys::process_impl::Spawn;