wasi: split with-libc and without-libc implementations

Make a clearer separation between the Posix defines for WASI without a
libc (the `system` defined in posix.zig) and the Posix defines for WASI
with a libc (which should mirror the Musl-based wasi-libc implementation,
and are defined in c.zig).

Make WASI `posix.O` look more POSIX-y when compiling without libc.  These
structures and constants do not need to mirror the with-libc Wasi API
(e.g., can use `.ACCMODE`).  This removes some Wasi-specific code in
Dir.zig and posix.zig by making the structure use names consistent with
other platforms.  Define `.S`, `.timespec`, and `.AT` structs for
Wasi-without-libc in posix.zig.  These are based on the wasi-with-libc
structures, but cleaned up to remove cruft like padding or wholly
unsupported fields.

Fix `.S` and `.AT` constants on wasi-with-libc (defined in c.zig) to match
wasi-libc headers.

Define `mode_t` type as `void` for wasi targets because file permissions
are not supported via the Posix APIS on these platforms.  Use `mode_t` as
the parameter type in Zig's mkdir\* and openat\* wrappers.

Re-enable a lot of tests that have accumulated stale not-on-wasi guards,
and simplify some tests (e.g., dropping unnecessary absolute paths) so
they can run on wasi targets.

Author: rootbeer

lib/std/Build/Step/Run.zig

