Implement (m|mun)lockall for Linux and *nix libcs

Author: blblack

lib/std/c.zig

@@ -1516,6 +1516,20 @@ pub const clock_gettime = switch (native_os) {
     else => private.clock_gettime,
 };
 
+// All the Unix-likes except darwin support the mlockall call.  However, the
+// flags values are consistent everywhere except Linux. which has an extra flag
+// MCL_ONFAULT and has non-standard values for the MCL constants on ppc, ppc64,
+// and sparc.
+pub extern "c" fn mlockall(flags: c_int) c_int;
+pub extern "c" fn munlockall() c_int;
+pub const MCL = switch (native_os) {
+    .linux => std.os.linux.MCL,
+    else => struct {
+        pub const CURRENT = 0x01;
+        pub const FUTURE = 0x02;
+    },
+};
+
 pub const fstat = switch (native_os) {
     .macos => switch (native_arch) {
         .x86_64 => private.@"fstat$INODE64",

lib/std/os.zig

@@ -100,6 +100,7 @@ pub const Kevent = system.Kevent;
 pub const LOCK = system.LOCK;
 pub const MADV = system.MADV;
 pub const MAP = system.MAP;
+pub const MCL = system.MCL;
 pub const MSF = system.MSF;
 pub const MAX_ADDR_LEN = system.MAX_ADDR_LEN;
 pub const MFD = system.MFD;
@@ -7505,6 +7506,37 @@ pub fn madvise(ptr: [*]align(mem.page_size) u8, length: usize, advice: u32) Madv
     }
 }
 
+pub const MlockallError = error{
+    InvalidArgument,
+    LockedMemoryLimitExceeded,
+    PermissionDenied,
+    SystemResources,
+} || UnexpectedError;
+
+pub fn mlockall(flags: i32) MlockallError!void {
+    switch (errno(system.mlockall(flags))) {
+        .SUCCESS => return,
+        .INVAL => return error.InvalidArgument,
+        .NOMEM => return error.LockedMemoryLimitExceeded,
+        .PERM => return error.PermissionDenied,
+        // Solaris and (Free|Net|Open)BSD, presumably no room to fault in locked stuff:
+        .AGAIN => return error.SystemResources,
+        else => |err| return unexpectedErrno(err),
+    }
+}
+
+pub const MunlockallError = error{
+    PermissionDenied,
+} || UnexpectedError;
+
+pub fn munlockall() MunlockallError!void {
+    switch (errno(system.munlockall())) {
+        .SUCCESS => return,
+        .EPERM => return error.PermissionDenied, // Solaris, possibly BSDs as well
+        else => |err| return unexpectedErrno(err),
+    }
+}
+
 pub const PerfEventOpenError = error{
     /// Returned if the perf_event_attr size value is too small (smaller
     /// than PERF_ATTR_SIZE_VER0), too big (larger than the page  size),

lib/std/os/linux.zig

@@ -2092,6 +2092,14 @@ pub fn madvise(address: [*]u8, len: usize, advice: u32) usize {
     return syscall3(.madvise, @intFromPtr(address), len, advice);
 }
 
+pub fn mlockall(flags: i32) usize {
+    return syscall1(.mlockall, @as(usize, @bitCast(@as(isize, flags))));
+}
+
+pub fn munlockall() usize {
+    return syscall0(.munlockall);
+}
+
 pub fn pidfd_open(pid: pid_t, flags: u32) usize {
     return syscall2(.pidfd_open, @as(usize, @bitCast(@as(isize, pid))), flags);
 }
@@ -5454,6 +5462,16 @@ pub const MADV = struct {
     pub const SOFT_OFFLINE = 101;
 };
 
+pub const MCL = if (is_ppc or is_ppc64 or is_sparc) struct {
+    pub const CURRENT = 0x2000;
+    pub const FUTURE = 0x4000;
+    pub const ONFAULT = 0x8000;
+} else struct {
+    pub const CURRENT = 0x01;
+    pub const FUTURE = 0x02;
+    pub const ONFAULT = 0x04;
+};
+
 pub const POSIX_FADV = switch (native_arch) {
     .s390x => if (@typeInfo(usize).Int.bits == 64) struct {
         pub const NORMAL = 0;

lib/std/os/test.zig

@@ -1284,3 +1284,14 @@ test "fchmodat smoke test" {
         try expectMode(tmp.dir.fd, "symlink", 0o600);
     try expectMode(tmp.dir.fd, "regfile", 0o640);
 }
+
+test "mlockall basic check" {
+    // We can't test a "real" mlockall or munlockall because of various system
+    // perms/limits on locked memory and/or possible adverse effects on the
+    // testing environment itself. What we can do safely, I think, is execute
+    // mlockall() with a very-invalid (across all known platforms) flags value
+    // and expect EINVAL, so that we at least exercise the code path and
+    // confirm the system or libc call really exists and is callable.
+    if (!@hasDecl(os.system, "mlockall")) return error.SkipZigTest;
+    try expectError(error.InvalidArgument, os.mlockall(0b0001111111111000));
+}