fixup usages.

Author: Jan Philipp Hafer

lib/std/Thread.zig

@@ -945,6 +945,7 @@ const LinuxThreadImpl = struct {
 
         // map all memory needed without read/write permissions
         // to avoid committing the whole region right away
+        // anonymous mapping ensures file descriptor limits are not exceeded
         const mapped = os.posix.mmap(
             null,
             map_bytes,
@@ -956,6 +957,8 @@ const LinuxThreadImpl = struct {
             error.MemoryMappingNotSupported => unreachable,
             error.AccessDenied => unreachable,
             error.PermissionDenied => unreachable,
+            error.ProcessFdQuotaExceeded => unreachable,
+            error.SystemFdQuotaExceeded => unreachable,
             else => |e| return e,
         };
         assert(mapped.len >= map_bytes);

lib/std/crypto/tlcsprng.zig

@@ -111,11 +111,11 @@ fn tlsCsprngFill(_: *anyopaque, buffer: []u8) void {
                 // Qemu user-mode emulation ignores any valid/invalid madvise
                 // hint and returns success. Check if this is the case by
                 // passing bogus parameters, we expect EINVAL as result.
-                if (os.madvise(wipe_mem.ptr, 0, 0xffffffff)) |_| {
+                if (os.posix.madvise(wipe_mem.ptr, 0, 0xffffffff)) |_| {
                     break :wof;
                 } else |_| {}
 
-                if (os.madvise(wipe_mem.ptr, wipe_mem.len, os.MADV.WIPEONFORK)) |_| {
+                if (os.posix.madvise(wipe_mem.ptr, wipe_mem.len, os.MADV.WIPEONFORK)) |_| {
                     return initAndFill(buffer);
                 } else |_| {}
             }

lib/std/debug.zig

@@ -1880,10 +1880,10 @@ pub fn maybeEnableSegfaultHandler() void {
 var windows_segfault_handle: ?windows.HANDLE = null;
 
 pub fn updateSegfaultHandler(act: ?*const os.Sigaction) error{OperationNotSupported}!void {
-    try os.sigaction(os.SIG.SEGV, act, null);
-    try os.sigaction(os.SIG.ILL, act, null);
-    try os.sigaction(os.SIG.BUS, act, null);
-    try os.sigaction(os.SIG.FPE, act, null);
+    try os.posix.sigaction(os.SIG.SEGV, act, null);
+    try os.posix.sigaction(os.SIG.ILL, act, null);
+    try os.posix.sigaction(os.SIG.BUS, act, null);
+    try os.posix.sigaction(os.SIG.FPE, act, null);
 }
 
 /// Attaches a global SIGSEGV handler which calls @panic("segmentation fault");

lib/std/fs/file.zig

@@ -899,7 +899,7 @@ pub const File = struct {
         };
     }
 
-    pub const UpdateTimesError = os.FutimensError || windows.SetFileTimeError;
+    pub const UpdateTimesError = os.posix.FutimensError || windows.SetFileTimeError;
 
     /// The underlying file system may have a different granularity than nanoseconds,
     /// and therefore this function cannot guarantee any precision will be stored.
@@ -928,7 +928,7 @@ pub const File = struct {
                 .tv_nsec = math.cast(isize, @mod(mtime, std.time.ns_per_s)) orelse maxInt(isize),
             },
         };
-        try os.futimens(self.handle, &times);
+        try os.posix.futimens(self.handle, &times);
     }
 
     /// Reads all the bytes from the current position to the end of the file.

lib/std/os/test.zig

@@ -434,11 +434,11 @@ test "sigaltstack" {
     if (native_os == .windows or native_os == .wasi) return error.SkipZigTest;
 
     var st: os.stack_t = undefined;
-    try os.sigaltstack(null, &st);
+    try os.posix.sigaltstack(null, &st);
     // Setting a stack size less than MINSIGSTKSZ returns ENOMEM
     st.flags = 0;
     st.size = 1;
-    try testing.expectError(error.SizeTooSmall, os.sigaltstack(&st, null));
+    try testing.expectError(error.SizeTooSmall, os.posix.sigaltstack(&st, null));
 }
 
 // If the type is not available use void to avoid erroring out when `iter_fn` is
@@ -736,7 +736,7 @@ test "getrlimit and setrlimit" {
 
     inline for (std.meta.fields(os.rlimit_resource)) |field| {
         const resource = @intToEnum(os.rlimit_resource, field.value);
-        const limit = try os.getrlimit(resource);
+        const limit = try os.posix.getrlimit(resource);
 
         // On 32 bit MIPS musl includes a fix which changes limits greater than -1UL/2 to RLIM_INFINITY.
         // See http://git.musl-libc.org/cgit/musl/commit/src/misc/getrlimit.c?id=8258014fd1e34e942a549c88c7e022a00445c352
@@ -745,10 +745,10 @@ test "getrlimit and setrlimit" {
         // In that case the following the limit would be RLIM_INFINITY and the following setrlimit fails with EPERM.
         if (comptime builtin.cpu.arch.isMIPS() and builtin.link_libc) {
             if (limit.cur != os.linux.RLIM.INFINITY) {
-                try os.setrlimit(resource, limit);
+                try os.posix.setrlimit(resource, limit);
             }
         } else {
-            try os.setrlimit(resource, limit);
+            try os.posix.setrlimit(resource, limit);
         }
     }
 }
@@ -807,10 +807,10 @@ test "sigaction" {
     var old_sa: os.Sigaction = undefined;
 
     // Install the new signal handler.
-    try os.sigaction(os.SIG.USR1, &sa, null);
+    try os.posix.sigaction(os.SIG.USR1, &sa, null);
 
     // Check that we can read it back correctly.
-    try os.sigaction(os.SIG.USR1, null, &old_sa);
+    try os.posix.sigaction(os.SIG.USR1, null, &old_sa);
     try testing.expectEqual(&S.handler, old_sa.handler.sigaction.?);
     try testing.expect((old_sa.flags & os.SA.SIGINFO) != 0);
 
@@ -819,26 +819,26 @@ test "sigaction" {
     try testing.expect(S.handler_called_count == 1);
 
     // Check if passing RESETHAND correctly reset the handler to SIG_DFL
-    try os.sigaction(os.SIG.USR1, null, &old_sa);
+    try os.posix.sigaction(os.SIG.USR1, null, &old_sa);
     try testing.expectEqual(os.SIG.DFL, old_sa.handler.handler);
 
     // Reinstall the signal w/o RESETHAND and re-raise
     sa.flags = os.SA.SIGINFO;
-    try os.sigaction(os.SIG.USR1, &sa, null);
+    try os.posix.sigaction(os.SIG.USR1, &sa, null);
     try os.raise(os.SIG.USR1);
     try testing.expect(S.handler_called_count == 2);
 
     // Now set the signal to ignored
     sa.handler = .{ .handler = os.SIG.IGN };
     sa.flags = 0;
-    try os.sigaction(os.SIG.USR1, &sa, null);
+    try os.posix.sigaction(os.SIG.USR1, &sa, null);
 
     // Re-raise to ensure handler is actually ignored
     try os.raise(os.SIG.USR1);
     try testing.expect(S.handler_called_count == 2);
 
     // Ensure that ignored state is returned when querying
-    try os.sigaction(os.SIG.USR1, null, &old_sa);
+    try os.posix.sigaction(os.SIG.USR1, null, &old_sa);
     try testing.expectEqual(os.SIG.IGN, old_sa.handler.handler.?);
 }
 

lib/std/start.zig

@@ -471,7 +471,7 @@ fn expandStackSize(phdrs: []elf.Phdr) void {
                 const wanted_stack_size = phdr.p_memsz;
                 assert(wanted_stack_size % std.mem.page_size == 0);
 
-                std.os.setrlimit(.STACK, .{
+                std.os.posix.setrlimit(.STACK, .{
                     .cur = wanted_stack_size,
                     .max = wanted_stack_size,
                 }) catch {

lib/std/zig/system/NativeTargetInfo.zig

@@ -39,7 +39,7 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo {
     if (cross_target.os_tag == null) {
         switch (builtin.target.os.tag) {
             .linux => {
-                const uts = std.os.uname();
+                const uts = std.os.posix.uname();
                 const release = mem.sliceTo(&uts.release, 0);
                 // The release field sometimes has a weird format,
                 // `Version.parse` will attempt to find some meaningful interpretation.
@@ -53,7 +53,7 @@ pub fn detect(cross_target: CrossTarget) DetectError!NativeTargetInfo {
                 }
             },
             .solaris => {
-                const uts = std.os.uname();
+                const uts = std.os.posix.uname();
                 const release = mem.sliceTo(&uts.release, 0);
                 if (std.builtin.Version.parse(release)) |ver| {
                     os.version_range.semver.min = ver;

src/main.zig

@@ -5283,9 +5283,8 @@ fn parseCodeModel(arg: []const u8) std.builtin.CodeModel {
 /// zig processes to run concurrently with each other, without clobbering each other.
 fn gimmeMoreOfThoseSweetSweetFileDescriptors() void {
     if (!@hasDecl(std.os.system, "rlimit")) return;
-    const posix = std.os;
 
-    var lim = posix.getrlimit(.NOFILE) catch return; // Oh well; we tried.
+    var lim = std.os.posix.getrlimit(.NOFILE) catch return; // Oh well; we tried.
     if (comptime builtin.target.isDarwin()) {
         // On Darwin, `NOFILE` is bounded by a hardcoded value `OPEN_MAX`.
         // According to the man pages for setrlimit():
@@ -5297,17 +5296,17 @@ fn gimmeMoreOfThoseSweetSweetFileDescriptors() void {
     if (lim.cur == lim.max) return;
 
     // Do a binary search for the limit.
-    var min: posix.rlim_t = lim.cur;
-    var max: posix.rlim_t = 1 << 20;
+    var min: std.os.rlim_t = lim.cur;
+    var max: std.os.rlim_t = 1 << 20;
     // But if there's a defined upper bound, don't search, just set it.
-    if (lim.max != posix.RLIM.INFINITY) {
+    if (lim.max != std.os.RLIM.INFINITY) {
         min = lim.max;
         max = lim.max;
     }
 
     while (true) {
         lim.cur = min + @divTrunc(max - min, 2); // on freebsd rlim_t is signed
-        if (posix.setrlimit(.NOFILE, lim)) |_| {
+        if (std.os.posix.setrlimit(.NOFILE, lim)) |_| {
             min = lim.cur;
         } else |_| {
             max = lim.cur;