@@ -1088,7 +1088,7 @@ fn runCommand(
                         // the `--` before the module name. This appears to work for both old and
                         // new Wasmtime versions.
                         try interp_argv.append(bin_name);
-                        try interp_argv.append("--dir=.");
+                        try interp_argv.append("--dir=."); // Preopen '.' at file descriptor 3 for cwd
                         try interp_argv.append("--");
                         try interp_argv.append(argv[0]);
                         try interp_argv.appendSlice(argv[1..]);

lib/std/c.zig

@@ -133,9 +133,11 @@ pub const dev_t = switch (native_os) {
 pub const mode_t = switch (native_os) {
     .linux => linux.mode_t,
     .emscripten => emscripten.mode_t,
-    .openbsd, .haiku, .netbsd, .solaris, .illumos, .wasi => u32,
+    .openbsd, .haiku, .netbsd, .solaris, .illumos => u32,
     .freebsd, .macos, .ios, .tvos, .watchos, .visionos => u16,
-    else => u0,
+    .wasi => void,
+    .windows => u0,
+    else => u0, // TODO: should be void?
 };
 
 pub const nlink_t = switch (native_os) {
@@ -1702,17 +1704,15 @@ pub const S = switch (native_os) {
     .linux => linux.S,
     .emscripten => emscripten.S,
     .wasi => struct {
-        pub const IEXEC = @compileError("TODO audit this");
+        // Match wasi-libc's libc-bottom-half/headers/public/__mode_t.h
         pub const IFBLK = 0x6000;
         pub const IFCHR = 0x2000;
         pub const IFDIR = 0x4000;
-        pub const IFIFO = 0xc000;
+        pub const IFIFO = 0x1000;
         pub const IFLNK = 0xa000;
-        pub const IFMT = IFBLK | IFCHR | IFDIR | IFIFO | IFLNK | IFREG | IFSOCK;
         pub const IFREG = 0x8000;
-        /// There's no concept of UNIX domain socket but we define this value here
-        /// in order to line with other OSes.
-        pub const IFSOCK = 0x1;
+        pub const IFSOCK = 0xc000;
+        pub const IFMT = IFBLK | IFCHR | IFDIR | IFIFO | IFLNK | IFREG | IFSOCK;
     },
     .macos, .ios, .tvos, .watchos, .visionos => struct {
         pub const IFMT = 0o170000;
@@ -6362,6 +6362,7 @@ pub const Stat = switch (native_os) {
     },
     .emscripten => emscripten.Stat,
     .wasi => extern struct {
+        // Matches wasi-libc's libc-bottom-half/headers/public/__struct_stat.h
         dev: dev_t,
         ino: ino_t,
         nlink: nlink_t,
@@ -7061,17 +7062,13 @@ pub const AT = switch (native_os) {
         pub const RECURSIVE = 0x8000;
     },
     .wasi => struct {
-        pub const SYMLINK_NOFOLLOW = 0x100;
-        pub const SYMLINK_FOLLOW = 0x400;
-        pub const REMOVEDIR: u32 = 0x4;
-        /// When linking libc, we follow their convention and use -2 for current working directory.
-        /// However, without libc, Zig does a different convention: it assumes the
-        /// current working directory is the first preopen. This behavior can be
-        /// overridden with a public function called `wasi_cwd` in the root source
-        /// file.
-        pub const FDCWD: fd_t = if (builtin.link_libc) -2 else 3;
+        // Match AT_* constants in wasi-libc libc-bottom-half/headers/public/__header_fcntl.h
+        pub const FDCWD = -2;
+        pub const EACCESS = 0x0;
+        pub const SYMLINK_NOFOLLOW = 0x1;
+        pub const SYMLINK_FOLLOW = 0x2;
+        pub const REMOVEDIR = 0x4;
     },
-
     else => void,
 };
 
@@ -7100,6 +7097,7 @@ pub const O = switch (native_os) {
         _: u9 = 0,
     },
     .wasi => packed struct(u32) {
+        // Match layout from wasi-libc libc-bottom-half/headers/public/__header_fcntl.h
         APPEND: bool = false,
         DSYNC: bool = false,
         NONBLOCK: bool = false,
@@ -7112,10 +7110,17 @@ pub const O = switch (native_os) {
         TRUNC: bool = false,
         _16: u8 = 0,
         NOFOLLOW: bool = false,
+
+        // Logical O_ACCMODE is the following 4 bits, note O_SEARCH is between RD and WR,
+        // so can't easily reuse std.posix.ACCMODE in this struct.
         EXEC: bool = false,
-        read: bool = false,
+        RDONLY: bool = true, // equivalent to "ACCMODE = .RDONLY" default
         SEARCH: bool = false,
-        write: bool = false,
+        WRONLY: bool = false,
+
+        // CLOEXEC, TTY_ININT, NOCTTY are mapped 0, so they're silently
+        // ignored in C code.
+
         _: u3 = 0,
     },
     .solaris, .illumos => packed struct(u32) {
@@ -8945,6 +8950,7 @@ pub const gettimeofday = switch (native_os) {
 
 pub const msync = switch (native_os) {
     .netbsd => private.__msync13,
+    .wasi => {},
     else => private.msync,
 };
 
@@ -9087,8 +9093,8 @@ pub const fork = switch (native_os) {
 pub extern "c" fn access(path: [*:0]const u8, mode: c_uint) c_int;
 pub extern "c" fn faccessat(dirfd: fd_t, path: [*:0]const u8, mode: c_uint, flags: c_uint) c_int;
 pub extern "c" fn pipe(fds: *[2]fd_t) c_int;
-pub extern "c" fn mkdir(path: [*:0]const u8, mode: c_uint) c_int;
-pub extern "c" fn mkdirat(dirfd: fd_t, path: [*:0]const u8, mode: u32) c_int;
+pub extern "c" fn mkdir(path: [*:0]const u8, mode: usize) c_int;
+pub extern "c" fn mkdirat(dirfd: fd_t, path: [*:0]const u8, mode: usize) c_int;
 pub extern "c" fn symlink(existing: [*:0]const u8, new: [*:0]const u8) c_int;
 pub extern "c" fn symlinkat(oldpath: [*:0]const u8, newdirfd: fd_t, newpath: [*:0]const u8) c_int;
 pub extern "c" fn rename(old: [*:0]const u8, new: [*:0]const u8) c_int;

lib/std/debug.zig

@@ -1030,7 +1030,7 @@ test printLineFromFileAnyOs {
         output.clearRetainingCapacity();
     }
     {
-        const path = try fs.path.join(allocator, &.{ test_dir_path, "three_lines.zig" });
+        const path = try join(allocator, &.{ test_dir_path, "three_lines.zig" });
         defer allocator.free(path);
         try test_dir.dir.writeFile(.{
             .sub_path = "three_lines.zig",
@@ -1052,7 +1052,7 @@ test printLineFromFileAnyOs {
     {
         const file = try test_dir.dir.createFile("line_overlaps_page_boundary.zig", .{});
         defer file.close();
-        const path = try fs.path.join(allocator, &.{ test_dir_path, "line_overlaps_page_boundary.zig" });
+        const path = try join(allocator, &.{ test_dir_path, "line_overlaps_page_boundary.zig" });
         defer allocator.free(path);
 
         const overlap = 10;
@@ -1068,7 +1068,7 @@ test printLineFromFileAnyOs {
     {
         const file = try test_dir.dir.createFile("file_ends_on_page_boundary.zig", .{});
         defer file.close();
-        const path = try fs.path.join(allocator, &.{ test_dir_path, "file_ends_on_page_boundary.zig" });
+        const path = try join(allocator, &.{ test_dir_path, "file_ends_on_page_boundary.zig" });
         defer allocator.free(path);
 
         var writer = file.writer();
@@ -1081,7 +1081,7 @@ test printLineFromFileAnyOs {
     {
         const file = try test_dir.dir.createFile("very_long_first_line_spanning_multiple_pages.zig", .{});
         defer file.close();
-        const path = try fs.path.join(allocator, &.{ test_dir_path, "very_long_first_line_spanning_multiple_pages.zig" });
+        const path = try join(allocator, &.{ test_dir_path, "very_long_first_line_spanning_multiple_pages.zig" });
         defer allocator.free(path);
 
         var writer = file.writer();
@@ -1106,7 +1106,7 @@ test printLineFromFileAnyOs {
     {
         const file = try test_dir.dir.createFile("file_of_newlines.zig", .{});
         defer file.close();
-        const path = try fs.path.join(allocator, &.{ test_dir_path, "file_of_newlines.zig" });
+        const path = try join(allocator, &.{ test_dir_path, "file_of_newlines.zig" });
         defer allocator.free(path);
 
         var writer = file.writer();

lib/std/fs/Dir.zig

@@ -2,7 +2,12 @@ fd: Handle,
 
 pub const Handle = posix.fd_t;
 
-pub const default_mode = 0o755;
+/// Default mode bits for a new directory.
+pub const default_mode = switch (posix.mode_t) {
+    void => {}, // wasi-without-libc has no mode suppport
+    u0 => 0, // Zig's Posix layer doesn't support modes on Windows
+    else => 0o755,
+};
 
 pub const Entry = struct {
     name: []const u8,
@@ -831,32 +836,19 @@ pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.Ope
 
 /// Same as `openFile` but the path parameter is null-terminated.
 pub fn openFileZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) File.OpenError!File {
-    switch (native_os) {
-        .windows => {
-            const path_w = try windows.cStrToPrefixedFileW(self.fd, sub_path);
-            return self.openFileW(path_w.span(), flags);
-        },
-        // Use the libc API when libc is linked because it implements things
-        // such as opening absolute file paths.
-        .wasi => if (!builtin.link_libc) {
-            return openFile(self, mem.sliceTo(sub_path, 0), flags);
-        },
-        else => {},
+    if (native_os == .windows) {
+        const path_w = try windows.cStrToPrefixedFileW(self.fd, sub_path);
+        return self.openFileW(path_w.span(), flags);
+    }
+    if (native_os == .wasi and !builtin.link_libc) {
+        return openFile(self, mem.sliceTo(sub_path, 0), flags);
     }
 
-    var os_flags: posix.O = switch (native_os) {
-        .wasi => .{
-            .read = flags.mode != .write_only,
-            .write = flags.mode != .read_only,
-        },
-        else => .{
-            .ACCMODE = switch (flags.mode) {
-                .read_only => .RDONLY,
-                .write_only => .WRONLY,
-                .read_write => .RDWR,
-            },
-        },
-    };
+    var os_flags: posix.O = std.posix.makeOFlags(switch (flags.mode) {
+        .read_only => .RDONLY,
+        .write_only => .WRONLY,
+        .read_write => .RDWR,
+    }, .{});
     if (@hasField(posix.O, "CLOEXEC")) os_flags.CLOEXEC = true;
     if (@hasField(posix.O, "LARGEFILE")) os_flags.LARGEFILE = true;
     if (@hasField(posix.O, "NOCTTY")) os_flags.NOCTTY = !flags.allow_ctty;
@@ -879,7 +871,8 @@ pub fn openFileZ(self: Dir, sub_path: [*:0]const u8, flags: File.OpenFlags) File
             },
         }
     }
-    const fd = try posix.openatZ(self.fd, sub_path, os_flags, 0);
+    const mode = if (posix.mode_t == void) {} else 0;
+    const fd = try posix.openatZ(self.fd, sub_path, os_flags, mode);
     errdefer posix.close(fd);
 
     if (have_flock and !has_flock_open_flags and flags.lock != .none) {
@@ -1002,12 +995,11 @@ pub fn createFileZ(self: Dir, sub_path_c: [*:0]const u8, flags: File.CreateFlags
         else => {},
     }
 
-    var os_flags: posix.O = .{
-        .ACCMODE = if (flags.read) .RDWR else .WRONLY,
+    var os_flags: posix.O = std.posix.makeOFlags(if (flags.read) .RDWR else .WRONLY, .{
         .CREAT = true,
         .TRUNC = flags.truncate,
         .EXCL = flags.exclusive,
-    };
+    });
     if (@hasField(posix.O, "LARGEFILE")) os_flags.LARGEFILE = true;
     if (@hasField(posix.O, "CLOEXEC")) os_flags.CLOEXEC = true;
 
@@ -1270,7 +1262,7 @@ pub const RealPathError = posix.RealPathError;
 /// See also `Dir.realpathZ`, `Dir.realpathW`, and `Dir.realpathAlloc`.
 pub fn realpath(self: Dir, pathname: []const u8, out_buffer: []u8) RealPathError![]u8 {
     if (native_os == .wasi) {
-        @compileError("realpath is not available on WASI");
+        @compileError("WASI does not support absolute paths");
     }
     if (native_os == .windows) {
         const pathname_w = try windows.sliceToPrefixedFileW(self.fd, pathname);
@@ -1283,22 +1275,18 @@ pub fn realpath(self: Dir, pathname: []const u8, out_buffer: []u8) RealPathError
 /// Same as `Dir.realpath` except `pathname` is null-terminated.
 /// See also `Dir.realpath`, `realpathZ`.
 pub fn realpathZ(self: Dir, pathname: [*:0]const u8, out_buffer: []u8) RealPathError![]u8 {
+    if (native_os == .wasi) {
+        @compileError("WASI does not support absolute paths");
+    }
     if (native_os == .windows) {
         const pathname_w = try windows.cStrToPrefixedFileW(self.fd, pathname);
         return self.realpathW(pathname_w.span(), out_buffer);
     }
 
-    const flags: posix.O = switch (native_os) {
-        .linux => .{
-            .NONBLOCK = true,
-            .CLOEXEC = true,
-            .PATH = true,
-        },
-        else => .{
-            .NONBLOCK = true,
-            .CLOEXEC = true,
-        },
-    };
+    var flags: posix.O = .{};
+    if (@hasField(posix.O, "NONBLOCK")) flags.NONBLOCK = true;
+    if (@hasField(posix.O, "CLOEXEC")) flags.CLOEXEC = true;
+    if (@hasField(posix.O, "PATH")) flags.PATH = true;
 
     const fd = posix.openatZ(self.fd, pathname, flags, 0) catch |err| switch (err) {
         error.FileLocksNotSupported => return error.Unexpected,
@@ -1511,19 +1499,13 @@ pub fn openDirZ(self: Dir, sub_path_c: [*:0]const u8, args: OpenOptions) OpenErr
         else => {},
     }
 
-    var symlink_flags: posix.O = switch (native_os) {
-        .wasi => .{
-            .read = true,
-            .NOFOLLOW = args.no_follow,
-            .DIRECTORY = true,
-        },
-        else => .{
-            .ACCMODE = .RDONLY,
-            .NOFOLLOW = args.no_follow,
-            .DIRECTORY = true,
-            .CLOEXEC = true,
-        },
-    };
+    var symlink_flags: posix.O = std.posix.makeOFlags(.RDONLY, .{
+        .NOFOLLOW = args.no_follow,
+        .DIRECTORY = true,
+    });
+
+    if (@hasField(posix.O, "CLOEXEC"))
+        symlink_flags.CLOEXEC = true;
 
     if (@hasField(posix.O, "PATH") and !args.iterate)
         symlink_flags.PATH = true;
@@ -1556,7 +1538,8 @@ pub fn openDirW(self: Dir, sub_path_w: [*:0]const u16, args: OpenOptions) OpenEr
 /// Asserts `flags` has `DIRECTORY` set.
 fn openDirFlagsZ(self: Dir, sub_path_c: [*:0]const u8, flags: posix.O) OpenError!Dir {
     assert(flags.DIRECTORY);
-    const fd = posix.openatZ(self.fd, sub_path_c, flags, 0) catch |err| switch (err) {
+    const mode = if (posix.mode_t == void) {} else 0;
+    const fd = posix.openatZ(self.fd, sub_path_c, flags, mode) catch |err| switch (err) {
         error.FileTooBig => unreachable, // can't happen for directories
         error.IsDir => unreachable, // we're setting DIRECTORY
         error.NoSpaceLeft => unreachable, // not setting CREAT

lib/std/fs/File.zig

@@ -27,9 +27,9 @@ pub const Kind = enum {
 /// the `touch` command, which would correspond to `0o644`. However, POSIX
 /// libc implementations use `0o666` inside `fopen` and then rely on the
 /// process-scoped "umask" setting to adjust this number for file creation.
-pub const default_mode = switch (builtin.os.tag) {
-    .windows => 0,
-    .wasi => 0,
+pub const default_mode = switch (posix.mode_t) {
+    void => {}, // WASI-without-libc has no mode support
+    u0 => 0, // Zig's Posix layer doesn't support modes for Windows
     else => 0o666,
 };
 
@@ -381,7 +381,7 @@ pub const Stat = struct {
     /// is unique to each filesystem.
     inode: INode,
     size: u64,
-    /// This is available on POSIX systems and is always 0 otherwise.
+    /// This is available on POSIX systems and is {} otherwise.
     mode: Mode,
     kind: Kind,
 
@@ -399,7 +399,7 @@ pub const Stat = struct {
         return .{
             .inode = st.ino,
             .size = @bitCast(st.size),
-            .mode = st.mode,
+            .mode = if (Mode == void) {} else st.mode,
             .kind = k: {
                 const m = st.mode & posix.S.IFMT;
                 switch (m) {
@@ -455,7 +455,7 @@ pub const Stat = struct {
         return .{
             .inode = st.ino,
             .size = @bitCast(st.size),
-            .mode = 0,
+            .mode = {},
             .kind = switch (st.filetype) {
                 .BLOCK_DEVICE => .block_device,
                 .CHARACTER_DEVICE => .character_device,