tiny.sys.process

1pub const AuxiliaryKey = enum {2    hardware_capabilities,3    hardware_capabilities_2,4};

1pub const AuxiliaryValueError = error{UnsupportedPlatform};

1pub const BuildIdError = error{ UnsupportedPlatform, ProgramHeaderMissing };

1pub const ChildPeekPolicy = enum {2    unsupported,3    linux_waitid,4    darwin_waitid,5};

1pub const ChildSignal = enum {2    terminate,3    kill,4    pause_child,5    resume_child,6};

1pub const ChildSignalError = error{2    UnsupportedPlatform,3    ProcessNotFound,4    PermissionDenied,5    InvalidSignal,6    SignalFailed,7};

1pub const ChildSignalPolicy = enum {2    unsupported,3    linux_syscall,4    posix_host,5};

1pub const DescriptorIsolationError = error{2    UnsupportedPlatform,3    DescriptorIsolationFailed,4};

1pub const DetachOptions = struct {2    argv: []const []const u8,3    cwd: Child.Cwd = .inherit,4    environ_map: ?*const Environ.Map = null,5};

1pub const DetachPolicy = enum {2    unsupported,3    linux_cloexec_process_group,4};

1pub const ExecDescriptorError = error{2    UnsupportedPlatform,3    InvalidDescriptor,4    AccessDenied,5    InvalidExecutable,6    ExecFailed,7};

1pub const ExecUnderStackError = error{2    UnsupportedPlatform,3    InvalidLimit,4    PermissionDenied,5    PersonaFailed,6    AccessDenied,7    InvalidExecutable,8    ExecFailed,9};

1pub const ForkError = error{2    UnsupportedPlatform,3    SystemResources,4    ForkFailed,5};

1pub const ForkResult = union(enum) {2    child,3    parent: ProcessId,4};

1pub const KernelReleaseError = error{ UnsupportedPlatform, BufferTooSmall };

1pub const ProcessGroupError = error{2    UnsupportedPlatform,3    ProcessNotFound,4    PermissionDenied,5};

1pub const ProcessIdentityError = error{2    UnsupportedPlatform,3};

1pub const ProcessIdentityPolicy = enum {2    unsupported,3    linux_syscall,4    posix_host,5};

1pub const ResourceUsage = struct {2    source: ?ResourceUsageSource = null,3    maxrss_kib: ?i64 = null,4    user_s: ?f64 = null,5    system_s: ?f64 = null,6    minor_page_faults: ?u64 = null,7    major_page_faults: ?u64 = null,8    voluntary_context_switches: ?u64 = null,9    involuntary_context_switches: ?u64 = null,10};

1pub const ResourceUsageSource = enum {2    getrusage_self,3    wait4_rusage,4};

1pub const SubreaperError = error{2    UnsupportedPlatform,3    SubreaperFailed,4};

1pub const SystemControlError = error{2    UnsupportedPlatform,3    NotFound,4    PermissionDenied,5    BufferTooSmall,6    QueryFailed,7};

1pub const WaitDirectError = error{2    UnsupportedPlatform,3    ChildAlreadyReaped,4    ChildWaitFailed,5};

1pub const WaitNoHangOutcome = struct {2    term: Termination,3    usage: ResourceUsage,4};

1/// Specifies what to run and in what environment through the inputs for a2/// captured launch: the argument vector and the environment map.3pub const CapturedOptions = struct {4    argv: []const []const u8,5    environment: *const std.process.Environ.Map,6};

1pub const DetachError = SpawnError || error{2    UnsupportedPlatform,3    DescriptorIsolationFailed,4};

1pub const ReapHandoffError = sys.thread.SpawnError || error{2    MissingChildId,3};

1pub fn abort() noreturn {2    std.process.abort();3}

