std: move abort and exit from posix into process

and delete the unit tests that called fork()

no forking allowed in the std lib, including unit tests, except to implement child process spawning.

17 files changed, 151 insertions, 236 deletions

diff --git a/lib/std/Build.zig b/lib/std/Build.zig
index 3d0e8b8dbc..1eff8813e5 100644
--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -1706,7 +1706,7 @@ pub fn truncateFile(b: *Build, dest_path: []const u8) (Io.Dir.MakeError || Io.Di
     var src_file = cwd.createFile(io, dest_path, .{}) catch |err| switch (err) {
         error.FileNotFound => blk: {
             if (fs.path.dirname(dest_path)) |dirname| {
-                try cwd.makePath(dirname);
+                try cwd.makePath(io, dirname);
             }
             break :blk try cwd.createFile(io, dest_path, .{});
         },
@@ -2634,13 +2634,12 @@ pub const InstallDir = union(enum) {
 /// source of API breakage in the future, so keep that in mind when using this
 /// function.
 pub fn makeTempPath(b: *Build) []const u8 {
+    const io = b.graph.io;
     const rand_int = std.crypto.random.int(u64);
     const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int);
     const result_path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch @panic("OOM");
-    b.cache_root.handle.makePath(tmp_dir_sub_path) catch |err| {
-        std.debug.print("unable to make tmp path '{s}': {s}\n", .{
-            result_path, @errorName(err),
-        });
+    b.cache_root.handle.makePath(io, tmp_dir_sub_path) catch |err| {
+        std.debug.print("unable to make tmp path '{s}': {t}\n", .{ result_path, err });
     };
     return result_path;
 }
diff --git a/lib/std/Build/Cache/Path.zig b/lib/std/Build/Cache/Path.zig
index 93e0c0d792..941948a9cd 100644
--- a/lib/std/Build/Cache/Path.zig
+++ b/lib/std/Build/Cache/Path.zig
@@ -128,14 +128,14 @@ pub fn access(p: Path, sub_path: []const u8, flags: Io.Dir.AccessOptions) !void
     return p.root_dir.handle.access(joined_path, flags);
 }
 
-pub fn makePath(p: Path, sub_path: []const u8) !void {
+pub fn makePath(p: Path, io: Io, sub_path: []const u8) !void {
     var buf: [fs.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
         break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
-    return p.root_dir.handle.makePath(joined_path);
+    return p.root_dir.handle.makePath(io, joined_path);
 }
 
 pub fn toString(p: Path, allocator: Allocator) Allocator.Error![]u8 {
diff --git a/lib/std/Build/Step/ConfigHeader.zig b/lib/std/Build/Step/ConfigHeader.zig
index ea7d9d99ff..f377959610 100644
--- a/lib/std/Build/Step/ConfigHeader.zig
+++ b/lib/std/Build/Step/ConfigHeader.zig
@@ -184,6 +184,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
 
     const gpa = b.allocator;
     const arena = b.allocator;
+    const io = b.graph.io;
 
     var man = b.graph.cache.obtain();
     defer man.deinit();
@@ -257,7 +258,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     const sub_path = b.pathJoin(&.{ "o", &digest, config_header.include_path });
     const sub_path_dirname = std.fs.path.dirname(sub_path).?;
 
-    b.cache_root.handle.makePath(sub_path_dirname) catch |err| {
+    b.cache_root.handle.makePath(io, sub_path_dirname) catch |err| {
         return step.fail("unable to make path '{f}{s}': {s}", .{
             b.cache_root, sub_path_dirname, @errorName(err),
         });
diff --git a/lib/std/Build/Step/ObjCopy.zig b/lib/std/Build/Step/ObjCopy.zig
index 4aa1c0a9dc..b81f59b9a1 100644
--- a/lib/std/Build/Step/ObjCopy.zig
+++ b/lib/std/Build/Step/ObjCopy.zig
@@ -143,6 +143,7 @@ pub fn getOutputSeparatedDebug(objcopy: *const ObjCopy) ?std.Build.LazyPath {
 fn make(step: *Step, options: Step.MakeOptions) !void {
     const prog_node = options.progress_node;
     const b = step.owner;
+    const io = b.graph.io;
     const objcopy: *ObjCopy = @fieldParentPtr("step", step);
     try step.singleUnchangingWatchInput(objcopy.input_file);
 
@@ -176,7 +177,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     const cache_path = "o" ++ fs.path.sep_str ++ digest;
     const full_dest_path = try b.cache_root.join(b.allocator, &.{ cache_path, objcopy.basename });
     const full_dest_path_debug = try b.cache_root.join(b.allocator, &.{ cache_path, b.fmt("{s}.debug", .{objcopy.basename}) });
-    b.cache_root.handle.makePath(cache_path) catch |err| {
+    b.cache_root.handle.makePath(io, cache_path) catch |err| {
         return step.fail("unable to make path {s}: {s}", .{ cache_path, @errorName(err) });
     };
 
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index af6bc20438..54e77bd614 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -973,7 +973,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
                 .output_directory => output_sub_path,
                 else => unreachable,
             };
-            b.cache_root.handle.makePath(output_sub_dir_path) catch |err| {
+            b.cache_root.handle.makePath(io, output_sub_dir_path) catch |err| {
                 return step.fail("unable to make path '{f}{s}': {s}", .{
                     b.cache_root, output_sub_dir_path, @errorName(err),
                 });
@@ -1005,7 +1005,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
             .output_directory => output_sub_path,
             else => unreachable,
         };
-        b.cache_root.handle.makePath(output_sub_dir_path) catch |err| {
+        b.cache_root.handle.makePath(io, output_sub_dir_path) catch |err| {
             return step.fail("unable to make path '{f}{s}': {s}", .{
                 b.cache_root, output_sub_dir_path, @errorName(err),
             });
@@ -1241,6 +1241,7 @@ fn runCommand(
     const b = step.owner;
     const arena = b.allocator;
     const gpa = options.gpa;
+    const io = b.graph.io;
 
     const cwd: ?[]const u8 = if (run.cwd) |lazy_cwd| lazy_cwd.getPath2(b, step) else null;
 
@@ -1470,7 +1471,7 @@ fn runCommand(
 
             const sub_path = b.pathJoin(&output_components);
             const sub_path_dirname = fs.path.dirname(sub_path).?;
-            b.cache_root.handle.makePath(sub_path_dirname) catch |err| {
+            b.cache_root.handle.makePath(io, sub_path_dirname) catch |err| {
                 return step.fail("unable to make path '{f}{s}': {s}", .{
                     b.cache_root, sub_path_dirname, @errorName(err),
                 });
diff --git a/lib/std/Build/Step/UpdateSourceFiles.zig b/lib/std/Build/Step/UpdateSourceFiles.zig
index f5d95182e9..44c6ae1ed4 100644
--- a/lib/std/Build/Step/UpdateSourceFiles.zig
+++ b/lib/std/Build/Step/UpdateSourceFiles.zig
@@ -78,7 +78,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
     var any_miss = false;
     for (usf.output_source_files.items) |output_source_file| {
         if (fs.path.dirname(output_source_file.sub_path)) |dirname| {
-            b.build_root.handle.makePath(dirname) catch |err| {
+            b.build_root.handle.makePath(io, dirname) catch |err| {
                 return step.fail("unable to make path '{f}{s}': {t}", .{ b.build_root, dirname, err });
             };
         }
diff --git a/lib/std/Build/Step/WriteFile.zig b/lib/std/Build/Step/WriteFile.zig
index 85dc9b3fa2..21346959e7 100644
--- a/lib/std/Build/Step/WriteFile.zig
+++ b/lib/std/Build/Step/WriteFile.zig
@@ -268,7 +268,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
 
     for (write_file.files.items) |file| {
         if (fs.path.dirname(file.sub_path)) |dirname| {
-            cache_dir.makePath(dirname) catch |err| {
+            cache_dir.makePath(io, dirname) catch |err| {
                 return step.fail("unable to make path '{f}{s}{c}{s}': {t}", .{
                     b.cache_root, cache_path, fs.path.sep, dirname, err,
                 });
@@ -303,7 +303,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         const dest_dirname = dir.sub_path;
 
         if (dest_dirname.len != 0) {
-            cache_dir.makePath(dest_dirname) catch |err| {
+            cache_dir.makePath(io, dest_dirname) catch |err| {
                 return step.fail("unable to make path '{f}{s}{c}{s}': {s}", .{
                     b.cache_root, cache_path, fs.path.sep, dest_dirname, @errorName(err),
                 });
@@ -318,7 +318,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
             const src_entry_path = try src_dir_path.join(arena, entry.path);
             const dest_path = b.pathJoin(&.{ dest_dirname, entry.path });
             switch (entry.kind) {
-                .directory => try cache_dir.makePath(dest_path),
+                .directory => try cache_dir.makePath(io, dest_path),
                 .file => {
                     const prev_status = Io.Dir.updateFile(
                         src_entry_path.root_dir.handle,
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 5df0eef2d5..7ede172d86 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -522,7 +522,7 @@ pub fn defaultPanic(
             }
             @trap();
         },
-        .cuda, .amdhsa => std.posix.abort(),
+        .cuda, .amdhsa => std.process.abort(),
         .plan9 => {
             var status: [std.os.plan9.ERRMAX]u8 = undefined;
             const len = @min(msg.len, status.len - 1);
@@ -575,12 +575,13 @@ pub fn defaultPanic(
             // A panic happened while trying to print a previous panic message.
             // We're still holding the mutex but that's fine as we're going to
             // call abort().
-            File.stderr().writeStreamingAll("aborting due to recursive panic\n") catch {};
+            const stderr, _ = lockStderrWriter(&.{});
+            stderr.writeAll("aborting due to recursive panic\n") catch {};
         },
         else => {}, // Panicked while printing the recursive panic message.
     }
 
-    posix.abort();
+    std.process.abort();
 }
 
 /// Must be called only after adding 1 to `panicking`. There are three callsites.
@@ -1596,7 +1597,8 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex
             // A segfault happened while trying to print a previous panic message.
             // We're still holding the mutex but that's fine as we're going to
             // call abort().
-            File.stderr().writeAll("aborting due to recursive panic\n") catch {};
+            const stderr, _ = lockStderrWriter(&.{});
+            stderr().writeAll("aborting due to recursive panic\n") catch {};
         },
         else => {}, // Panicked while printing the recursive panic message.
     }
@@ -1604,7 +1606,7 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex
     // We cannot allow the signal handler to return because when it runs the original instruction
     // again, the memory may be mapped and undefined behavior would occur rather than repeating
     // the segfault. So we simply abort here.
-    posix.abort();
+    std.process.abort();
 }
 
 pub fn dumpStackPointerAddr(prefix: []const u8) void {
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index e044a97620..bc84500419 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -674,7 +674,7 @@ test "Dir.Iterator but dir is deleted during iteration" {
     var iterator = subdir.iterate();
 
     // Create something to iterate over within the subdir
-    try tmp.dir.makePath("subdir" ++ fs.path.sep_str ++ "b");
+    try tmp.dir.makePath(io, "subdir" ++ fs.path.sep_str ++ "b");
 
     // Then, before iterating, delete the directory that we're iterating.
     // This is a contrived reproduction, but this could happen outside of the program, in another thread, etc.
@@ -1196,7 +1196,7 @@ test "deleteTree does not follow symlinks" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    try tmp.dir.makePath("b");
+    try tmp.dir.makePath(io, "b");
     {
         var a = try tmp.dir.makeOpenPath("a", .{});
         defer a.close(io);
@@ -1211,6 +1211,8 @@ test "deleteTree does not follow symlinks" {
 }
 
 test "deleteTree on a symlink" {
+    const io = testing.io;
+
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1223,7 +1225,7 @@ test "deleteTree on a symlink" {
     try tmp.dir.access("file", .{});
 
     // Symlink to a directory
-    try tmp.dir.makePath("dir");
+    try tmp.dir.makePath(io, "dir");
     try setupSymlink(tmp.dir, "dir", "dirlink", .{ .is_directory = true });
 
     try tmp.dir.deleteTree("dirlink");
@@ -1238,7 +1240,7 @@ test "makePath, put some files in it, deleteTree" {
             const allocator = ctx.arena.allocator();
             const dir_path = try ctx.transformPath("os_test_tmp");
 
-            try ctx.dir.makePath(try fs.path.join(allocator, &.{ "os_test_tmp", "b", "c" }));
+            try ctx.dir.makePath(io, try fs.path.join(allocator, &.{ "os_test_tmp", "b", "c" }));
             try ctx.dir.writeFile(.{
                 .sub_path = try fs.path.join(allocator, &.{ "os_test_tmp", "b", "c", "file.txt" }),
                 .data = "nonsense",
@@ -1261,7 +1263,7 @@ test "makePath, put some files in it, deleteTreeMinStackSize" {
             const allocator = ctx.arena.allocator();
             const dir_path = try ctx.transformPath("os_test_tmp");
 
-            try ctx.dir.makePath(try fs.path.join(allocator, &.{ "os_test_tmp", "b", "c" }));
+            try ctx.dir.makePath(io, try fs.path.join(allocator, &.{ "os_test_tmp", "b", "c" }));
             try ctx.dir.writeFile(.{
                 .sub_path = try fs.path.join(allocator, &.{ "os_test_tmp", "b", "c", "file.txt" }),
                 .data = "nonsense",
@@ -1280,21 +1282,25 @@ test "makePath, put some files in it, deleteTreeMinStackSize" {
 test "makePath in a directory that no longer exists" {
     if (native_os == .windows) return error.SkipZigTest; // Windows returns FileBusy if attempting to remove an open dir
 
+    const io = testing.io;
+
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
     try tmp.parent_dir.deleteTree(&tmp.sub_path);
 
-    try testing.expectError(error.FileNotFound, tmp.dir.makePath("sub-path"));
+    try testing.expectError(error.FileNotFound, tmp.dir.makePath(io, "sub-path"));
 }
 
 test "makePath but sub_path contains pre-existing file" {
+    const io = testing.io;
+
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
     try tmp.dir.makeDir("foo");
     try tmp.dir.writeFile(.{ .sub_path = "foo/bar", .data = "" });
 
-    try testing.expectError(error.NotDir, tmp.dir.makePath("foo/bar/baz"));
+    try testing.expectError(error.NotDir, tmp.dir.makePath(io, "foo/bar/baz"));
 }
 
 fn expectDir(io: Io, dir: Dir, path: []const u8) !void {
@@ -1314,7 +1320,7 @@ test "makepath existing directories" {
     try tmpA.makeDir("B");
 
     const testPath = "A" ++ fs.path.sep_str ++ "B" ++ fs.path.sep_str ++ "C";
-    try tmp.dir.makePath(testPath);
+    try tmp.dir.makePath(io, testPath);
 
     try expectDir(io, tmp.dir, testPath);
 }
@@ -1328,7 +1334,7 @@ test "makepath through existing valid symlink" {
     try tmp.dir.makeDir("realfolder");
     try setupSymlink(tmp.dir, "." ++ fs.path.sep_str ++ "realfolder", "working-symlink", .{});
 
-    try tmp.dir.makePath("working-symlink" ++ fs.path.sep_str ++ "in-realfolder");
+    try tmp.dir.makePath(io, "working-symlink" ++ fs.path.sep_str ++ "in-realfolder");
 
     try expectDir(io, tmp.dir, "realfolder" ++ fs.path.sep_str ++ "in-realfolder");
 }
@@ -1344,7 +1350,7 @@ test "makepath relative walks" {
     });
     defer testing.allocator.free(relPath);
 
-    try tmp.dir.makePath(relPath);
+    try tmp.dir.makePath(io, relPath);
 
     // How .. is handled is different on Windows than non-Windows
     switch (native_os) {
@@ -1383,7 +1389,7 @@ test "makepath ignores '.'" {
     });
     defer testing.allocator.free(expectedPath);
 
-    try tmp.dir.makePath(dotPath);
+    try tmp.dir.makePath(io, dotPath);
 
     try expectDir(io, tmp.dir, expectedPath);
 }
@@ -1550,10 +1556,11 @@ test "setEndPos" {
 test "access file" {
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
+            const io = ctx.io;
             const dir_path = try ctx.transformPath("os_test_tmp");
             const file_path = try ctx.transformPath("os_test_tmp" ++ fs.path.sep_str ++ "file.txt");
 
-            try ctx.dir.makePath(dir_path);
+            try ctx.dir.makePath(io, dir_path);
             try testing.expectError(error.FileNotFound, ctx.dir.access(file_path, .{}));
 
             try ctx.dir.writeFile(.{ .sub_path = file_path, .data = "" });
@@ -1569,7 +1576,7 @@ test "sendfile" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    try tmp.dir.makePath("os_test_tmp");
+    try tmp.dir.makePath(io, "os_test_tmp");
 
     var dir = try tmp.dir.openDir(io, "os_test_tmp", .{});
     defer dir.close(io);
@@ -1616,7 +1623,7 @@ test "sendfile with buffered data" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    try tmp.dir.makePath("os_test_tmp");
+    try tmp.dir.makePath(io, "os_test_tmp");
 
     var dir = try tmp.dir.openDir(io, "os_test_tmp", .{});
     defer dir.close(io);
@@ -1894,7 +1901,7 @@ test "walker" {
     });
 
     for (expected_paths.keys()) |key| {
-        try tmp.dir.makePath(key);
+        try tmp.dir.makePath(io, key);
     }
 
     var walker = try tmp.dir.walk(testing.allocator);
@@ -1956,7 +1963,7 @@ test "selective walker, skip entries that start with ." {
     });
 
     for (paths_to_create) |path| {
-        try tmp.dir.makePath(path);
+        try tmp.dir.makePath(io, path);
     }
 
     var walker = try tmp.dir.walkSelectively(testing.allocator);
@@ -1991,6 +1998,8 @@ test "selective walker, skip entries that start with ." {
 }
 
 test "walker without fully iterating" {
+    const io = testing.io;
+
     var tmp = tmpDir(.{ .iterate = true });
     defer tmp.cleanup();
 
@@ -2000,8 +2009,8 @@ test "walker without fully iterating" {
     // Create 2 directories inside the tmp directory, but then only iterate once before breaking.
     // This ensures that walker doesn't try to close the initial directory when not fully iterating.
 
-    try tmp.dir.makePath("a");
-    try tmp.dir.makePath("b");
+    try tmp.dir.makePath(io, "a");
+    try tmp.dir.makePath(io, "b");
 
     var num_walked: usize = 0;
     while (try walker.next()) |_| {
diff --git a/lib/std/os/linux/IoUring.zig b/lib/std/os/linux/IoUring.zig
index 3c9a313a4a..72b8369d68 100644
--- a/lib/std/os/linux/IoUring.zig
+++ b/lib/std/os/linux/IoUring.zig
@@ -4090,32 +4090,6 @@ test "openat_direct/close_direct" {
     try ring.unregister_files();
 }
 
-test "waitid" {
-    try skipKernelLessThan(.{ .major = 6, .minor = 7, .patch = 0 });
-
-    var ring = IoUring.init(16, 0) catch |err| switch (err) {
-        error.SystemOutdated => return error.SkipZigTest,
-        error.PermissionDenied => return error.SkipZigTest,
-        else => return err,
-    };
-    defer ring.deinit();
-
-    const pid = try posix.fork();
-    if (pid == 0) {
-        posix.exit(7);
-    }
-
-    var siginfo: posix.siginfo_t = undefined;
-    _ = try ring.waitid(0, .PID, pid, &siginfo, posix.W.EXITED, 0);
-
-    try testing.expectEqual(1, try ring.submit());
-
-    const cqe_waitid = try ring.copy_cqe();
-    try testing.expectEqual(0, cqe_waitid.res);
-    try testing.expectEqual(pid, siginfo.fields.common.first.piduid.pid);
-    try testing.expectEqual(7, siginfo.fields.common.second.sigchld.status);
-}
-
 /// For use in tests. Returns SkipZigTest if kernel version is less than required.
 inline fn skipKernelLessThan(required: std.SemanticVersion) !void {
     if (!is_linux) return error.SkipZigTest;
diff --git a/lib/std/posix.zig b/lib/std/posix.zig
index f4aa970413..42429a4993 100644
--- a/lib/std/posix.zig
+++ b/lib/std/posix.zig
@@ -615,66 +615,6 @@ fn getRandomBytesDevURandom(buf: []u8) GetRandomError!void {
     }
 }
 
-/// Causes abnormal process termination.
-/// If linking against libc, this calls the abort() libc function. Otherwise
-/// it raises SIGABRT followed by SIGKILL and finally lo
-/// Invokes the current signal handler for SIGABRT, if any.
-pub fn abort() noreturn {
-    @branchHint(.cold);
-    // MSVCRT abort() sometimes opens a popup window which is undesirable, so
-    // even when linking libc on Windows we use our own abort implementation.
-    // See https://github.com/ziglang/zig/issues/2071 for more details.
-    if (native_os == .windows) {
-        if (builtin.mode == .Debug and windows.peb().BeingDebugged != 0) {
-            @breakpoint();
-        }
-        windows.ntdll.RtlExitUserProcess(3);
-    }
-    if (!builtin.link_libc and native_os == .linux) {
-        // The Linux man page says that the libc abort() function
-        // "first unblocks the SIGABRT signal", but this is a footgun
-        // for user-defined signal handlers that want to restore some state in
-        // some program sections and crash in others.
-        // So, the user-installed SIGABRT handler is run, if present.
-        raise(.ABRT) catch {};
-
-        // Disable all signal handlers.
-        const filledset = linux.sigfillset();
-        sigprocmask(SIG.BLOCK, &filledset, null);
-
-        // Only one thread may proceed to the rest of abort().
-        if (!builtin.single_threaded) {
-            const global = struct {
-                var abort_entered: bool = false;
-            };
-            while (@cmpxchgWeak(bool, &global.abort_entered, false, true, .seq_cst, .seq_cst)) |_| {}
-        }
-
-        // Install default handler so that the tkill below will terminate.
-        const sigact = Sigaction{
-            .handler = .{ .handler = SIG.DFL },
-            .mask = sigemptyset(),
-            .flags = 0,
-        };
-        sigaction(.ABRT, &sigact, null);
-
-        _ = linux.tkill(linux.gettid(), .ABRT);
-
-        var sigabrtmask = sigemptyset();
-        sigaddset(&sigabrtmask, .ABRT);
-        sigprocmask(SIG.UNBLOCK, &sigabrtmask, null);
-
-        // Beyond this point should be unreachable.
-        @as(*allowzero volatile u8, @ptrFromInt(0)).* = 0;
-        raise(.KILL) catch {};
-        exit(127); // Pid 1 might not be signalled in some containers.
-    }
-    switch (native_os) {
-        .uefi, .wasi, .emscripten, .cuda, .amdhsa => @trap(),
-        else => system.abort(),
-    }
-}
-
 pub const RaiseError = UnexpectedError;
 
 pub fn raise(sig: SIG) RaiseError!void {
@@ -715,33 +655,6 @@ pub fn kill(pid: pid_t, sig: SIG) KillError!void {
     }
 }
 
-/// Exits all threads of the program with the specified status code.
-pub fn exit(status: u8) noreturn {
-    if (builtin.link_libc) {
-        std.c.exit(status);
-    }
-    if (native_os == .windows) {
-        windows.ntdll.RtlExitUserProcess(status);
-    }
-    if (native_os == .wasi) {
-        wasi.proc_exit(status);
-    }
-    if (native_os == .linux and !builtin.single_threaded) {
-        linux.exit_group(status);
-    }
-    if (native_os == .uefi) {
-        const uefi = std.os.uefi;
-        // exit() is only available if exitBootServices() has not been called yet.
-        // This call to exit should not fail, so we catch-ignore errors.
-        if (uefi.system_table.boot_services) |bs| {
-            bs.exit(uefi.handle, @enumFromInt(status), null) catch {};
-        }
-        // If we can't exit, reboot the system instead.
-        uefi.system_table.runtime_services.resetSystem(.cold, @enumFromInt(status), null);
-    }
-    system.exit(status);
-}
-
 pub const ReadError = std.Io.File.Reader.Error;
 
 /// Returns the number of bytes that were read, which can be less than
diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig
index dc63be6e14..169c5a70c2 100644
--- a/lib/std/posix/test.zig
+++ b/lib/std/posix/test.zig
@@ -667,73 +667,6 @@ test "writev longer than IOV_MAX" {
     try testing.expectEqual(@as(usize, posix.IOV_MAX), amt);
 }
 
-test "POSIX file locking with fcntl" {
-    if (native_os == .windows or native_os == .wasi) {
-        // Not POSIX.
-        return error.SkipZigTest;
-    }
-
-    if (true) {
-        // https://github.com/ziglang/zig/issues/11074
-        return error.SkipZigTest;
-    }
-
-    const io = testing.io;
-
-    var tmp = tmpDir(.{});
-    defer tmp.cleanup();
-
-    // Create a temporary lock file
-    var file = try tmp.dir.createFile(io, "lock", .{ .read = true });
-    defer file.close(io);
-    try file.setEndPos(2);
-    const fd = file.handle;
-
-    // Place an exclusive lock on the first byte, and a shared lock on the second byte:
-    var struct_flock = std.mem.zeroInit(posix.Flock, .{ .type = posix.F.WRLCK });
-    _ = try posix.fcntl(fd, posix.F.SETLK, @intFromPtr(&struct_flock));
-    struct_flock.start = 1;
-    struct_flock.type = posix.F.RDLCK;
-    _ = try posix.fcntl(fd, posix.F.SETLK, @intFromPtr(&struct_flock));
-
-    // Check the locks in a child process:
-    const pid = try posix.fork();
-    if (pid == 0) {
-        // child expects be denied the exclusive lock:
-        struct_flock.start = 0;
-        struct_flock.type = posix.F.WRLCK;
-        try expectError(error.Locked, posix.fcntl(fd, posix.F.SETLK, @intFromPtr(&struct_flock)));
-        // child expects to get the shared lock:
-        struct_flock.start = 1;
-        struct_flock.type = posix.F.RDLCK;
-        _ = try posix.fcntl(fd, posix.F.SETLK, @intFromPtr(&struct_flock));
-        // child waits for the exclusive lock in order to test deadlock:
-        struct_flock.start = 0;
-        struct_flock.type = posix.F.WRLCK;
-        _ = try posix.fcntl(fd, posix.F.SETLKW, @intFromPtr(&struct_flock));
-        // child exits without continuing:
-        posix.exit(0);
-    } else {
-        // parent waits for child to get shared lock:
-        std.Thread.sleep(1 * std.time.ns_per_ms);
-        // parent expects deadlock when attempting to upgrade the shared lock to exclusive:
-        struct_flock.start = 1;
-        struct_flock.type = posix.F.WRLCK;
-        try expectError(error.DeadLock, posix.fcntl(fd, posix.F.SETLKW, @intFromPtr(&struct_flock)));
-        // parent releases exclusive lock:
-        struct_flock.start = 0;
-        struct_flock.type = posix.F.UNLCK;
-        _ = try posix.fcntl(fd, posix.F.SETLK, @intFromPtr(&struct_flock));
-        // parent releases shared lock:
-        struct_flock.start = 1;
-        struct_flock.type = posix.F.UNLCK;
-        _ = try posix.fcntl(fd, posix.F.SETLK, @intFromPtr(&struct_flock));
-        // parent waits for child:
-        const result = posix.waitpid(pid, 0);
-        try expect(result.status == 0 * 256);
-    }
-}
-
 test "rename smoke test" {
     if (native_os == .wasi) return error.SkipZigTest;
     if (native_os == .windows) return error.SkipZigTest;
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 5d60190c2b..f7ecf5fdc2 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -16,8 +16,6 @@ const unicode = std.unicode;
 const max_path_bytes = std.fs.max_path_bytes;
 
 pub const Child = @import("process/Child.zig");
-pub const abort = posix.abort;
-pub const exit = posix.exit;
 pub const changeCurDir = posix.chdir;
 pub const changeCurDirZ = posix.chdirZ;
 
@@ -2208,3 +2206,87 @@ pub const OpenExecutableError = File.OpenError || ExecutablePathError || File.Lo
 pub fn openExecutable(io: Io, flags: File.OpenFlags) OpenExecutableError!File {
     return io.vtable.processExecutableOpen(io.userdata, flags);
 }
+
+/// Causes abnormal process termination.
+///
+/// If linking against libc, this calls `std.c.abort`. Otherwise it raises
+/// SIGABRT followed by SIGKILL.
+///
+/// Invokes the current signal handler for SIGABRT, if any.
+pub fn abort() noreturn {
+    @branchHint(.cold);
+    // MSVCRT abort() sometimes opens a popup window which is undesirable, so
+    // even when linking libc on Windows we use our own abort implementation.
+    // See https://github.com/ziglang/zig/issues/2071 for more details.
+    if (native_os == .windows) {
+        if (builtin.mode == .Debug and windows.peb().BeingDebugged != 0) {
+            @breakpoint();
+        }
+        windows.ntdll.RtlExitUserProcess(3);
+    }
+    if (!builtin.link_libc and native_os == .linux) {
+        // The Linux man page says that the libc abort() function
+        // "first unblocks the SIGABRT signal", but this is a footgun
+        // for user-defined signal handlers that want to restore some state in
+        // some program sections and crash in others.
+        // So, the user-installed SIGABRT handler is run, if present.
+        posix.raise(.ABRT) catch {};
+
+        // Disable all signal handlers.
+        const filledset = std.os.linux.sigfillset();
+        posix.sigprocmask(posix.SIG.BLOCK, &filledset, null);
+
+        // Only one thread may proceed to the rest of abort().
+        if (!builtin.single_threaded) {
+            const global = struct {
+                var abort_entered: bool = false;
+            };
+            while (@cmpxchgWeak(bool, &global.abort_entered, false, true, .seq_cst, .seq_cst)) |_| {}
+        }
+
+        // Install default handler so that the tkill below will terminate.
+        const sigact: posix.Sigaction = .{
+            .handler = .{ .handler = posix.SIG.DFL },
+            .mask = posix.sigemptyset(),
+            .flags = 0,
+        };
+        posix.sigaction(.ABRT, &sigact, null);
+
+        _ = std.os.linux.tkill(std.os.linux.gettid(), .ABRT);
+
+        var sigabrtmask = posix.sigemptyset();
+        posix.sigaddset(&sigabrtmask, .ABRT);
+        posix.sigprocmask(posix.SIG.UNBLOCK, &sigabrtmask, null);
+
+        // Beyond this point should be unreachable.
+        @as(*allowzero volatile u8, @ptrFromInt(0)).* = 0;
+        posix.raise(.KILL) catch {};
+        exit(127); // Pid 1 might not be signalled in some containers.
+    }
+    switch (native_os) {
+        .uefi, .wasi, .emscripten, .cuda, .amdhsa => @trap(),
+        else => posix.system.abort(),
+    }
+}
+
+/// Exits all threads of the program with the specified status code.
+pub fn exit(status: u8) noreturn {
+    if (builtin.link_libc) {
+        std.c.exit(status);
+    } else switch (native_os) {
+        .windows => windows.ntdll.RtlExitUserProcess(status),
+        .wasi => std.os.wasi.proc_exit(status),
+        .linux => if (!builtin.single_threaded) std.os.linux.exit_group(status),
+        .uefi => {
+            const uefi = std.os.uefi;
+            // exit() is only available if exitBootServices() has not been called yet.
+            // This call to exit should not fail, so we catch-ignore errors.
+            if (uefi.system_table.boot_services) |bs| {
+                bs.exit(uefi.handle, @enumFromInt(status), null) catch {};
+            }
+            // If we can't exit, reboot the system instead.
+            uefi.system_table.runtime_services.resetSystem(.cold, @enumFromInt(status), null);
+        },
+        else => posix.system.exit(status),
+    }
+}
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index 33faeef061..4521cd511f 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -1050,7 +1050,7 @@ fn forkChildErrReport(fd: i32, err: ChildProcess.SpawnError) noreturn {
         // The _exit(2) function does nothing but make the exit syscall, unlike exit(3)
         std.c._exit(1);
     }
-    posix.exit(1);
+    posix.system.exit(1);
 }
 
 fn writeIntFd(fd: i32, value: ErrInt) !void {
diff --git a/lib/std/start.zig b/lib/std/start.zig
index a5bec41231..64a1c17175 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -110,7 +110,7 @@ fn main2() callconv(.c) c_int {
 }
 
 fn _start2() callconv(.withStackAlign(.c, 1)) noreturn {
-    std.posix.exit(callMain());
+    std.process.exit(callMain());
 }
 
 fn spirvMain2() callconv(.kernel) void {
@@ -118,7 +118,7 @@ fn spirvMain2() callconv(.kernel) void {
 }
 
 fn wWinMainCRTStartup2() callconv(.c) noreturn {
-    std.posix.exit(callMain());
+    std.process.exit(callMain());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -627,7 +627,7 @@ fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.c) noreturn {
         for (slice) |func| func();
     }
 
-    std.posix.exit(callMainWithArgs(argc, argv, envp));
+    std.process.exit(callMainWithArgs(argc, argv, envp));
 }
 
 fn expandStackSize(phdrs: []elf.Phdr) void {
diff --git a/lib/std/tar.zig b/lib/std/tar.zig
index 8a0bbb342f..b2a5306458 100644
--- a/lib/std/tar.zig
+++ b/lib/std/tar.zig
@@ -606,7 +606,7 @@ pub fn pipeToFileSystem(io: Io, dir: Io.Dir, reader: *Io.Reader, options: PipeOp
         switch (file.kind) {
             .directory => {
                 if (file_name.len > 0 and !options.exclude_empty_directories) {
-                    try dir.makePath(file_name);
+                    try dir.makePath(io, file_name);
                 }
             },
             .file => {
@@ -625,7 +625,7 @@ pub fn pipeToFileSystem(io: Io, dir: Io.Dir, reader: *Io.Reader, options: PipeOp
             },
             .sym_link => {
                 const link_name = file.link_name;
-                createDirAndSymlink(dir, link_name, file_name) catch |err| {
+                createDirAndSymlink(io, dir, link_name, file_name) catch |err| {
                     const d = options.diagnostics orelse return error.UnableToCreateSymLink;
                     try d.errors.append(d.allocator, .{ .unable_to_create_sym_link = .{
                         .code = err,
@@ -642,7 +642,7 @@ fn createDirAndFile(io: Io, dir: Io.Dir, file_name: []const u8, mode: Io.File.Mo
     const fs_file = dir.createFile(io, file_name, .{ .exclusive = true, .mode = mode }) catch |err| {
         if (err == error.FileNotFound) {
             if (std.fs.path.dirname(file_name)) |dir_name| {
-                try dir.makePath(dir_name);
+                try dir.makePath(io, dir_name);
                 return try dir.createFile(io, file_name, .{ .exclusive = true, .mode = mode });
             }
         }
@@ -652,11 +652,11 @@ fn createDirAndFile(io: Io, dir: Io.Dir, file_name: []const u8, mode: Io.File.Mo
 }
 
 // Creates a symbolic link at path `file_name` which points to `link_name`.
-fn createDirAndSymlink(dir: Io.Dir, link_name: []const u8, file_name: []const u8) !void {
+fn createDirAndSymlink(io: Io, dir: Io.Dir, link_name: []const u8, file_name: []const u8) !void {
     dir.symLink(link_name, file_name, .{}) catch |err| {
         if (err == error.FileNotFound) {
             if (std.fs.path.dirname(file_name)) |dir_name| {
-                try dir.makePath(dir_name);
+                try dir.makePath(io, dir_name);
                 return try dir.symLink(link_name, file_name, .{});
             }
         }
@@ -885,15 +885,15 @@ test "create file and symlink" {
     file = try createDirAndFile(io, root.dir, "a/b/c/file2", default_mode);
     file.close(io);
 
-    createDirAndSymlink(root.dir, "a/b/c/file2", "symlink1") catch |err| {
+    createDirAndSymlink(io, root.dir, "a/b/c/file2", "symlink1") catch |err| {
         // On Windows when developer mode is not enabled
         if (err == error.AccessDenied) return error.SkipZigTest;
         return err;
     };
-    try createDirAndSymlink(root.dir, "../../../file1", "d/e/f/symlink2");
+    try createDirAndSymlink(io, root.dir, "../../../file1", "d/e/f/symlink2");
 
     // Danglink symlnik, file created later
-    try createDirAndSymlink(root.dir, "../../../g/h/i/file4", "j/k/l/symlink3");
+    try createDirAndSymlink(io, root.dir, "../../../g/h/i/file4", "j/k/l/symlink3");
     file = try createDirAndFile(io, root.dir, "g/h/i/file4", default_mode);
     file.close(io);
 }
diff --git a/lib/std/zip.zig b/lib/std/zip.zig
index 9d08847092..acb3fc65ab 100644
--- a/lib/std/zip.zig
+++ b/lib/std/zip.zig
@@ -464,6 +464,8 @@ pub const Iterator = struct {
             filename_buf: []u8,
             dest: Io.Dir,
         ) !void {
+            const io = stream.io;
+
             if (filename_buf.len < self.filename_len)
                 return error.ZipInsufficientBuffer;
             switch (self.compression_method) {
@@ -552,12 +554,10 @@ pub const Iterator = struct {
             if (filename[filename.len - 1] == '/') {
                 if (self.uncompressed_size != 0)
                     return error.ZipBadDirectorySize;
-                try dest.makePath(filename[0 .. filename.len - 1]);
+                try dest.makePath(io, filename[0 .. filename.len - 1]);
                 return;
             }
 
-            const io = stream.io;
-
             const out_file = blk: {
                 if (std.fs.path.dirname(filename)) |dirname| {
                     var parent_dir = try dest.makeOpenPath(dirname, .{});