Linux: Nuke Stat bits in favour of statx

Maintaining the POSIX `stat` bits for Zig is a pain. Not only is `struct
stat` incompatable between architectures, but maddingly annoying so;
timestamps are specified as machine longs or fixed-width ints, members
can be signed or unsigned. The libcs deal with this by introducing the
own version of `struct stat` and copying the kernel structure members to
it. In the case of glibc, they did it twice thanks to the largefile
transition!

In practice, the project needs to maintain three versions of `struct
stat`:
- What the kernel defines.
- What musl wants for `struct stat`.
- What glibc wants for `struct stat64`. Make sure to use `fstatat64`!

And it's not as simple as running `zig translate-c`. In #21440 I had to
create test programs in C and use `pahole` to dump the structure of
`stat` for each arch, and I was constantly running into issue regarding
padding and signed/unsigned ints. The fact that so many target checks in
the `linux` and `posix` tests exist is most likely due to writing to
padding bits and failing later.

The solution to this madness is `statx(2)`:
- It takes a single structure that is the same for all arches AND libcs.
- It uses a custom timestamp format, but it is 64-bit ready.
- It gives the same info as `fstatat(2)` and more!
- Unlike `fstatat(2)`, you can request a subset of the info required
  based on passing a mask.

It's so good that modern Linux arches (e.g. riscv) don't even implement
`stat`, with the libcs using a generic `struct stat` and copying from
`struct statx`.

Therefore, this commit rips out all the `stat` bits from `std.os.linux`
and `std.c`. `std.posix.Stat` is now `void`, and calling
`std.posix.*stat` is an compile-time error. A wrapper around `statx` has
been added to `std.os.linux`, and callers have been upgraded to use it.
Tests have also been updated to use `statx` where possible.

While I was here, I converted the mask and file attributes to be packed
struct bitfields. A nice side effect is checking that you actually
recieved the members you asked for via `Statx.mask`, which I have used
by adding `assert`s at specific callsites.

In the future I expect types like `mode_t`/`dev_t` to be audited and
removed, as they aren't being used to define members of `struct stat`.

Author: The-King-of-Toasters

lib/std/c.zig

