Commit cdd6e545cc7e4c6cb32d1a87695f215ce9d5f753 | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-10-12 13:30:02-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-10-13 13:26:23-07:00
log	cdd6e545cc7e4c6cb32d1a87695f215ce9d5f753
tree	bfb9dc6d5a84eaf40b83ab0446e1be54505dbb24
parent	59f14713067c59751dff4d6f73f81893a2284793

std.Io.Threaded: handle unsupported renamePreserveLinux

with link/unlink fallback. closes #31960

2 files changed, 18 insertions(+), 4 deletions(-)

lib
- std
  - Io
    Dir.zig
    Threaded.zig

lib/std/Io/Dir.zig+7-2

 @@ -1122,8 +1122,7 @@ pub const RenamePreserveError = error{
     /// policy of the current thread or process disallows dataless directory materialization.
     AccessDenied,
     PathAlreadyExists,
-    /// Operating system or file system does not support atomic nonreplacing
+    /// Operating system or file system does not support atomic nonreplacing rename.
-    /// rename.
     OperationUnsupported,
 } || RenameError;
 @@ -1131,6 +1130,12 @@ pub const RenamePreserveError = error{
 ///
 /// If `new_sub_path` already exists, `error.PathAlreadyExists` will be returned.
 ///
+/// If the operating system supports it, the entire operation will be done atomically. If unsupported, will
+/// fall back to hard link followed by unlink, which is atomic with respect to `new_sub_path` but leaves a
+/// window where the cleanup of `old_sub_path may fail. Although the operation is fairly portable, technically
+/// this fallback, too, may be unsupported in some environments, in which case `error.OperationUnsupported` is
+/// returned.
+///
 /// * On Windows, both paths should be encoded as [WTF-8](https://wtf-8.codeberg.page/).
 /// * On WASI, both paths should be encoded as valid UTF-8.
 /// * On other platforms, both paths are an opaque sequence of bytes with no particular encoding.

lib/std/Io/Threaded.zig+11-2

 @@ -7756,7 +7756,14 @@ fn dirRenamePreserve(
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     if (is_windows) return dirRenameWindowsInner(old_dir, old_sub_path, new_dir, new_sub_path, false);
     if (is_darwin) return dirRenamePreserveDarwin(old_dir, old_sub_path, new_dir, new_sub_path);
-    if (native_os == .linux) return dirRenamePreserveLinux(old_dir, old_sub_path, new_dir, new_sub_path);
+    if (native_os == .linux) {
+        if (dirRenamePreserveLinux(old_dir, old_sub_path, new_dir, new_sub_path)) |_| {
+            return;
+        } else |err| switch (err) {
+            else => |e| return e,
+            error.OperationUnsupported => {}, // Fall back to link/unlink below.
+        }
+    }
     // Make a hard link then delete the original.
     try dirHardLink(t, old_dir, old_sub_path, new_dir, new_sub_path, .{ .follow_symlinks = false });
     const prev = swapCancelProtection(t, .blocked);
 @@ -8084,8 +8091,10 @@ fn dirRenamePreserveLinux(
         .ROFS => return syscall.fail(error.ReadOnlyFileSystem),
         .XDEV => return syscall.fail(error.CrossDevice),
         .ILSEQ => return syscall.fail(error.BadPathName),
+        // EINVAL when passing NOREPLACE=true observed on ext4, 7.0.0-38-generic #38~24.04.4-Ubuntu.
+        // OPNOTSUPP handled defensively.
+        .INVAL, .OPNOTSUPP => return syscall.fail(error.OperationUnsupported),
         .FAULT => |err| return syscall.errnoBug(err),
-        .INVAL => return syscall.fail(error.OperationUnsupported),
         else => |err| return syscall.unexpectedErrno(err),
     };
 }