1pub fn auxiliaryValue(key: AuxiliaryKey) AuxiliaryValueError!usize {2    if (comptime native_os != .linux) return error.UnsupportedPlatform;3    return linux.getauxval(switch (key) {4        .hardware_capabilities => std.elf.AT_HWCAP,5        .hardware_capabilities_2 => std.elf.AT_HWCAP2,6    });7}

1/// Ensures a descendant whose parent died still reports its exit to the2/// supervisor by making the calling process the Linux child subreaper, so3/// descendants orphaned below it reparent to it and stay reapable. Other4/// targets refuse with `UnsupportedPlatform`.5pub fn becomeChildSubreaper() SubreaperError!void {6    if (comptime native_os != .linux) return error.UnsupportedPlatform;7    return switch (linux.errno(linux.prctl(8        @backingInt(linux.PR.SET_CHILD_SUBREAPER),9        1,10        0,11        0,12        0,13    ))) {14        .SUCCESS => {},15        else => error.SubreaperFailed,16    };17}

1/// Returns the GNU build-id descriptor of the running executable, or null when its link wrote2/// none. The kernel passes the program headers in auxv, so no file is read and no syscall runs.3/// The slice borrows the mapped image for the life of the process.4pub fn buildId() BuildIdError!?[]const u8 {5    if (comptime native_os != .linux) return error.UnsupportedPlatform;6    const headers = posix.getSelfPhdrs();7    const bias = for (headers) |header| {8        if (header.type == .PHDR) break @intFromPtr(headers.ptr) -% header.vaddr;9    } else return error.ProgramHeaderMissing;10    for (headers) |header| {11        if (header.type != .NOTE) continue;12        const start: [*]const u8 = @ptrFromInt(bias +% header.vaddr);13        const alignment: usize = if (header.@"align" == 8) 8 else 4;14        const segment = start[0..header.filesz];15        if (noteDescriptor(segment, alignment, std.elf.NT_GNU_BUILD_ID)) |id| return id;16    }17    return null;18}

1pub fn childPeekPolicy() ChildPeekPolicy {2    return switch (native_os) {3        .linux => .linux_waitid,4        .macos => .darwin_waitid,5        else => .unsupported,6    };7}

1pub fn childSignalPolicy() ChildSignalPolicy {2    return switch (native_os) {3        .windows, .wasi => .unsupported,4        .linux => .linux_syscall,5        else => .posix_host,6    };7}

1pub fn createOwnProcessGroup() ProcessGroupError!void {2    const outcome = if (comptime native_os == .linux)3        linux.errno(linux.setpgid(0, 0))4    else if (comptime native_os == .macos)5        std.c.errno(std.c.setpgid(0, 0))6    else7        return error.UnsupportedPlatform;8    return switch (outcome) {9        .SUCCESS => {},10        .ACCES, .PERM => error.PermissionDenied,11        else => error.UnsupportedPlatform,12    };13}

1pub fn currentGroupId() ProcessIdentityError!GroupId {2    return switch (comptime processIdentityPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => linux.getgid(),5        .posix_host => currentGroupIdPosix(),6    };7}

1pub fn currentProcessId() ProcessIdentityError!ProcessId {2    return switch (comptime processIdentityPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => linux.getpid(),5        .posix_host => currentProcessIdPosix(),6    };7}

1pub fn currentResourceUsage() ResourceUsage {2    if (comptime native_os == .windows or3        native_os == .wasi or4        native_os == .freestanding)5    {6        return .{};7    }8    return resourceUsage(9        .getrusage_self,10        posix.getrusage(posix.rusage.SELF),11    );12}

1pub fn currentThreadId() ProcessIdentityError!ThreadId {2    return switch (comptime processIdentityPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => linux.gettid(),5        .posix_host => currentThreadIdPosix(),6    };7}

1pub fn currentUserId() ProcessIdentityError!UserId {2    return switch (comptime processIdentityPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => linux.getuid(),5        .posix_host => currentUserIdPosix(),6    };7}

1pub fn detachPolicy() DetachPolicy {2    return switch (comptime native_os) {3        .linux => .linux_cloexec_process_group,4        else => .unsupported,5    };6}

