std.os.linuxの薄いラッパーを自作する——sethostname(2)に高レベル関数が存在しない問題

pub fn uname(uts: *utsname) usize

const rc = linux.syscall2(.sethostname, @intFromPtr(name.ptr), name.len);

const std = @import("std");
const linux = std.os.linux;

pub const SyscallError = error{
    PermissionDenied,
    Unexpected,
};

fn check(comptime name: []const u8, rc: usize) SyscallError!void {
    switch (linux.errno(rc)) {
        .SUCCESS => return,
        .PERM => return error.PermissionDenied,
        else => |err| {
            std.log.err("{s} failed: errno={d} ({s})", .{ name, @intFromEnum(err), @tagName(err) });
            return error.Unexpected;
        },
    }
}

pub fn getUname() SyscallError!linux.utsname {
    var uts: linux.utsname = undefined;
    try check("uname", linux.uname(&uts));
    return uts;
}

pub fn setHostname(name: []const u8) SyscallError!void {
    const rc = linux.syscall2(.sethostname, @intFromPtr(name.ptr), name.len);
    try check("sethostname", rc);
}

// この書き方だと、返ってきたスライスの参照先がすでに無効になっている
pub fn getHostname() SyscallError![]const u8 {
    var uts: linux.utsname = undefined;
    try check("uname", linux.uname(&uts));
    return std.mem.sliceTo(&uts.nodename, 0);
}

$ zig build run -- create
command: create
current hostname: server
setHostname failed as expected (no privilege / no UTS namespace yet): PermissionDenied

pub fn clone(
    func: *const fn (arg: usize) callconv(.c) u8,
    stack: usize,
    flags: u32,
    arg: usize,
    ptid: ?*i32,
    tp: usize,
    ctid: ?*i32,
) usize

pub const CLONE_NEWPID: u32 = 0x20000000;
pub const CLONE_NEWUTS: u32 = 0x04000000;
pub const CLONE_NEWIPC: u32 = 0x08000000;

pub fn cloneInNamespace(
    flags: u32,
    stack: []align(16) u8,
    func: *const fn (arg: usize) callconv(.c) u8,
    arg: usize,
) SyscallError!linux.pid_t {
    const stack_top = @intFromPtr(stack.ptr) + stack.len;
    const rc = linux.clone(
        func,
        stack_top,
        flags | @intFromEnum(linux.SIG.CHLD),
        arg,
        null,
        0,
        null,
    );
    try check("clone", rc);
    return @intCast(rc);
}

pub fn waitForChild(pid: linux.pid_t) SyscallError!u8 {
    var status: u32 = undefined;
    const rc = linux.waitpid(pid, &status, 0);
    try check("waitpid", rc);
    return linux.W.EXITSTATUS(status);
}

pub fn getPid() linux.pid_t {
    return linux.getpid();
}

pub fn shmGet(key: i32, size: usize, flags: u32) SyscallError!i32 {
    const rc = linux.syscall3(.shmget, @intCast(key), size, flags);
    try check("shmget", rc);
    return @intCast(rc);
}

pub fn shmRemove(shmid: i32) SyscallError!void {
    const rc = linux.syscall3(.shmctl, @intCast(shmid), IPC_RMID, 0);
    try check("shmctl", rc);
}

pub const IPC_CREAT: u32 = 0o1000;
pub const IPC_RMID: u32 = 0;

pub const SyscallError = error {
    PermissionDenied,
    NotFound,
    Unexpected,
};

fn check(comptime name: []const u8, rc: usize) SyscallError!void {
    switch (linux.errno(rc)) {
        .SUCCESS => return,
        .PERM => return error.PermissionDenied,
        .NOENT => return error.NotFound,
        else => |err| {
            std.log.err("{s} failed: errno={d} ({s})", .{ name, @intFromEnum(err), @tagName(err) });
            return error.Unexpected;
        },
    }
}

pub const CLONE_NEWNS: u32 = 0x00020000;

pub fn pivotRootInto(new_root: [*:0]const u8) SyscallError!void {
    try check("mount(private)", linux.mount(null, "/", null, linux.MS.REC | linux.MS.PRIVATE, 0));
    try check("mount(bind)", linux.mount(new_root, new_root, null, linux.MS.BIND | linux.MS.REC, 0));
    try check("chdir(new_root)", linux.chdir(new_root));
    try check("mkdir(put_old)", linux.mkdir("put_old", 0o700));
    try check("pivot_root", linux.pivot_root(".", "put_old"));
    try check("chdir(/)", linux.chdir("/"));
    try check("umount2(put_old)", linux.umount2("/put_old", linux.MNT.DETACH));
    try check("rmdir(put_old)", linux.rmdir("/put_old"));
}

pub fn mountProc() SyscallError!void {
    try check("mount(proc)", linux.mount("proc", "/proc", "proc", 0, 0));
}

pub fn execInto(
    path: [*:0]const u8,
    argv: [*:null]const ?[*:0]const u8,
    envp: [*:null]const ?[*:0]const u8,
) SyscallError!void {
    try check("execve", linux.execve(path, argv, envp));
}