std.os.linux: resurrect shm

This reintroduces Linux's shared memory system calls which was in
ziglang#7214. It also adds the externs
necessary for C.

Author: RossComputerGuy

lib/std/c/linux.zig

@@ -65,6 +65,7 @@ pub const dl_phdr_info = linux.dl_phdr_info;
 pub const empty_sigset = linux.empty_sigset;
 pub const epoll_event = linux.epoll_event;
 pub const fd_t = linux.fd_t;
+pub const key_t = linux.key_t;
 pub const gid_t = linux.gid_t;
 pub const ifreq = linux.ifreq;
 pub const ino_t = linux.ino_t;
@@ -344,3 +345,8 @@ pub const dirent64 = struct {
     type: u8,
     name: [256]u8,
 };
+
+pub extern "c" fn shmget(key: key_t, size: usize, shmflg: u32) c_int;
+pub extern "c" fn shmat(shmid: i32, shmaddr: ?[*]align(std.mem.page_size) u8, shmflg: u32) c_int;
+pub extern "c" fn shmctl(shmid: i32, cmd: i32, buf: ?[*]u8) c_int;
+pub extern "c" fn shmdt(shmaddr: [*]u8) c_int;

lib/std/os/linux.zig

@@ -799,6 +799,93 @@ pub fn munmap(address: [*]const u8, length: usize) usize {
     return syscall2(.munmap, @intFromPtr(address), length);
 }
 
+pub const key_t = i32;
+pub const IPC = struct {
+    pub const PRIVATE = 0;
+
+    /// create key if key does not exist
+    pub const CREAT = 0x200;
+
+    /// fail if key exists
+    pub const EXCL = 0x400;
+
+    /// return error on wait
+    pub const NOWAIT = 0x800;
+
+    /// remove identifier
+    pub const RMID = 0;
+
+    /// set 'ipc_perm' options
+    pub const SET = 1;
+
+    /// get 'ipc_perm' options
+    pub const STAT = 2;
+
+    /// get info about shared memory limits and parameters
+    pub const INFO = 3;
+};
+
+pub const SHM = struct {
+    /// segment will be destroyed on last detach
+    pub const DEST = 0x200;
+
+    /// segment will not be swapped
+    pub const LOCKED = 0x400;
+
+    /// segment will use huge TLB pages
+    pub const HUGETLB = 0x800;
+
+    pub const HUGE_SHIFT = 26;
+    pub const HUGE_2MB = 21 << HUGE_SHIFT;
+    pub const HUGE_1GB = 30 << HUGE_SHIFT;
+
+    /// don't check for reservations
+    pub const NORESERVE = 0x1000;
+
+    /// attach read-only else read-write
+    pub const RDONLY = 0x1000;
+
+    /// round attach address to SHMLBA
+    pub const RND = 0x2000;
+
+    /// take-over region on attach
+    pub const REMAP = 0x4000;
+
+    /// execution access
+    pub const EXEC = 0x8000;
+
+    /// lock segment
+    pub const LOCK = 11;
+
+    /// unlock segment
+    pub const UNLOCK = 12;
+
+    /// get 'ipc_perm' options from kernel index
+    pub const STAT = 13;
+
+    /// get info about about system resources consumed by shared memory
+    pub const INFO = 14;
+
+    /// get 'ipc_perm' options from kernel index without checking read access
+    pub const STAT_ANY = 15;
+};
+
+pub fn shmget(key: key_t, size: usize, shmflg: u32) usize {
+    return syscall3(.shmget, key, size, shmflg);
+}
+
+pub fn shmat(shmid: u32, shmaddr: ?[*]align(std.mem.page_size) u8, shmflg: u32) usize {
+    return syscall3(.shmat, shmid, @intFromPtr(shmaddr), shmflg);
+}
+
+pub fn shmctl(shmid: u32, cmd: i32, buf: ?[*]u8) usize {
+    return syscall3(.shmctl, shmid, cmd, @intFromPtr(buf));
+}
+
+pub fn shmdt(shmaddr: *const anyopaque) usize {
+    return syscall1(.shmdt, @intFromPtr(shmaddr));
+}
+
 pub fn poll(fds: [*]pollfd, n: nfds_t, timeout: i32) usize {
     if (@hasField(SYS, "poll")) {
         return syscall3(.poll, @intFromPtr(fds), n, @as(u32, @bitCast(timeout)));

lib/std/os/linux/test.zig

@@ -121,6 +121,36 @@ test "fadvise" {
     try expectEqual(@as(usize, 0), ret);
 }
 
+test "shm" {
+    const segment = linux.shmget(linux.IPC.PRIVATE, mem.page_size, linux.IPC.CREAT | 0o666);
+    switch (linux.getErrno(segment)) {
+        .SUCCESS => {},
+        else => unreachable,
+    }
+
+    defer {
+        const r = linux.shmctl(@intCast(segment), linux.IPC.RMID, null);
+        switch (linux.getErrno(r)) {
+            .SUCCESS => {},
+            else => unreachable,
+        }
+    }
+
+    const addr = std.os.linux.shmat(@intCast(segment), null, 0);
+    switch (linux.getErrno(addr)) {
+        .SUCCESS => {},
+        else => unreachable,
+    }
+
+    defer {
+        const r = std.os.linux.shmdt(@ptrFromInt(addr));
+        switch (linux.getErrno(r)) {
+            .SUCCESS => {},
+            else => unreachable,
+        }
+    }
+}
+
 test {
     _ = linux.IoUring;
 }