1pub fn effectiveGroupId() ProcessIdentityError!GroupId {2    return switch (comptime processIdentityPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => linux.getegid(),5        .posix_host => effectiveGroupIdPosix(),6    };7}

1pub fn effectiveUserId() ProcessIdentityError!UserId {2    return switch (comptime processIdentityPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => linux.geteuid(),5        .posix_host => effectiveUserIdPosix(),6    };7}

1pub fn execDescriptor(2    descriptor: posix.fd_t,3    argv: [*:null]const ?[*:0]const u8,4    environment: [*:null]const ?[*:0]const u8,5) ExecDescriptorError!void {6    if (comptime native_os != .linux) return error.UnsupportedPlatform;7    const result = linux.execveat(8        descriptor,9        "",10        argv,11        environment,12        .{ .SYMLINK_NOFOLLOW = true, .EMPTY_PATH = true },13    );14    return switch (linux.errno(result)) {15        .BADF => error.InvalidDescriptor,16        .ACCES => error.AccessDenied,17        .NOEXEC => error.InvalidExecutable,18        else => error.ExecFailed,19    };20}

1/// Caps this process at `stack_bytes` of stack and then hands it over to the2/// program at `path`. The initial stack lands at the address the kernel picks3/// when no randomization applies, so a harness that has to show a program stays4/// inside a stack budget gets the same answer on every run. Linux otherwise5/// shifts the initial stack pointer down by a random amount of up to eight6/// kilobytes before the program executes an instruction, in `arch_align_stack`,7/// which leaves a program at a fixed limit surviving one run and overflowing8/// the next. The order runs persona, then the soft and hard limit in one call,9/// and then the exec. A return means the exec failed, and both settings remain10/// in force on the calling process, so a caller with work left to do makes this11/// call inside a forked child. A zero limit fails with `InvalidLimit`, and a12/// host other than Linux with `UnsupportedPlatform`.13pub fn execUnderStack(14    path: [*:0]const u8,15    argv: [*:null]const ?[*:0]const u8,16    environment: [*:null]const ?[*:0]const u8,17    stack_bytes: u64,18) ExecUnderStackError!void {19    if (comptime native_os != .linux) return error.UnsupportedPlatform;20    if (stack_bytes == 0) return error.InvalidLimit;21    if (linux.errno(linux.syscall1(.personality, persona_no_randomize)) != .SUCCESS) {22        return error.PersonaFailed;23    }24    const limit = linux.rlimit{ .cur = stack_bytes, .max = stack_bytes };25    switch (linux.errno(linux.setrlimit(.STACK, &limit))) {26        .SUCCESS => {},27        .INVAL => return error.InvalidLimit,28        .PERM => return error.PermissionDenied,29        else => return error.InvalidLimit,30    }31    const result = linux.execve(path, argv, environment);32    return switch (linux.errno(result)) {33        .ACCES => error.AccessDenied,34        .NOEXEC => error.InvalidExecutable,35        else => error.ExecFailed,36    };37}

1pub fn executableDirPathAlloc(allocator: std.mem.Allocator) ExecutablePathAllocError![]u8 {2    return std.process.executableDirPathAlloc(std.Options.debug_io, allocator);3}

1pub fn executablePathAlloc(allocator: std.mem.Allocator) ExecutablePathAllocError![:0]u8 {2    return std.process.executablePathAlloc(std.Options.debug_io, allocator);3}

1pub fn exit(code: u8) noreturn {2    std.process.exit(code);3}

1pub fn exitCode(term: Termination) i64 {2    return switch (term) {3        .exited => |code| @intCast(code),4        .signal => |sig| -@as(i64, @intCast(@backingInt(sig))),5        .stopped => |sig| -@as(i64, @intCast(@backingInt(sig))),6        .unknown => -1,7    };8}

