Commit 7b21fd7244ed1b0459b542346e96a20e91138f69 | zig

lib/std/Io/File/MemoryMap.zig+5

 @@ -95,6 +95,11 @@ pub const SetLengthError = error{
 /// `options` is needed because the mapping may need to be destroyed and
 /// re-created. All the same options must be provided except for `len` which is
 /// the new length.
+///
+/// This operation cannot be completed atomically on all operating systems.
+/// When this function fails, the `MemoryMap` may be left in an unmapped state,
+/// which can be detected by checking if `memory.len` is zero. In such case it
+/// is safe to call `destroy` which will have no effect.
 pub fn setLength(mm: *MemoryMap, io: Io, options: CreateOptions) SetLengthError!void {
     return io.vtable.fileMemoryMapSetLength(io.userdata, mm, options);
 }

lib/std/Io/Threaded.zig+35-57

 @@ -16238,6 +16238,8 @@ fn createFileMap(
         try Thread.checkCancel();
         var section = windows.INVALID_HANDLE_VALUE;
+        const section_size: windows.LARGE_INTEGER = @intCast(len);
+        const page = windows.PAGE.fromProtection(protection) orelse return error.AccessDenied;
         switch (windows.ntdll.NtCreateSection(
             &section,
             .{
 @@ -16251,8 +16253,8 @@ fn createFileMap(
                 .STANDARD = .{ .RIGHTS = .REQUIRED },
             },
             null,
-            @constCast(&@as(i64, @intCast(len))),
+            &section_size,
-            .{ .READWRITE = true },
+            page,
             .{ .COMMIT = populate },
             file.handle,
         )) {
 @@ -16260,6 +16262,7 @@ fn createFileMap(
             .FILE_LOCK_CONFLICT => return error.FileLockConflict,
             .INVALID_FILE_FOR_SECTION => return error.OperationUnsupported,
             .ACCESS_DENIED => return error.AccessDenied,
+            .SECTION_TOO_BIG => return error.SectionOversize,
             else => |status| return windows.unexpectedStatus(status),
         }
         var contents_ptr: ?[*]align(std.heap.page_size_min) u8 = null;
 @@ -16274,7 +16277,7 @@ fn createFileMap(
             &contents_len,
             .Unmap,
             .{},
-            .{ .READWRITE = true },
+            page,
         )) {
             .SUCCESS => {},
             .CONFLICTING_ADDRESSES => return error.MappingAlreadyExists,
 @@ -16363,16 +16366,20 @@ fn fileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
     const memory = mm.memory;
     if (mm.section) |section| switch (native_os) {
         .windows => {
+            if (section == windows.INVALID_HANDLE_VALUE) return;
             _ = windows.ntdll.NtUnmapViewOfSection(windows.current_process, memory.ptr);
             windows.CloseHandle(section);
         },
         .wasi => unreachable,
-        else => switch (posix.errno(posix.system.munmap(memory.ptr, memory.len))) {
+        else => {
-            .SUCCESS => {},
+            if (memory.len == 0) return;
-            else => |e| {
+            switch (posix.errno(posix.system.munmap(memory.ptr, memory.len))) {
-                if (builtin.mode == .Debug)
+                .SUCCESS => {},
-                    std.log.err("failed to unmap {d} bytes at {*}: {t}", .{ memory.len, memory.ptr, e });
+                else => |e| {
-            },
+                    if (builtin.mode == .Debug)
+                        std.log.err("failed to unmap {d} bytes at {*}: {t}", .{ memory.len, memory.ptr, e });
+                },
+            }
         },
     } else {
         const gpa = t.allocator;
 @@ -16394,47 +16401,16 @@ fn fileMemoryMapSetLength(
     const new_len = options.len;
     if (mm.section) |section| {
-        const aligned_old_len = alignment.forward(old_memory.len);
+        if (alignment.forward(new_len) == alignment.forward(old_memory.len)) {
-        const aligned_new_len = alignment.forward(new_len);
-        if (aligned_new_len == aligned_old_len) {
             mm.memory.len = new_len;
             return;
         }
         switch (native_os) {
             .windows => {
-                if (aligned_new_len > aligned_old_len) {
+                _ = windows.ntdll.NtUnmapViewOfSection(windows.current_process, old_memory.ptr);
-                    var new_section_size: windows.LARGE_INTEGER = @intCast(aligned_new_len);
+                windows.CloseHandle(section);
-                    switch (windows.ntdll.NtExtendSection(section, &new_section_size)) {
+                mm.section = windows.INVALID_HANDLE_VALUE;
-                        .SUCCESS => {},
+                mm.memory = &.{};
-                        else => |status| return windows.unexpectedStatus(status),
-                    }
-                    assert(new_section_size == aligned_new_len);
-                    mm.memory.len = new_len;
-                } else {
-                    _ = windows.ntdll.NtUnmapViewOfSection(windows.current_process, old_memory.ptr);
-                    windows.CloseHandle(section);
-                    var contents_len = aligned_new_len;
-                    var contents_ptr: ?[*]align(std.heap.page_size_min) u8 = null;
-                    switch (windows.ntdll.NtMapViewOfSection(
-                        section,
-                        windows.current_process,
-                        @ptrCast(&contents_ptr),
-                        null,
-                        0,
-                        null,
-                        &contents_len,
-                        .Unmap,
-                        .{},
-                        .{ .READWRITE = true },
-                    )) {
-                        .SUCCESS => {},
-                        .SECTION_PROTECTION => return error.PermissionDenied,
-                        .INVALID_VIEW_SIZE => |status| return windows.statusBug(status),
-                        else => |status| return windows.unexpectedStatus(status),
-                    }
-                    assert(contents_len == aligned_new_len);
-                    mm.memory = contents_ptr.?[0..new_len];
-                }
             },
             .wasi => unreachable,
             .linux => {
 @@ -16463,6 +16439,7 @@ fn fileMemoryMapSetLength(
                     }
                 };
                 mm.memory = new_memory;
+                return;
             },
             else => {
                 switch (posix.errno(posix.system.munmap(old_memory.ptr, old_memory.len))) {
 @@ -16475,20 +16452,21 @@ fn fileMemoryMapSetLength(
                         return error.Unexpected;
                     },
                 }
-                if (createFileMap(mm.file, options.protection, mm.offset, options.populate, new_len)) |result| {
+                mm.memory = &.{};
-                    mm.* = result;
-                    return;
-                } else |err| switch (err) {
-                    error.OperationUnsupported,
-                    error.Unseekable,
-                    error.SectionOversize,
-                    error.MappingAlreadyExists,
-                    error.FileLockConflict,
-                    => return error.Unexpected, // It worked before on the same open file.
-                    else => |e| return e,
-                }
             },
         }
+        if (createFileMap(mm.file, options.protection, mm.offset, options.populate, new_len)) |result| {
+            mm.* = result;
+            return;
+        } else |err| switch (err) {
+            error.OperationUnsupported,
+            error.Unseekable,
+            error.SectionOversize,
+            error.MappingAlreadyExists,
+            error.FileLockConflict,
+            => return error.Unexpected, // It worked before on the same open file.
+            else => |e| return e,
+        }
     } else {
         const gpa = t.allocator;
         if (gpa.rawRemap(old_memory, alignment, new_len, @returnAddress())) |new_ptr| {

lib/std/Io/test.zig+4-3

 @@ -629,19 +629,20 @@ test "memory mapping" {
     try expectEqualStrings("this9is9my data123", updated_contents);
     {
-        var file = try tmp.dir.openFile(io, "blah.txt", .{ .mode = .read_only });
+        var file = try tmp.dir.openFile(io, "blah.txt", .{ .mode = .read_write });
         defer file.close(io);
         var mm = try file.createMemoryMap(io, .{
             .len = "this9is9my".len,
-            .protection = .{ .read = true },
         });
         defer mm.destroy(io);
         try expectEqualStrings("this9is9my", mm.memory);
         // Cross a page boundary to require an actual remap.
-        try mm.setLength(io, .{ .len = std.heap.pageSize() * 2 });
+        try mm.setLength(io, .{
+            .len = std.heap.pageSize() * 2,
+        });
         try mm.read(io);
         try expectEqualStrings("this9is9my data123\x00\x00", mm.memory[0.."this9is9my data123\x00\x00".len]);

lib/std/os/windows.zig+14

...	@@ -2126,6 +2126,20 @@ pub const PAGE = packed struct(ULONG) {	...	@@ -2126,6 +2126,20 @@ pub const PAGE = packed struct(ULONG) {
2126	Reserved19: u12 = 0,	2126	Reserved19: u12 = 0,
2127		2127
2128	REVERT_TO_FILE_MAP: bool = false,	2128	REVERT_TO_FILE_MAP: bool = false,
		2129
		2130	pub fn fromProtection(protection: std.process.MemoryProtection) ?PAGE {
		2131	// TODO https://github.com/ziglang/zig/issues/22214
		2132	return switch (@as(u3, @bitCast(protection))) {
		2133	0b000 => .{ .NOACCESS = true },
		2134	0b001 => .{ .READONLY = true },
		2135	0b010 => null,
		2136	0b011 => .{ .READWRITE = true },
		2137	0b100 => .{ .EXECUTE = true },
		2138	0b101 => .{ .EXECUTE_READ = true },
		2139	0b110 => null,
		2140	0b111 => .{ .EXECUTE_READWRITE = true },
		2141	};
		2142	}
2129	};	2143	};
2130		2144
2131	pub const MEM = struct {	2145	pub const MEM = struct {

lib/std/process.zig+1-10

...	@@ -1030,16 +1030,7 @@ pub fn protectMemory(memory: []align(std.heap.page_size_min) u8, protection: Mem	...	@@ -1030,16 +1030,7 @@ pub fn protectMemory(memory: []align(std.heap.page_size_min) u8, protection: Mem
1030	var size = memory.len; // ntdll takes an extra level of indirection here	1030	var size = memory.len; // ntdll takes an extra level of indirection here
1031	var old: windows.PAGE = undefined;	1031	var old: windows.PAGE = undefined;
1032	const current_process: windows.HANDLE = @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))));	1032	const current_process: windows.HANDLE = @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))));
1033	const new: windows.PAGE = switch (@as(u3, @bitCast(protection))) {	1033	const new = windows.PAGE.fromProtection(protection) orelse return error.AccessDenied;
1034	0b000 => .{ .NOACCESS = true },
1035	0b001 => .{ .READONLY = true },
1036	0b010 => return error.AccessDenied, // +w -r not allowed
1037	0b011 => .{ .READWRITE = true },
1038	0b100 => .{ .EXECUTE = true },
1039	0b101 => .{ .EXECUTE_READ = true },
1040	0b110 => return error.AccessDenied, // +w -r not allowed
1041	0b111 => .{ .EXECUTE_READWRITE = true },
1042	};
1043	switch (windows.ntdll.NtProtectVirtualMemory(current_process, @ptrCast(&addr), &size, new, &old)) {	1034	switch (windows.ntdll.NtProtectVirtualMemory(current_process, @ptrCast(&addr), &size, new, &old)) {
1044	.SUCCESS => return,	1035	.SUCCESS => return,
1045	.INVALID_ADDRESS => return error.AccessDenied,	1036	.INVALID_ADDRESS => return error.AccessDenied,

author	Andrew Kelley <andrew@ziglang.org> 2026-01-15 14:10:09-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-01-15 14:18:21-08:00
log	7b21fd7244ed1b0459b542346e96a20e91138f69
tree	f5a448d213c0176b5a20cd03e59a9f69765c2af7
parent	d2585e68a79b8e43166e797d6adc33282acac046

std.Io.Threaded: fix memory mapping on windows