Commit 4a344de651de757f01d9139ce0fbda7935048cf5 | zig

author	Jacob Young <jacobly@ziglang.org> 2025-09-22 12:59:00-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-09-24 16:09:46-07:00
log	4a344de651de757f01d9139ce0fbda7935048cf5
tree	b7694b3e8b708cd2bc345962024029b23d4e06c0
parent	94d319a10f90f8dfaf717fb537eeaf5415c47f9b

MappedFile: fix the insert range path not updating the root node

1 files changed, 50 insertions(+), 52 deletions(-)

src
- link
  - MappedFile.zig

src/link/MappedFile.zig+50-52

 @@ -146,7 +146,7 @@ pub const Node = extern struct {
         pub fn hasMoved(ni: Node.Index, mf: *const MappedFile) bool {
             var parent_ni = ni;
-            while (parent_ni != .none) {
+            while (parent_ni != Node.Index.root) {
                 const parent = parent_ni.get(mf);
                 if (parent.flags.moved) return true;
                 parent_ni = parent.parent;
 @@ -164,7 +164,7 @@ pub const Node = extern struct {
         }
         fn movedAssumeCapacity(ni: Node.Index, mf: *MappedFile) void {
             var parent_ni = ni;
-            while (parent_ni != .none) {
+            while (parent_ni != Node.Index.root) {
                 const parent_node = parent_ni.get(mf);
                 if (parent_node.flags.moved) return;
                 parent_ni = parent_node.parent;
 @@ -550,9 +550,9 @@ fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested
     const new_size = node.flags.alignment.forward(@intCast(requested_size));
     // Resize the entire file
     if (ni == Node.Index.root) {
+        try mf.ensureCapacityForSetLocation(gpa);
         try mf.file.setEndPos(new_size);
         try mf.ensureTotalCapacity(@intCast(new_size));
-        try mf.ensureCapacityForSetLocation(gpa);
         ni.setLocationAssumeCapacity(mf, old_offset, new_size);
         return;
     }
 @@ -585,56 +585,56 @@ fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested
                 continue;
             }
             const range_file_offset = ni.fileLocation(mf, false).offset + old_size;
-            retry: while (true) {
+            while (true) switch (linux.E.init(linux.fallocate(
-                switch (linux.E.init(linux.fallocate(
+                mf.file.handle,
-                    mf.file.handle,
+                linux.FALLOC.FL_INSERT_RANGE,
-                    linux.FALLOC.FL_INSERT_RANGE,
+                @intCast(range_file_offset),
-                    @intCast(range_file_offset),
+                @intCast(range_size),
-                    @intCast(range_size),
+            ))) {
-                ))) {
+                .SUCCESS => {
-                    .SUCCESS => {
+                    var enclosing_ni = ni;
-                        var enclosing_ni = ni;
+                    while (true) {
-                        while (enclosing_ni != .none) {
+                        try mf.ensureCapacityForSetLocation(gpa);
+                        const enclosing = enclosing_ni.get(mf);
+                        const enclosing_offset, const old_enclosing_size =
+                            enclosing.location().resolve(mf);
+                        const new_enclosing_size = old_enclosing_size + range_size;
+                        enclosing_ni.setLocationAssumeCapacity(mf, enclosing_offset, new_enclosing_size);
+                        if (enclosing_ni == Node.Index.root) {
+                            assert(enclosing_offset == 0);
+                            try mf.ensureTotalCapacity(@intCast(new_enclosing_size));
+                            break;
+                        }
+                        var after_ni = enclosing.next;
+                        while (after_ni != .none) {
                             try mf.ensureCapacityForSetLocation(gpa);
-                            const enclosing = enclosing_ni.get(mf);
+                            const after = after_ni.get(mf);
-                            const enclosing_offset, const enclosing_size =
+                            const after_offset, const after_size = after.location().resolve(mf);
-                                enclosing.location().resolve(mf);
+                            after_ni.setLocationAssumeCapacity(
-                            enclosing_ni.setLocationAssumeCapacity(
                                 mf,
-                                enclosing_offset,
+                                range_size + after_offset,
-                                enclosing_size + range_size,
+                                after_size,
                             );
-                            var after_ni = enclosing.next;
+                            after_ni = after.next;
-                            while (after_ni != .none) {
-                                try mf.ensureCapacityForSetLocation(gpa);
-                                const after = after_ni.get(mf);
-                                const after_offset, const after_size = after.location().resolve(mf);
-                                after_ni.setLocationAssumeCapacity(
-                                    mf,
-                                    range_size + after_offset,
-                                    after_size,
-                                );
-                                after_ni = after.next;
-                            }
-                            enclosing_ni = enclosing.parent;
                         }
-                        return;
+                        enclosing_ni = enclosing.parent;
-                    },
+                    }
-                    .INTR => continue :retry,
+                    return;
-                    .BADF, .FBIG, .INVAL => unreachable,
+                },
-                    .IO => return error.InputOutput,
+                .INTR => continue,
-                    .NODEV => return error.NotFile,
+                .BADF, .FBIG, .INVAL => unreachable,
-                    .NOSPC => return error.NoSpaceLeft,
+                .IO => return error.InputOutput,
-                    .NOSYS, .OPNOTSUPP => {
+                .NODEV => return error.NotFile,
-                        mf.flags.fallocate_insert_range_unsupported = true;
+                .NOSPC => return error.NoSpaceLeft,
-                        break :insert_range;
+                .NOSYS, .OPNOTSUPP => {
-                    },
+                    mf.flags.fallocate_insert_range_unsupported = true;
-                    .PERM => return error.PermissionDenied,
+                    break :insert_range;
-                    .SPIPE => return error.Unseekable,
+                },
-                    .TXTBSY => return error.FileBusy,
+                .PERM => return error.PermissionDenied,
-                    else => |e| return std.posix.unexpectedErrno(e),
+                .SPIPE => return error.Unseekable,
-                }
+                .TXTBSY => return error.FileBusy,
-            }
+                else => |e| return std.posix.unexpectedErrno(e),
+            };
         }
         switch (node.next) {
             .none => {
 @@ -728,7 +728,6 @@ fn moveRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size:
     // delete the copy of this node at the old location
     if (is_linux and !mf.flags.fallocate_punch_hole_unsupported and
         size >= mf.flags.block_size.toByteUnits() * 2 - 1) while (true)
-    {
         switch (linux.E.init(linux.fallocate(
             mf.file.handle,
             linux.FALLOC.FL_PUNCH_HOLE | linux.FALLOC.FL_KEEP_SIZE,
 @@ -749,8 +748,7 @@ fn moveRange(mf: *MappedFile, old_file_offset: u64, new_file_offset: u64, size:
             .SPIPE => return error.Unseekable,
             .TXTBSY => return error.FileBusy,
             else => |e| return std.posix.unexpectedErrno(e),
-        }
+        };
-    };
     @memset(mf.contents[@intCast(old_file_offset)..][0..@intCast(size)], 0);
 }