1pub fn forceKillChildId(child_id: Child.Id) void {2    if (builtin.os.tag == .windows or builtin.os.tag == .wasi) return;3    signalChildId(child_id, .kill) catch {};4}

1pub fn fork() ForkError!ForkResult {2    if (comptime native_os != .linux) return error.UnsupportedPlatform;3    const result = linux.fork();4    return switch (linux.errno(result)) {5        .SUCCESS => if (result == 0) .child else .{ .parent = @intCast(result) },6        .AGAIN, .NOMEM => error.SystemResources,7        else => error.ForkFailed,8    };9}

1pub fn handoffReap(2    child: *Child,3) ReapHandoffError!void {4    const child_id = child.id orelse5        return error.MissingChildId;6    const reaper = try sys.thread.spawn(7        reapChildId,8        .{child_id},9    );10    child.id = null;11    reaper.detach();12}

1pub fn isolateChildDescriptors() DescriptorIsolationError!void {2    return switch (comptime native_os) {3        .linux => isolateChildDescriptorsLinux(),4        .macos => isolateChildDescriptorsDarwin(),5        else => error.UnsupportedPlatform,6    };7}

1pub fn kernelRelease(storage: []u8) KernelReleaseError![]const u8 {2    if (comptime native_os == .windows or native_os == .wasi or native_os == .freestanding) {3        return error.UnsupportedPlatform;4    }5    const identity = posix.uname();6    const release = std.mem.sliceTo(&identity.release, 0);7    if (release.len > storage.len) return error.BufferTooSmall;8    @memcpy(storage[0..release.len], release);9    return storage[0..release.len];10}

1pub fn killAndReap(child: *Child, io: anytype) void {2    if (child.id != null) child.kill(io);3}

1pub fn parentProcessId() ProcessIdentityError!ProcessId {2    return switch (comptime processIdentityPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => linux.getppid(),5        .posix_host => parentProcessIdPosix(),6    };7}

1pub fn peekNoHang(child_id: Child.Id) !?Termination {2    return switch (comptime childPeekPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_waitid => peekLinux(child_id),5        .darwin_waitid => peekDarwin(child_id),6    };7}

1pub fn processAlive(process_id: ProcessId) ProcessGroupError!bool {2    _ = processGroupId(process_id) catch |err| switch (err) {3        error.ProcessNotFound => return false,4        else => return err,5    };6    return true;7}

1pub fn processGroupAlive(group_id: ProcessId) ProcessGroupError!bool {2    if (group_id <= 1) return error.ProcessNotFound;3    return switch (comptime processIdentityPolicy()) {4        .unsupported => error.UnsupportedPlatform,5        .linux_syscall => switch (linux.errno(linux.kill(6            -group_id,7            @fromBackingInt(@intCast(0)),8        ))) {9            .SUCCESS => true,10            .SRCH => false,11            .PERM => true,12            else => error.UnsupportedPlatform,13        },14        .posix_host => switch (posix.errno(system.kill(15            -group_id,16            @as(system.SIG, @fromBackingInt(@intCast(0))),17        ))) {18            .SUCCESS, .PERM => true,19            .SRCH => false,20            else => error.UnsupportedPlatform,21        },22    };23}

1pub fn processGroupId(process_id: ProcessId) ProcessGroupError!ProcessId {2    if (process_id <= 0) return error.ProcessNotFound;3    return switch (comptime processIdentityPolicy()) {4        .unsupported => error.UnsupportedPlatform,5        .linux_syscall => processGroupIdInspected(process_id),6        .posix_host => processGroupIdPosix(process_id),7    };8}

1pub fn processIdentityPolicy() ProcessIdentityPolicy {2    return switch (native_os) {3        .windows, .wasi, .freestanding => .unsupported,4        .linux => .linux_syscall,5        else => .posix_host,6    };7}

1pub fn requestTermination(child: *Child, io: anytype) void {2    if (native_os == .windows or native_os == .wasi) {3        killAndReap(child, io);4        return;5    }67    const child_id = child.id orelse return;8    signalChildId(child_id, .terminate) catch {};9}

