Add mlock syscalls to std.c and std.posix

Linux already gained the relevant syscalls and consts in ziglang#24473

The basic mlock() and munlock() are fairly universal across the
*nix world with a consistent interface, but are missing on wasi
and windows.

The mlockall() and munlockall() calls are not as widely supported
as the basic ones.  Notable non-implementers include darwin,
haiku, and serenity (and of course wasi and windows again).

mlock2() is Linux-only, as are its MLOCK flags.

Author: blblack

lib/std/c.zig

@@ -1599,6 +1599,19 @@ pub const MADV = switch (native_os) {
     },
     else => void,
 };
+pub const MCL = switch (native_os) {
+    .linux => linux.MCL,
+    .freebsd, .dragonfly, .netbsd, .openbsd, .solaris, .illumos => packed struct(c_int) {
+        CURRENT: bool = 0,
+        FUTURE: bool = 0,
+        _: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 2) = 0,
+    },
+    else => void,
+};
+pub const MLOCK = switch (native_os) {
+    .linux => linux.MLOCK,
+    else => void,
+};
 pub const MSF = switch (native_os) {
     .linux => linux.MSF,
     .emscripten => emscripten.MSF,
@@ -10425,6 +10438,31 @@ pub const gettimeofday = switch (native_os) {
     else => private.gettimeofday,
 };
 
+pub const mlock = switch (native_os) {
+    .windows, .wasi => {},
+    else => private.mlock,
+};
+
+pub const mlock2 = switch (native_os) {
+    linux => private.mlock2,
+    else => {},
+};
+
+pub const munlock = switch (native_os) {
+    .windows, .wasi => {},
+    else => private.mlock,
+};
+
+pub const mlockall = switch (native_os) {
+    .linux, .freebsd, .dragonfly, .netbsd, .openbsd, .solaris, .illumos => private.mlockall,
+    else => {},
+};
+
+pub const munlockall = switch (native_os) {
+    .linux, .freebsd, .dragonfly, .netbsd, .openbsd, .solaris, .illumos => private.munlockall,
+    else => {},
+};
+
 pub const msync = switch (native_os) {
     .netbsd => private.__msync13,
     else => private.msync,
@@ -11313,6 +11351,12 @@ const private = struct {
     extern "c" fn malloc_usable_size(?*const anyopaque) usize;
     extern "c" fn posix_memalign(memptr: *?*anyopaque, alignment: usize, size: usize) c_int;
 
+    extern "c" fn mlock(addr: *align(page_size) const anyopaque, len: usize) c_int;
+    extern "c" fn mlock2(addr: *align(page_size) const anyopaque, len: usize, flags: MLOCK) c_int;
+    extern "c" fn munlock(addr: *align(page_size) const anyopaque, len: usize) c_int;
+    extern "c" fn mlockall(flags: MCL) c_int;
+    extern "c" fn munlockall() c_int;
+
     /// macos modernized symbols.
     /// x86_64 links to $INODE64 suffix for 64-bit support.
     /// Note these are not necessary on aarch64.

lib/std/posix.zig

@@ -81,7 +81,9 @@ pub const Kevent = system.Kevent;
 pub const MADV = system.MADV;
 pub const MAP = system.MAP;
 pub const MAX_ADDR_LEN = system.MAX_ADDR_LEN;
+pub const MCL = system.MCL;
 pub const MFD = system.MFD;
+pub const MLOCK = system.MLOCK;
 pub const MREMAP = system.MREMAP;
 pub const MSF = system.MSF;
 pub const MSG = system.MSG;
@@ -4745,6 +4747,76 @@ pub fn fanotify_markZ(
     }
 }
 
+pub const MlockError = error{
+    PermissionDenied,
+    LockedMemoryLimitExceeded,
+    SystemResources,
+} || UnexpectedError;
+
+pub fn mlock(memory: []align(page_size_min) const u8) MlockError!void {
+    if (@TypeOf(system.mlock) == void)
+        @compileError("mlock not supported on this OS");
+    return switch (errno(system.mlock(memory.ptr, memory.len))) {
+        .SUCCESS => {},
+        .INVAL => unreachable, // unaligned, negative, runs off end of addrspace
+        .PERM => error.PermissionDenied,
+        .NOMEM => error.LockedMemoryLimitExceeded,
+        .AGAIN => error.SystemResources,
+        else => |err| unexpectedErrno(err),
+    };
+}
+
+pub fn mlock2(memory: []align(page_size_min) const u8, flags: MLOCK) MlockError!void {
+    if (@TypeOf(system.mlock2) == void)
+        @compileError("mlock2 not supported on this OS");
+    return switch (errno(system.mlock2(memory.ptr, memory.len, flags))) {
+        .SUCCESS => {},
+        .INVAL => unreachable, // bad memory or bad flags
+        .PERM => error.PermissionDenied,
+        .NOMEM => error.LockedMemoryLimitExceeded,
+        .AGAIN => error.SystemResources,
+        else => |err| unexpectedErrno(err),
+    };
+}
+
+pub fn munlock(memory: []align(page_size_min) const u8) MlockError!void {
+    if (@TypeOf(system.munlock) == void)
+        @compileError("munlock not supported on this OS");
+    return switch (errno(system.munlock(memory.ptr, memory.len))) {
+        .SUCCESS => {},
+        .INVAL => unreachable, // unaligned or runs off end of addr space
+        .PERM => return error.PermissionDenied,
+        .NOMEM => return error.LockedMemoryLimitExceeded,
+        .AGAIN => return error.SystemResources,
+        else => |err| unexpectedErrno(err),
+    };
+}
+
+pub fn mlockall(flags: MCL) MlockError!void {
+    if (@TypeOf(system.mlockall) == void)
+        @compileError("mlockall not supported on this OS");
+    return switch (errno(system.mlockall(flags))) {
+        .SUCCESS => {},
+        .INVAL => unreachable, // bad flags
+        .PERM => error.PermissionDenied,
+        .NOMEM => error.LockedMemoryLimitExceeded,
+        .AGAIN => error.SystemResources,
+        else => |err| unexpectedErrno(err),
+    };
+}
+
+pub fn munlockall() MlockError!void {
+    if (@TypeOf(system.munlockall) == void)
+        @compileError("munlockall not supported on this OS");
+    return switch (errno(system.munlockall())) {
+        .SUCCESS => {},
+        .PERM => error.PermissionDenied,
+        .NOMEM => error.LockedMemoryLimitExceeded,
+        .AGAIN => error.SystemResources,
+        else => |err| unexpectedErrno(err),
+    };
+}
+
 pub const MProtectError = error{
     /// The memory cannot be given the specified access.  This can happen, for example, if you
     /// mmap(2)  a  file  to  which  you have read-only access, then ask mprotect() to mark it