@@ -7463,166 +7463,6 @@ pub const EAI = if (builtin.abi.isAndroid()) enum(c_int) {
 pub const dl_iterate_phdr_callback = *const fn (info: *dl_phdr_info, size: usize, data: ?*anyopaque) callconv(.c) c_int;
 
 pub const Stat = switch (native_os) {
-    .linux => switch (native_arch) {
-        .sparc64 => extern struct {
-            dev: u64,
-            __pad1: u16,
-            ino: ino_t,
-            mode: u32,
-            nlink: u32,
-
-            uid: u32,
-            gid: u32,
-            rdev: u64,
-            __pad2: u16,
-
-            size: off_t,
-            blksize: isize,
-            blocks: i64,
-
-            atim: timespec,
-            mtim: timespec,
-            ctim: timespec,
-            __reserved: [2]usize,
-
-            pub fn atime(self: @This()) timespec {
-                return self.atim;
-            }
-
-            pub fn mtime(self: @This()) timespec {
-                return self.mtim;
-            }
-
-            pub fn ctime(self: @This()) timespec {
-                return self.ctim;
-            }
-        },
-        .mips, .mipsel => if (builtin.target.abi.isMusl()) extern struct {
-            dev: dev_t,
-            __pad0: [2]i32,
-            ino: ino_t,
-            mode: mode_t,
-            nlink: nlink_t,
-            uid: uid_t,
-            gid: gid_t,
-            rdev: dev_t,
-            __pad1: [2]i32,
-            size: off_t,
-            atim: timespec,
-            mtim: timespec,
-            ctim: timespec,
-            blksize: blksize_t,
-            __pad3: i32,
-            blocks: blkcnt_t,
-            __pad4: [14]i32,
-
-            pub fn atime(self: @This()) timespec {
-                return self.atim;
-            }
-
-            pub fn mtime(self: @This()) timespec {
-                return self.mtim;
-            }
-
-            pub fn ctime(self: @This()) timespec {
-                return self.ctim;
-            }
-        } else extern struct {
-            dev: u32,
-            __pad0: [3]u32,
-            ino: ino_t,
-            mode: mode_t,
-            nlink: nlink_t,
-            uid: uid_t,
-            gid: gid_t,
-            rdev: u32,
-            __pad1: [3]u32,
-            size: off_t,
-            atim: timespec,
-            mtim: timespec,
-            ctim: timespec,
-            blksize: blksize_t,
-            __pad3: u32,
-            blocks: blkcnt_t,
-            __pad4: [14]u32,
-
-            pub fn atime(self: @This()) timespec {
-                return self.atim;
-            }
-
-            pub fn mtime(self: @This()) timespec {
-                return self.mtim;
-            }
-
-            pub fn ctime(self: @This()) timespec {
-                return self.ctim;
-            }
-        },
-        .mips64, .mips64el => if (builtin.target.abi.isMusl()) extern struct {
-            dev: dev_t,
-            __pad0: [3]i32,
-            ino: ino_t,
-            mode: mode_t,
-            nlink: nlink_t,
-            uid: uid_t,
-            gid: gid_t,
-            rdev: dev_t,
-            __pad1: [2]u32,
-            size: off_t,
-            __pad2: i32,
-            atim: timespec,
-            mtim: timespec,
-            ctim: timespec,
-            blksize: blksize_t,
-            __pad3: u32,
-            blocks: blkcnt_t,
-            __pad4: [14]i32,
-
-            pub fn atime(self: @This()) timespec {
-                return self.atim;
-            }
-
-            pub fn mtime(self: @This()) timespec {
-                return self.mtim;
-            }
-
-            pub fn ctime(self: @This()) timespec {
-                return self.ctim;
-            }
-        } else extern struct {
-            dev: dev_t,
-            __pad0: [3]u32,
-            ino: ino_t,
-            mode: mode_t,
-            nlink: nlink_t,
-            uid: uid_t,
-            gid: gid_t,
-            rdev: dev_t,
-            __pad1: [3]u32,
-            size: off_t,
-            atim: timespec,
-            mtim: timespec,
-            ctim: timespec,
-            blksize: blksize_t,
-            __pad3: u32,
-            blocks: blkcnt_t,
-            __pad4: [14]i32,
-
-            pub fn atime(self: @This()) timespec {
-                return self.atim;
-            }
-
-            pub fn mtime(self: @This()) timespec {
-                return self.mtim;
-            }
-
-            pub fn ctime(self: @This()) timespec {
-                return self.ctim;
-            }
-        },
-
-        else => std.os.linux.Stat, // libc stat is the same as kernel stat.
-    },
     .emscripten => emscripten.Stat,
     .wasi => extern struct {
         // Match wasi-libc's `struct stat` in lib/libc/include/wasm-wasi-musl/__struct_stat.h
@@ -10260,6 +10100,7 @@ pub const fstat = switch (native_os) {
         else => private.fstat,
     },
     .netbsd => private.__fstat50,
+    .linux => {},
     else => private.fstat,
 };
 
@@ -10268,8 +10109,12 @@ pub const fstatat = switch (native_os) {
         .x86_64 => private.@"fstatat$INODE64",
         else => private.fstatat,
     },
+    .linux => {},
     else => private.fstatat,
 };
+
+pub extern "c" fn statx(dirfd: fd_t, path: [*:0]const u8, flags: u32, mask: linux.STATX, buf: *linux.Statx) c_int;
+
 pub extern "c" fn getpwent() ?*passwd;
 pub extern "c" fn endpwent() void;
 pub extern "c" fn setpwent() void;
@@ -10343,8 +10188,6 @@ pub extern "c" fn inotify_init1(flags: c_uint) c_int;
 pub extern "c" fn inotify_add_watch(fd: fd_t, pathname: [*:0]const u8, mask: u32) c_int;
 pub extern "c" fn inotify_rm_watch(fd: fd_t, wd: c_int) c_int;
 
-pub extern "c" fn fstat64(fd: fd_t, buf: *Stat) c_int;
-pub extern "c" fn fstatat64(dirfd: fd_t, noalias path: [*:0]const u8, noalias stat_buf: *Stat, flags: u32) c_int;
 pub extern "c" fn fallocate64(fd: fd_t, mode: c_int, offset: off_t, len: off_t) c_int;
 pub extern "c" fn fopen64(noalias filename: [*:0]const u8, noalias modes: [*:0]const u8) ?*FILE;
 pub extern "c" fn ftruncate64(fd: c_int, length: off_t) c_int;
@@ -10517,14 +10360,6 @@ pub const socketpair = switch (native_os) {
     else => private.socketpair,
 };
 
-pub const stat = switch (native_os) {
-    .macos => switch (native_arch) {
-        .x86_64 => private.@"stat$INODE64",
-        else => private.stat,
-    },
-    else => private.stat,
-};
-
 pub const _msize = switch (native_os) {
     .windows => private._msize,
     else => {},
@@ -11363,7 +11198,6 @@ const private = struct {
     extern "c" fn sigprocmask(how: c_int, noalias set: ?*const sigset_t, noalias oset: ?*sigset_t) c_int;
     extern "c" fn socket(domain: c_uint, sock_type: c_uint, protocol: c_uint) c_int;
     extern "c" fn socketpair(domain: c_uint, sock_type: c_uint, protocol: c_uint, sv: *[2]fd_t) c_int;
-    extern "c" fn stat(noalias path: [*:0]const u8, noalias buf: *Stat) c_int;
     extern "c" fn sigaltstack(ss: ?*stack_t, old_ss: ?*stack_t) c_int;
     extern "c" fn sysconf(sc: c_int) c_long;
     extern "c" fn shm_open(name: [*:0]const u8, flag: c_int, mode: mode_t) c_int;

lib/std/fs/Dir.zig

@@ -2805,32 +2805,26 @@ pub fn statFile(self: Dir, sub_path: []const u8) StatFileError!Stat {
         const st = try std.os.fstatat_wasi(self.fd, sub_path, .{ .SYMLINK_FOLLOW = true });
         return Stat.fromWasi(st);
     }
-    if (native_os == .linux) {
-        const sub_path_c = try posix.toPosixPath(sub_path);
-        var stx = std.mem.zeroes(linux.Statx);
-
-        const rc = linux.statx(
-            self.fd,
-            &sub_path_c,
-            linux.AT.NO_AUTOMOUNT,
-            linux.STATX_TYPE | linux.STATX_MODE | linux.STATX_ATIME | linux.STATX_MTIME | linux.STATX_CTIME,
-            &stx,
-        );
 
-        return switch (linux.E.init(rc)) {
-            .SUCCESS => Stat.fromLinux(stx),
-            .ACCES => error.AccessDenied,
-            .BADF => unreachable,
-            .FAULT => unreachable,
-            .INVAL => unreachable,
-            .LOOP => error.SymLinkLoop,
-            .NAMETOOLONG => unreachable, // Handled by posix.toPosixPath() above.
-            .NOENT, .NOTDIR => error.FileNotFound,
-            .NOMEM => error.SystemResources,
-            else => |err| posix.unexpectedErrno(err),
-        };
-    }
-    const st = try posix.fstatat(self.fd, sub_path, 0);
+    const sub_path_z = try posix.toPosixPath(sub_path);
+    if (native_os == .linux) return if (linux.wrapped.statx(
+        self.fd,
+        &sub_path_z,
+        linux.AT.NO_AUTOMOUNT,
+        .{ .TYPE = true, .MODE = true, .ATIME = true, .MTIME = true, .CTIME = true },
+    )) |stx| blk: {
+        assert(stx.mask.TYPE);
+        assert(stx.mask.MODE);
+        assert(stx.mask.ATIME);
+        assert(stx.mask.MTIME);
+        assert(stx.mask.CTIME);
+        break :blk Stat.fromLinux(stx);
+    } else |err| switch (err) {
+        error.NameTooLong => unreachable, // Handled by toPosixPath above.
+        else => |e| e,
+    };
+
+    const st = try posix.fstatatZ(self.fd, &sub_path_z, 0);
     return Stat.fromPosix(st);
 }
 

lib/std/fs/File.zig

@@ -552,37 +552,29 @@ pub fn stat(self: File) StatError!Stat {
             .ctime = windows.fromSysTime(info.BasicInformation.ChangeTime),
         };
     }
-
     if (builtin.os.tag == .wasi and !builtin.link_libc) {
         const st = try std.os.fstat_wasi(self.handle);
         return Stat.fromWasi(st);
     }
-
-    if (builtin.os.tag == .linux) {
-        var stx = std.mem.zeroes(linux.Statx);
-
-        const rc = linux.statx(
-            self.handle,
-            "",
-            linux.AT.EMPTY_PATH,
-            linux.STATX_TYPE | linux.STATX_MODE | linux.STATX_ATIME | linux.STATX_MTIME | linux.STATX_CTIME,
-            &stx,
-        );
-
-        return switch (linux.E.init(rc)) {
-            .SUCCESS => Stat.fromLinux(stx),
-            .ACCES => unreachable,
-            .BADF => unreachable,
-            .FAULT => unreachable,
-            .INVAL => unreachable,
-            .LOOP => unreachable,
-            .NAMETOOLONG => unreachable,
-            .NOENT => unreachable,
-            .NOMEM => error.SystemResources,
-            .NOTDIR => unreachable,
-            else => |err| posix.unexpectedErrno(err),
-        };
-    }
+    if (builtin.os.tag == .linux) return if (linux.wrapped.statx(
+        self.handle,
+        "",
+        linux.AT.EMPTY_PATH,
+        .{ .TYPE = true, .MODE = true, .ATIME = true, .MTIME = true, .CTIME = true },
+    )) |stx| blk: {
+        assert(stx.mask.TYPE);
+        assert(stx.mask.MODE);
+        assert(stx.mask.ATIME);
+        assert(stx.mask.MTIME);
+        assert(stx.mask.CTIME);
+        break :blk Stat.fromLinux(stx);
+    } else |err| switch (err) {
+        error.AccessDenied => unreachable,
+        error.SymLinkLoop => unreachable,
+        error.FileNotFound => unreachable,
+        error.NameTooLong => unreachable,
+        else => |e| e,
+    };
 
     const st = try posix.fstat(self.handle);
     return Stat.fromPosix(st);
@@ -1166,7 +1158,7 @@ pub const Reader = struct {
                     return err;
                 }
             }
-            if (posix.Stat == void) {
+            if (posix.Stat == void and native_os != .linux) {
                 r.size_err = error.Streaming;
                 return error.Streaming;
             }