1pub const required_capabilities = sys.capabilities.host(2    &.{ .process, .environment, .threads },3);

1pub fn run(allocator: std.mem.Allocator, io: anytype, options: RunOptions) RunError!RunResult {2    return std.process.run(allocator, io, options);3}

1pub fn signalChildGroup(child_id: Child.Id, signal: ChildSignal) ChildSignalError!void {2    return switch (comptime childSignalPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall, .posix_host => signalChildId(-child_id, signal),5    };6}

1pub fn signalChildId(child_id: Child.Id, signal: ChildSignal) ChildSignalError!void {2    return switch (comptime childSignalPolicy()) {3        .unsupported => error.UnsupportedPlatform,4        .linux_syscall => signalChildIdLinux(child_id, signal),5        .posix_host => signalChildIdPosix(child_id, signal),6    };7}

1pub fn spawn(io: anytype, options: SpawnOptions) SpawnError!Child {2    return std.process.spawn(io, options);3}

1pub fn spawnDetached(io: anytype, options: DetachOptions) DetachError!Child {2    if (comptime detachPolicy() == .unsupported) return error.UnsupportedPlatform;3    std.debug.assert(options.argv.len != 0);4    try isolateChildDescriptors();5    return try spawn(io, .{6        .argv = options.argv,7        .cwd = options.cwd,8        .environ_map = options.environ_map,9        .stdin = .ignore,10        .stdout = .ignore,11        .stderr = .ignore,12        .pgid = 0,13    });14}

1pub fn systemControl(2    comptime name: [:0]const u8,3    output: anytype,4) SystemControlError!usize {5    if (comptime !is_darwin) return error.UnsupportedPlatform;6    const pointer = @typeInfo(@TypeOf(output)).pointer;7    var byte_len: usize = @sizeOf(pointer.child);8    const rc = system.sysctlbyname(name, output, &byte_len, null, 0);9    return switch (posix.errno(rc)) {10        .SUCCESS => byte_len,11        .NOENT => error.NotFound,12        .ACCES, .PERM => error.PermissionDenied,13        .NOMEM => error.BufferTooSmall,14        else => error.QueryFailed,15    };16}

1pub fn wait(child: *Child, io: anytype) WaitError!Termination {2    return child.wait(io);3}

1pub fn waitDirect(child_id: ProcessId) WaitDirectError!Termination {2    if (comptime native_os == .windows or3        native_os == .wasi or4        native_os == .freestanding)5    {6        return error.UnsupportedPlatform;7    }8    var status: i32 = undefined;9    var child_usage: posix.rusage = undefined;10    while (true) {11        const result = system.wait4(child_id, &status, 0, &child_usage);12        switch (posix.errno(result)) {13            .SUCCESS => return statusToTerm(@bitCast(status)),14            .INTR => continue,15            .CHILD => return error.ChildAlreadyReaped,16            else => return error.ChildWaitFailed,17        }18    }19}

1pub fn waitNoHang(child_id: Child.Id) !?WaitNoHangOutcome {2    if (comptime native_os == .windows or native_os == .wasi) return error.UnsupportedPlatform;3    var status: i32 = undefined;4    var child_usage: posix.rusage = undefined;5    const rc = system.wait4(child_id, &status, posix.W.NOHANG, &child_usage);6    return switch (posix.errno(rc)) {7        .SUCCESS => if (rc == 0) null else .{8            .term = statusToTerm(@bitCast(status)),9            .usage = resourceUsage(.wait4_rusage, child_usage),10        },11        .INTR => null,12        else => |err| return posix.unexpectedErrno(err),13    };14}

