Commit a7c9d11b289b2140430f2666968bddb02a6f1a1f | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-12-27 10:40:24-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-12-27 10:40:24-08:00
log	a7c9d11b289b2140430f2666968bddb02a6f1a1f
tree	b5b682039c0704b9beaf3f17737ab3d6962afb1a
parent	e55e6b5528bb2f01de242fcf32b172e244e98e74

std.Io: make file access time optional

Some filesystems, such as ZFS, do not report atime. It's pretty useless
in general, so make it an optional field in File.Stat.

Also take the opportunity to make setting timestamps API more flexible
and match the APIs widely available, which have UTIME_OMIT and UTIME_NOW
constants that can be independently set for both fields.

This is needed to handle smoothly the case when atime is null.

6 files changed, 159 insertions(+), 211 deletions(-)

lib
- std
  - Io.zig
  - Io
    Dir.zig
    File.zig
    Threaded.zig
    test.zig
  - os
    linux.zig

lib/std/Io.zig+2-4

lib/std/Io/Dir.zig+22-6

 @@ -615,7 +615,10 @@ pub fn updateFile(
         error.WriteFailed => return atomic_file.file_writer.err.?,
     };
     try atomic_file.flush();
-    try atomic_file.file_writer.file.setTimestamps(io, src_stat.atime, src_stat.mtime);
+    try atomic_file.file_writer.file.setTimestamps(io, .{
+        .access_timestamp = .init(src_stat.atime),
+        .modify_timestamp = .init(src_stat.mtime),
+    });
     try atomic_file.renameIntoPlace();
     return .stale;
 }
 @@ -1825,6 +1828,8 @@ pub const SetTimestampsError = File.SetTimestampsError || PathNameError;
 pub const SetTimestampsOptions = struct {
     follow_symlinks: bool = true,
+    access_timestamp: File.SetTimestamp = .unchanged,
+    modify_timestamp: File.SetTimestamp = .unchanged,
 };
 /// The granularity that ultimately is stored depends on the combination of
 @@ -1834,18 +1839,29 @@ pub fn setTimestamps(
     dir: Dir,
     io: Io,
     sub_path: []const u8,
-    last_accessed: Io.Timestamp,
-    last_modified: Io.Timestamp,
     options: SetTimestampsOptions,
 ) SetTimestampsError!void {
-    return io.vtable.dirSetTimestamps(io.userdata, dir, sub_path, last_accessed, last_modified, options);
+    return io.vtable.dirSetTimestamps(io.userdata, dir, sub_path, options);
 }
+pub const SetTimestampsNowOptions = struct {
+    follow_symlinks: bool = true,
+};
 /// Sets the accessed and modification timestamps of the provided path to the
 /// current wall clock time.
 ///
 /// The granularity that ultimately is stored depends on the combination of
 /// operating system and file system.