1/// Starts one Linux child whose standard output and standard error are pipes2/// the caller reads, with standard input on `/dev/null`, for a caller that3/// needs to know the child holds none of its descriptors.4///5/// Before it execs, the child arms the parent-death signal to `SIGKILL` and6/// starts its own process group. One `close_range` call in the child closes any7/// open descriptor above standard error, so that every inherited non-standard8/// descriptor is closed before the program runs, while the pre-exec launcher9/// keeps one private close-on-exec status descriptor at descriptor 3, whose10/// end-of-file after a successful exec tells the parent the launch reached the11/// program. Where a command name has no slash, the launcher finds it by12/// searching a fixed `PATH` list compiled into the launcher, which the13/// environment map does not change.14///15/// A launch that fails anywhere before the program starts is killed and reaped,16/// and reports `DescriptorIsolationFailed`, while an empty argument vector17/// returns `EmptyArgv` and a host other than Linux returns18/// `UnsupportedPlatform`.19pub fn spawnCaptured(20    allocator: Allocator,21    options: CapturedOptions,22) !std.process.Child {23    if (comptime native_os != .linux) return error.UnsupportedPlatform;24    if (options.argv.len == 0) return error.EmptyArgv;2526    var arena_state = std.heap.ArenaAllocator.init(allocator);27    defer arena_state.deinit();28    const arena = arena_state.allocator();2930    const argv = try prepareArgv(arena, options.argv);31    const environment = try options.environment.createPosixBlock(arena, .{32        .zig_progress_fd = -1,33    });34    var executable_storage: [std.posix.PATH_MAX]u8 = undefined;35    const executable = try executablePath(36        argv[0].?,37        options.argv[0],38        &executable_storage,39    );4041    var descriptors = try Descriptors.init();42    defer descriptors.deinit();43    const parent_id = linux.getpid();44    const fork_result = linux.fork();45    switch (linux.errno(fork_result)) {46        .SUCCESS => {},47        .AGAIN, .NOMEM => return error.SystemResources,48        else => return error.DescriptorIsolationFailed,49    }50    if (fork_result == 0) {51        launchChild(52            parent_id,53            descriptors,54            executable,55            argv,56            environment,57        );58    }5960    const child_id: linux.pid_t = @intCast(fork_result);61    descriptors.closeSources();62    if (!launchSucceeded(descriptors.status_read)) {63        terminateAndReap(child_id);64        return error.DescriptorIsolationFailed;65    }66    descriptors.closeStatus();6768    const stdout_descriptor = descriptors.takeStdout();69    const stderr_descriptor = descriptors.takeStderr();70    return .{71        .id = child_id,72        .thread_handle = {},73        .stdin = null,74        .stdout = .{75            .handle = stdout_descriptor,76            .flags = .{ .nonblocking = false },77        },78        .stderr = .{79            .handle = stderr_descriptor,80            .flags = .{ .nonblocking = false },81        },82        .request_resource_usage_statistics = false,83    };84}

1/// Forks a child that is process id 1 inside a new PID namespace and a new user2/// namespace, preserving the caller's real and effective user and group3/// identity through an identity map, while on the parent side the call yields4/// the child's process id as the host numbers it. Killing or exiting that child5/// kills the namespace's descendants, including processes that create new6/// sessions. The child arms the parent-death signal, which delivers `SIGKILL`7/// to a child when its parent exits, and no-new-privileges, which stops a later8/// exec from gaining privileges, such as through a setuid binary, while the9/// parent waits for both over a socket pair before the call returns. The child10/// keeps every mount the caller had, procfs among them, so a numeric path under11/// `/proc` read inside the child resolves against the caller's process12/// numbering, and only a program whose behavior under that mismatch is known13/// belongs beneath this call. The child carries the same restriction any forked14/// child carries: it reaches an exec or an exit while touching none of the15/// runtime locks it inherited. A caller whose real and effective identity16/// differ fails with `NamespaceIdentityUnavailable`, and a host outside Linux17/// on x86-64 and aarch64 fails with `UnsupportedPlatform`.18pub fn forkContained() !process.ForkResult {19    if (comptime builtin.os.tag != .linux) return error.UnsupportedPlatform;20    if (comptime builtin.cpu.arch != .x86_64 and builtin.cpu.arch != .aarch64) {21        return error.UnsupportedPlatform;22    }23    const uid = linux.getuid();24    const gid = linux.getgid();25    if (uid != linux.geteuid() or gid != linux.getegid()) {26        return error.NamespaceIdentityUnavailable;27    }28    var channel: [2]sys.fd.Descriptor = undefined;29    const channel_result = linux.socketpair(30        linux.AF.UNIX,31        linux.SOCK.SEQPACKET | linux.SOCK.CLOEXEC,32        0,33        &channel,34    );35    if (linux.errno(channel_result) != .SUCCESS) {36        return error.NamespaceChannelFailed;37    }38    defer closeDescriptor(&channel[0]);39    defer closeDescriptor(&channel[1]);40    const flags = linux.CLONE.NEWUSER | linux.CLONE.NEWPID | @backingInt(linux.SIG.CHLD);41    const result = linux.clone2(flags, 0);42    switch (linux.errno(result)) {43        .SUCCESS => {},44        .PERM, .ACCES => return error.NamespacePermissionDenied,45        .AGAIN, .NOMEM, .NOSPC => return error.SystemResources,46        else => return error.NamespaceCreationFailed,47    }48    if (result == 0) {49        closeDescriptor(&channel[0]);50        childReady(channel[1]) catch process.exit(127);51        std.debug.assert(linux.getpid() == 1);52        std.debug.assert(linux.getuid() == uid);53        std.debug.assert(linux.getgid() == gid);54        return .child;55    }56    closeDescriptor(&channel[1]);57    const child: process.ProcessId = @intCast(result);58    std.debug.assert(child > 1);59    errdefer {60        process.forceKillChildId(child);61        _ = process.waitDirect(child) catch {};62    }63    try receiveReady(channel[0]);64    try mapIdentity(child, "uid_map", uid);65    try writeControl(child, "setgroups", "deny");66    try mapIdentity(child, "gid_map", gid);67    try sendReady(channel[0]);68    return .{ .parent = child };69}

1pub const Args = std.process.Args;

1pub const Child = std.process.Child;

1pub const Environ = std.process.Environ;

1pub const ExecutablePathAllocError = std.process.ExecutablePathAllocError;

1pub const GroupId = linux.gid_t;

1pub const Init = std.process.Init;

1pub const MinimalInit = std.process.Init.Minimal;

1pub const ProcessId = linux.pid_t;

1pub const RunError = std.process.RunError;

1pub const RunOptions = std.process.RunOptions;

1pub const RunResult = std.process.RunResult;

1pub const SpawnError = std.process.SpawnError;

1pub const SpawnOptions = std.process.SpawnOptions;

1pub const Termination = Child.Term;

1pub const ThreadId = linux.pid_t;

1pub const UserId = linux.uid_t;

1pub const WaitError = Child.WaitError;