-pub fn setTimestampsNow(dir: Dir, io: Io, sub_path: []const u8, options: SetTimestampsOptions) SetTimestampsError!void {
+pub fn setTimestampsNow(
-    return io.vtable.fileSetTimestampsNow(io.userdata, dir, sub_path, options);
+    dir: Dir,
+    io: Io,
+    sub_path: []const u8,
+    options: SetTimestampsNowOptions,
+) SetTimestampsError!void {
+    return io.vtable.fileSetTimestamps(io.userdata, dir, sub_path, .{
+        .follow_symlinks = options.follow_symlinks,
+        .access_timestamp = .now,
+        .modify_timestamp = .now,
+    });
 }

lib/std/Io/File.zig+31-9

 @@ -53,7 +53,12 @@ pub const Stat = struct {
     permissions: Permissions,
     kind: Kind,
     /// Last access time in nanoseconds, relative to UTC 1970-01-01.
-    atime: Io.Timestamp,
+    ///
+    /// Filesystems generally find this value problematic to keep updated since
+    /// it turns read-only file system accesses into file system mutations.
+    /// Some systems report stale values, and some systems explicitly refuse to
+    /// report this value. The latter case is handled by `null`.
+    atime: ?Io.Timestamp,
     /// Last modification time in nanoseconds, relative to UTC 1970-01-01.
     mtime: Io.Timestamp,
     /// Last status/metadata change time in nanoseconds, relative to UTC 1970-01-01.
 @@ -478,16 +483,30 @@ pub const SetTimestampsError = error{
     ReadOnlyFileSystem,
 } || Io.Cancelable || Io.UnexpectedError;
+pub const SetTimestampsOptions = struct {
+    access_timestamp: SetTimestamp = .unchanged,
+    modify_timestamp: SetTimestamp = .unchanged,
+};
+pub const SetTimestamp = union(enum) {
+    /// Leave the existing timestamp unmodified.
+    unchanged,
+    /// Set to current time using `Io.Clock.real`.
+    now,
+    /// Set to provided timestamp using `Io.Clock.real`.
+    new: Io.Timestamp,
+    /// Convenience for interacting with `Stat`, in which `null` indicates `unchanged`.
+    pub fn init(optional: ?Io.Timestamp) SetTimestamp {
+        return if (optional) |t| .{ .new = t } else .unchanged;
+    }
+};
 /// The granularity that ultimately is stored depends on the combination of
 /// operating system and file system. When a value as provided that exceeds
 /// this range, the value is clamped to the maximum.
-pub fn setTimestamps(
+pub fn setTimestamps(file: File, io: Io, options: SetTimestampsOptions) SetTimestampsError!void {
-    file: File,
+    return io.vtable.fileSetTimestamps(io.userdata, file, options);
-    io: Io,
-    last_accessed: Io.Timestamp,
-    last_modified: Io.Timestamp,
-) SetTimestampsError!void {
-    return io.vtable.fileSetTimestamps(io.userdata, file, last_accessed, last_modified);
 }
 /// Sets the accessed and modification timestamps of `file` to the current wall
 @@ -496,7 +515,10 @@ pub fn setTimestamps(
 /// The granularity that ultimately is stored depends on the combination of
 /// operating system and file system.
 pub fn setTimestampsNow(file: File, io: Io) SetTimestampsError!void {
-    return io.vtable.fileSetTimestampsNow(io.userdata, file);
+    return io.vtable.fileSetTimestamps(io.userdata, file, .{
+        .access_timestamp = .now,
+        .modify_timestamp = .now,
+    });
 }
 /// Returns 0 on stream end or if `buffer` has no space available for data.

lib/std/Io/Threaded.zig+86-186

 @@ -235,6 +235,24 @@ const Thread = struct {
         ) orelse return;
     }
+    fn endSyscallErrnoBug(thread: *Thread, err: posix.E) Io.UnexpectedError {
+        @branchHint(.cold);
+        thread.endSyscall();
+        return errnoBug(err);
+    }
+    fn endSyscallUnexpectedErrno(thread: *Thread, err: posix.E) Io.UnexpectedError {
+        @branchHint(.cold);
+        thread.endSyscall();
+        return posix.unexpectedErrno(err);
+    }
+    /// inline to make error return traces slightly shallower.
+    inline fn endSyscallError(thread: *Thread, err: anytype) @TypeOf(err) {
+        thread.endSyscall();
+        return err;
+    }
     fn currentSignalId() SignaleeId {
         return if (std.Thread.use_pthreads) std.c.pthread_self() else std.Thread.getCurrentId();
     }
 @@ -811,7 +829,6 @@ pub fn io(t: *Threaded) Io {
             .dirSetPermissions = dirSetPermissions,
             .dirSetFilePermissions = dirSetFilePermissions,
             .dirSetTimestamps = dirSetTimestamps,
-            .dirSetTimestampsNow = dirSetTimestampsNow,
             .dirHardLink = dirHardLink,
             .fileStat = fileStat,
 @@ -833,7 +850,6 @@ pub fn io(t: *Threaded) Io {
             .fileSetOwner = fileSetOwner,
             .fileSetPermissions = fileSetPermissions,
             .fileSetTimestamps = fileSetTimestamps,
-            .fileSetTimestampsNow = fileSetTimestampsNow,
             .fileLock = fileLock,
             .fileTryLock = fileTryLock,
             .fileUnlock = fileUnlock,
 @@ -947,7 +963,6 @@ pub fn ioBasic(t: *Threaded) Io {
             .dirSetPermissions = dirSetPermissions,
             .dirSetFilePermissions = dirSetFilePermissions,
             .dirSetTimestamps = dirSetTimestamps,
-            .dirSetTimestampsNow = dirSetTimestampsNow,
             .dirHardLink = dirHardLink,
             .fileStat = fileStat,
 @@ -969,7 +984,6 @@ pub fn ioBasic(t: *Threaded) Io {
             .fileSetOwner = fileSetOwner,
             .fileSetPermissions = fileSetPermissions,
             .fileSetTimestamps = fileSetTimestamps,
-            .fileSetTimestampsNow = fileSetTimestampsNow,
             .fileLock = fileLock,
             .fileTryLock = fileTryLock,
             .fileUnlock = fileUnlock,
 @@ -5977,8 +5991,6 @@ fn dirSetTimestamps(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    last_accessed: Io.Timestamp,
-    last_modified: Io.Timestamp,
     options: Dir.SetTimestampsOptions,
 ) Dir.SetTimestampsError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
 @@ -5992,9 +6004,13 @@ fn dirSetTimestamps(
         @panic("TODO implement dirSetTimestamps wasi");
     }
-    const times: [2]posix.timespec = .{
+    var times_buffer: [2]posix.timespec = undefined;
-        timestampToPosix(last_accessed.nanoseconds),
+    const times = if (options.modify_timestamp == .now and options.access_timestamp == .now) null else p: {
-        timestampToPosix(last_modified.nanoseconds),
+        times_buffer = .{
+            setTimestampToPosix(options.access_timestamp),
+            setTimestampToPosix(options.modify_timestamp),
+        };
+        break :p &times_buffer;
     };
     const flags: u32 = if (!options.follow_symlinks) posix.AT.SYMLINK_NOFOLLOW else 0;
 @@ -6003,80 +6019,26 @@ fn dirSetTimestamps(
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
     try current_thread.beginSyscall();
-    while (true) {
+    while (true) switch (posix.errno(posix.system.utimensat(dir.handle, sub_path_posix, times, flags))) {
-        switch (posix.errno(posix.system.utimensat(dir.handle, sub_path_posix, &times, flags))) {
+        .SUCCESS => return current_thread.endSyscall(),
-            .SUCCESS => return current_thread.endSyscall(),
+        .INTR => {
-            .INTR => {
+            try current_thread.checkCancel();
-                try current_thread.checkCancel();
+            continue;
-                continue;
+        },
-            },
+        .BADF => |err| return current_thread.endSyscallErrnoBug(err), // always a race condition
-            else => |e| {
+        .FAULT => |err| return current_thread.endSyscallErrnoBug(err),
-                current_thread.endSyscall();
+        .INVAL => |err| return current_thread.endSyscallErrnoBug(err),
-                switch (e) {
+        .ACCES => return current_thread.endSyscallError(error.AccessDenied),
-                    .ACCES => return error.AccessDenied,
+        .PERM => return current_thread.endSyscallError(error.PermissionDenied),
-                    .PERM => return error.PermissionDenied,
+        .ROFS => return current_thread.endSyscallError(error.ReadOnlyFileSystem),
-                    .BADF => |err| return errnoBug(err), // always a race condition
+        else => |err| return current_thread.endSyscallUnexpectedErrno(err),
-                    .FAULT => |err| return errnoBug(err),
+    };
-                    .INVAL => |err| return errnoBug(err),
-                    .ROFS => return error.ReadOnlyFileSystem,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
-        }
-    }
-}
-fn dirSetTimestampsNow(
-    userdata: ?*anyopaque,
-    dir: Dir,
-    sub_path: []const u8,
-    options: Dir.SetTimestampsOptions,
-) Dir.SetTimestampsError!void {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const current_thread = Thread.getCurrent(t);
-    if (is_windows) {
-        @panic("TODO implement dirSetTimestampsNow windows");
-    }
-    if (native_os == .wasi and !builtin.link_libc) {
-        @panic("TODO implement dirSetTimestampsNow wasi");
-    }
-    const flags: u32 = if (!options.follow_symlinks) posix.AT.SYMLINK_NOFOLLOW else 0;
-    var path_buffer: [posix.PATH_MAX]u8 = undefined;
-    const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
-    try current_thread.beginSyscall();
-    while (true) {
-        switch (posix.errno(posix.system.utimensat(dir.handle, sub_path_posix, null, flags))) {
-            .SUCCESS => return current_thread.endSyscall(),
-            .INTR => {
-                try current_thread.checkCancel();
-                continue;
-            },
-            else => |e| {
-                current_thread.endSyscall();
-                switch (e) {
-                    .ACCES => return error.AccessDenied,
-                    .PERM => return error.PermissionDenied,
-                    .BADF => |err| return errnoBug(err), // always a race condition
-                    .FAULT => |err| return errnoBug(err),
-                    .INVAL => |err| return errnoBug(err),
-                    .ROFS => return error.ReadOnlyFileSystem,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
-        }
-    }
 }
 fn fileSetTimestamps(
     userdata: ?*anyopaque,
     file: File,
-    last_accessed: Io.Timestamp,
+    options: File.SetTimestampsOptions,
-    last_modified: Io.Timestamp,
 ) File.SetTimestampsError!void {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     const current_thread = Thread.getCurrent(t);
 @@ -6084,8 +6046,8 @@ fn fileSetTimestamps(
     if (is_windows) {
         try current_thread.checkCancel();
-        const atime_ft = windows.nanoSecondsToFileTime(last_accessed);
+        const atime_ft = windows.nanoSecondsToFileTime(options.access_time);
-        const mtime_ft = windows.nanoSecondsToFileTime(last_modified);
+        const mtime_ft = windows.nanoSecondsToFileTime(options.modify_time);
         // https://github.com/ziglang/zig/issues/1840
         const rc = windows.kernel32.SetFileTime(file.handle, null, &atime_ft, &mtime_ft);
 @@ -6097,123 +6059,53 @@ fn fileSetTimestamps(
         return;
     }
-    const times: [2]posix.timespec = .{
-        timestampToPosix(last_accessed.nanoseconds),
-        timestampToPosix(last_modified.nanoseconds),
-    };
     if (native_os == .wasi and !builtin.link_libc) {
-        const atim = times[0].toTimestamp();
+        const atim = timestampToPosix(options.access_time.nanoseconds).toTimestamp();
-        const mtim = times[1].toTimestamp();
+        const mtim = timestampToPosix(options.modify_time.nanoseconds).toTimestamp();
         try current_thread.beginSyscall();
-        while (true) {
+        while (true) switch (std.os.wasi.fd_filestat_set_times(file.handle, atim, mtim, .{
-            switch (std.os.wasi.fd_filestat_set_times(file.handle, atim, mtim, .{
+            .ATIM = true,
-                .ATIM = true,
+            .MTIM = true,
-                .MTIM = true,
+        })) {
-            })) {
-                .SUCCESS => return current_thread.endSyscall(),
-                .INTR => {
-                    try current_thread.checkCancel();
-                    continue;
-                },
-                else => |e| {
-                    current_thread.endSyscall();
-                    switch (e) {
-                        .ACCES => return error.AccessDenied,
-                        .PERM => return error.PermissionDenied,
-                        .BADF => |err| return errnoBug(err), // File descriptor use-after-free.
-                        .FAULT => |err| return errnoBug(err),
-                        .INVAL => |err| return errnoBug(err),
-                        .ROFS => return error.ReadOnlyFileSystem,
-                        else => |err| return posix.unexpectedErrno(err),
-                    }
-                },
-            }
-        }
-    }
-    try current_thread.beginSyscall();
-    while (true) {
-        switch (posix.errno(posix.system.futimens(file.handle, &times))) {
             .SUCCESS => return current_thread.endSyscall(),
             .INTR => {
                 try current_thread.checkCancel();
                 continue;
             },
-            else => |e| {
+            .BADF => |err| return current_thread.endSyscallErrnoBug(err), // File descriptor use-after-free.
-                current_thread.endSyscall();
+            .FAULT => |err| return current_thread.endSyscallErrnoBug(err),
-                switch (e) {
+            .INVAL => |err| return current_thread.endSyscallErrnoBug(err),
-                    .ACCES => return error.AccessDenied,
+            .ACCES => return current_thread.endSyscallErrnoBug(error.AccessDenied),
-                    .PERM => return error.PermissionDenied,
+            .PERM => return current_thread.endSyscallErrnoBug(error.PermissionDenied),
-                    .BADF => |err| return errnoBug(err), // always a race condition
+            .ROFS => return current_thread.endSyscallErrnoBug(error.ReadOnlyFileSystem),
-                    .FAULT => |err| return errnoBug(err),
+            else => |err| return current_thread.endSyscallUnexpectedErrno(err),
-                    .INVAL => |err| return errnoBug(err),
+        };
-                    .ROFS => return error.ReadOnlyFileSystem,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
-        }
-    }
-}
-fn fileSetTimestampsNow(userdata: ?*anyopaque, file: File) File.SetTimestampsError!void {
-    const t: *Threaded = @ptrCast(@alignCast(userdata));
-    const current_thread = Thread.getCurrent(t);
-    if (is_windows) {
-        @panic("TODO implement fileSetTimestampsNow windows");
     }
-    if (native_os == .wasi and !builtin.link_libc) {
+    var times_buffer: [2]posix.timespec = undefined;
-        try current_thread.beginSyscall();
+    const times = if (options.modify_timestamp == .now and options.access_timestamp == .now) null else p: {
-        while (true) {
+        times_buffer = .{
-            switch (std.os.wasi.fd_filestat_set_times(file.handle, 0, 0, .{
+            setTimestampToPosix(options.access_timestamp),
-                .ATIM_NOW = true,
+            setTimestampToPosix(options.modify_timestamp),
-                .MTIM_NOW = true,
+        };
-            })) {
+        break :p &times_buffer;
-                .SUCCESS => return current_thread.endSyscall(),
+    };
-                .INTR => {
-                    try current_thread.checkCancel();
-                    continue;
-                },
-                else => |e| {
-                    current_thread.endSyscall();
-                    switch (e) {
-                        .ACCES => return error.AccessDenied,
-                        .PERM => return error.PermissionDenied,
-                        .BADF => |err| return errnoBug(err), // always a race condition
-                        .FAULT => |err| return errnoBug(err),
-                        .INVAL => |err| return errnoBug(err),
-                        .ROFS => return error.ReadOnlyFileSystem,
-                        else => |err| return posix.unexpectedErrno(err),
-                    }
-                },
-            }
-        }
-    }
     try current_thread.beginSyscall();
-    while (true) {
+    while (true) switch (posix.errno(posix.system.futimens(file.handle, times))) {
-        switch (posix.errno(posix.system.futimens(file.handle, null))) {
+        .SUCCESS => return current_thread.endSyscall(),
-            .SUCCESS => return current_thread.endSyscall(),
+        .INTR => {
-            .INTR => {
+            try current_thread.checkCancel();
-                try current_thread.checkCancel();
+            continue;
-                continue;
+        },
-            },
+        .BADF => |err| return current_thread.endSyscallErrnoBug(err), // always a race condition
-            else => |e| {
+        .FAULT => |err| return current_thread.endSyscallErrnoBug(err),
-                current_thread.endSyscall();
+        .INVAL => |err| return current_thread.endSyscallErrnoBug(err),
-                switch (e) {
+        .ACCES => return current_thread.endSyscallError(error.AccessDenied),
-                    .ACCES => return error.AccessDenied,
+        .PERM => return current_thread.endSyscallError(error.PermissionDenied),
-                    .PERM => return error.PermissionDenied,
+        .ROFS => return current_thread.endSyscallError(error.ReadOnlyFileSystem),
-                    .BADF => |err| return errnoBug(err), // always a race condition
+        else => |err| return current_thread.endSyscallUnexpectedErrno(err),
-                    .FAULT => |err| return errnoBug(err),
+    };
-                    .INVAL => |err| return errnoBug(err),
-                    .ROFS => return error.ReadOnlyFileSystem,
-                    else => |err| return posix.unexpectedErrno(err),
-                }
-            },
-        }
-    }
 }
 const windows_lock_range_off: windows.LARGE_INTEGER = 0;
 @@ -11283,6 +11175,14 @@ fn timestampToPosix(nanoseconds: i96) posix.timespec {
     };
 }
+fn setTimestampToPosix(set_ts: File.SetTimestamp) posix.timespec {
+    return switch (set_ts) {
+        .unchanged => .OMIT,
+        .now => .NOW,
+        .new => |t| timestampToPosix(t.nanoseconds),
+    };
+}
 fn pathToPosix(file_path: []const u8, buffer: *[posix.PATH_MAX]u8) Dir.PathNameError![:0]u8 {
     if (std.mem.containsAtLeastScalar2(u8, file_path, 0, 1)) return error.BadPathName;
     // >= rather than > to make room for the null byte

lib/std/Io/test.zig+6-6

 @@ -174,14 +174,14 @@ test "setTimestamps" {
     defer file.close(io);
     const stat_old = try file.stat(io);
     // Set atime and mtime to 5s before
-    try file.setTimestamps(
+    try file.setTimestamps(io, .{
-        io,
+        .access_timestamp = if (stat_old.atime) |atime| .{ .new = atime.subDuration(.fromSeconds(5)) } else .unchanged,
-        stat_old.atime.subDuration(.fromSeconds(5)),
+        .modify_timestamp = .{ .new = stat_old.mtime.subDuration(.fromSeconds(5)) },
-        stat_old.mtime.subDuration(.fromSeconds(5)),
+    });
-    );
     const stat_new = try file.stat(io);
-    try expect(stat_new.atime.nanoseconds < stat_old.atime.nanoseconds);
+    if (stat_old.atime) |old_atime| try expect(stat_new.atime.?.nanoseconds < old_atime.nanoseconds);
     try expect(stat_new.mtime.nanoseconds < stat_old.mtime.nanoseconds);
 }

lib/std/os/linux.zig+12

...	@@ -8423,6 +8423,18 @@ pub const kernel_timespec = extern struct {	...	@@ -8423,6 +8423,18 @@ pub const kernel_timespec = extern struct {
8423	pub const timespec = if (native_arch == .hexagon or native_arch == .riscv32) kernel_timespec else extern struct {	8423	pub const timespec = if (native_arch == .hexagon or native_arch == .riscv32) kernel_timespec else extern struct {
8424	sec: isize,	8424	sec: isize,
8425	nsec: isize,	8425	nsec: isize,
		8426
		8427	/// For use with `utimensat` and `futimens`.
		8428	pub const NOW: timespec = .{
		8429	.sec = 0,
		8430	.nsec = 0x3fffffff,
		8431	};
		8432
		8433	/// For use with `utimensat` and `futimens`.
		8434	pub const OMIT: timespec = .{
		8435	.sec = 0,
		8436	.nsec = 0x3ffffffe,
		8437	};
8426	};	8438	};
8427		8439
8428	pub const XDP = struct {	8440	pub const XDP = struct {

...	@@ -681,8 +681,7 @@ pub const VTable = struct {	...	@@ -681,8 +681,7 @@ pub const VTable = struct {
681	dirSetFileOwner: const fn (?anyopaque, Dir, []const u8, ?File.Uid, ?File.Gid, Dir.SetFileOwnerOptions) Dir.SetFileOwnerError!void,	681	dirSetFileOwner: const fn (?anyopaque, Dir, []const u8, ?File.Uid, ?File.Gid, Dir.SetFileOwnerOptions) Dir.SetFileOwnerError!void,
682	dirSetPermissions: const fn (?anyopaque, Dir, Dir.Permissions) Dir.SetPermissionsError!void,	682	dirSetPermissions: const fn (?anyopaque, Dir, Dir.Permissions) Dir.SetPermissionsError!void,
683	dirSetFilePermissions: const fn (?anyopaque, Dir, []const u8, File.Permissions, Dir.SetFilePermissionsOptions) Dir.SetFilePermissionsError!void,	683	dirSetFilePermissions: const fn (?anyopaque, Dir, []const u8, File.Permissions, Dir.SetFilePermissionsOptions) Dir.SetFilePermissionsError!void,
684	dirSetTimestamps: const fn (?anyopaque, Dir, []const u8, last_accessed: Timestamp, last_modified: Timestamp, Dir.SetTimestampsOptions) Dir.SetTimestampsError!void,	684	dirSetTimestamps: const fn (?anyopaque, Dir, []const u8, Dir.SetTimestampsOptions) Dir.SetTimestampsError!void,
685	dirSetTimestampsNow: const fn (?anyopaque, Dir, []const u8, Dir.SetTimestampsOptions) Dir.SetTimestampsError!void,
686	dirHardLink: const fn (?anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, Dir.HardLinkOptions) Dir.HardLinkError!void,	685	dirHardLink: const fn (?anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, Dir.HardLinkOptions) Dir.HardLinkError!void,
687		686
688	fileStat: const fn (?anyopaque, File) File.StatError!File.Stat,	687	fileStat: const fn (?anyopaque, File) File.StatError!File.Stat,
...	@@ -705,8 +704,7 @@ pub const VTable = struct {	...	@@ -705,8 +704,7 @@ pub const VTable = struct {
705	fileSetLength: const fn (?anyopaque, File, u64) File.SetLengthError!void,	704	fileSetLength: const fn (?anyopaque, File, u64) File.SetLengthError!void,
706	fileSetOwner: const fn (?anyopaque, File, ?File.Uid, ?File.Gid) File.SetOwnerError!void,	705	fileSetOwner: const fn (?anyopaque, File, ?File.Uid, ?File.Gid) File.SetOwnerError!void,
707	fileSetPermissions: const fn (?anyopaque, File, File.Permissions) File.SetPermissionsError!void,	706	fileSetPermissions: const fn (?anyopaque, File, File.Permissions) File.SetPermissionsError!void,
708	fileSetTimestamps: const fn (?anyopaque, File, last_accessed: Timestamp, last_modified: Timestamp) File.SetTimestampsError!void,	707	fileSetTimestamps: const fn (?anyopaque, File, File.SetTimestampsOptions) File.SetTimestampsError!void,
709	fileSetTimestampsNow: const fn (?anyopaque, File) File.SetTimestampsError!void,
710	fileLock: const fn (?anyopaque, File, File.Lock) File.LockError!void,	708	fileLock: const fn (?anyopaque, File, File.Lock) File.LockError!void,
711	fileTryLock: const fn (?anyopaque, File, File.Lock) File.LockError!bool,	709	fileTryLock: const fn (?anyopaque, File, File.Lock) File.LockError!bool,
712	fileUnlock: const fn (?anyopaque, File) void,	710	fileUnlock: const fn (?anyopaque, File) void,