1const control = @import("control.zig");2const namespace = @import("namespace.zig");3const isolated = @import("isolated.zig");45pub const inspect = @import("inspect/root.zig");67pub const required_capabilities = control.required_capabilities;8pub const Child = control.Child;9pub const Init = control.Init;10pub const MinimalInit = control.MinimalInit;11pub const Args = control.Args;12pub const Environ = control.Environ;13pub const SpawnOptions = control.SpawnOptions;14pub const SpawnError = control.SpawnError;15pub const Termination = control.Termination;16pub const WaitError = control.WaitError;17pub const RunOptions = control.RunOptions;18pub const RunResult = control.RunResult;19pub const RunError = control.RunError;20pub const ExecutablePathAllocError = control.ExecutablePathAllocError;21pub const ProcessId = control.ProcessId;22pub const ThreadId = control.ThreadId;23pub const UserId = control.UserId;24pub const GroupId = control.GroupId;25pub const AuxiliaryKey = control.AuxiliaryKey;26pub const BuildIdError = control.BuildIdError;27pub const AuxiliaryValueError = control.AuxiliaryValueError;28pub const SystemControlError = control.SystemControlError;29pub const KernelReleaseError = control.KernelReleaseError;30pub const ResourceUsageSource = control.ResourceUsageSource;31pub const ResourceUsage = control.ResourceUsage;32pub const WaitNoHangOutcome = control.WaitNoHangOutcome;33pub const ChildSignal = control.ChildSignal;34pub const ChildSignalPolicy = control.ChildSignalPolicy;35pub const ProcessIdentityPolicy = control.ProcessIdentityPolicy;36pub const ChildPeekPolicy = control.ChildPeekPolicy;37pub const ChildSignalError = control.ChildSignalError;38pub const ProcessIdentityError = control.ProcessIdentityError;39pub const ProcessGroupError = control.ProcessGroupError;40pub const SubreaperError = control.SubreaperError;41pub const ForkError = control.ForkError;42pub const ForkResult = control.ForkResult;43pub const ExecDescriptorError = control.ExecDescriptorError;44pub const ExecUnderStackError = control.ExecUnderStackError;45pub const WaitDirectError = control.WaitDirectError;46pub const DetachPolicy = control.DetachPolicy;47pub const DetachOptions = control.DetachOptions;48pub const DetachError = control.DetachError;49pub const DescriptorIsolationError = control.DescriptorIsolationError;50pub const ReapHandoffError = control.ReapHandoffError;51pub const CapturedIsolatedOptions = isolated.CapturedOptions;5253pub const spawn = control.spawn;54pub const fork = control.fork;55pub const forkContained = namespace.forkContained;56pub const execDescriptor = control.execDescriptor;57pub const execUnderStack = control.execUnderStack;58pub const spawnCapturedIsolated = isolated.spawnCaptured;59pub const auxiliaryValue = control.auxiliaryValue;60pub const buildId = control.buildId;61pub const systemControl = control.systemControl;62pub const kernelRelease = control.kernelRelease;63pub const detachPolicy = control.detachPolicy;64pub const spawnDetached = control.spawnDetached;65pub const handoffReap = control.handoffReap;66pub const isolateChildDescriptors = control.isolateChildDescriptors;67pub const processGroupId = control.processGroupId;68pub const processAlive = control.processAlive;69pub const createOwnProcessGroup = control.createOwnProcessGroup;70pub const becomeChildSubreaper = control.becomeChildSubreaper;71pub const processGroupAlive = control.processGroupAlive;72pub const wait = control.wait;73pub const waitDirect = control.waitDirect;74pub const waitNoHang = control.waitNoHang;75pub const currentResourceUsage = control.currentResourceUsage;76pub const peekNoHang = control.peekNoHang;77pub const childPeekPolicy = control.childPeekPolicy;78pub const run = control.run;79pub const executableDirPathAlloc = control.executableDirPathAlloc;80pub const executablePathAlloc = control.executablePathAlloc;81pub const exit = control.exit;82pub const abort = control.abort;83pub const exitCode = control.exitCode;84pub const childSignalPolicy = control.childSignalPolicy;85pub const processIdentityPolicy = control.processIdentityPolicy;86pub const signalChildId = control.signalChildId;87pub const signalChildGroup = control.signalChildGroup;88pub const currentProcessId = control.currentProcessId;89pub const parentProcessId = control.parentProcessId;90pub const currentThreadId = control.currentThreadId;91pub const currentUserId = control.currentUserId;92pub const currentGroupId = control.currentGroupId;93pub const effectiveUserId = control.effectiveUserId;94pub const effectiveGroupId = control.effectiveGroupId;95pub const requestTermination = control.requestTermination;96pub const forceKillChildId = control.forceKillChildId;97pub const killAndReap = control.killAndReap;9899pub const tracing = @import("tracing/root.zig");

1pub const process = @import("process/root.zig");