Commit 2def23063fbabb4128da17aca27745a7e8062ce5 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-05-24 00:13:13-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-05-26 18:32:44-04:00
log	2def23063fbabb4128da17aca27745a7e8062ce5
tree	53d8e79eebc72a0ff171ff6f911e2c4eb2ef5cdc
parent	daae7e1f5aa5aac02a342c9a60d703c2a0cba579
signature	Commit is signed but in an unrecognized format.

more progress. moving windows API layer to its own file

14 files changed, 1331 insertions(+), 1317 deletions(-)

CMakeLists.txt
std
- dynamic_library.zig
- event
  - fs.zig
- os.zig
- os
  - child_process.zig
  - linux.zig
  - linux
    sys.zig
  - posix.zig
  - windows.zig
  - windows
    advapi32.zig
    kernel32.zig
    ole32.zig
    posix.zig
    util.zig

CMakeLists.txt+1

...	@@ -619,6 +619,7 @@ set(ZIG_STD_FILES	...	@@ -619,6 +619,7 @@ set(ZIG_STD_FILES
619	"os/linux/posix.zig"	619	"os/linux/posix.zig"
620	"os/linux/posix/arm64.zig"	620	"os/linux/posix/arm64.zig"
621	"os/linux/posix/x86_64.zig"	621	"os/linux/posix/x86_64.zig"
		622	"os/linux/sys.zig"
622	"os/linux/tls.zig"	623	"os/linux/tls.zig"
623	"os/linux/vdso.zig"	624	"os/linux/vdso.zig"
624	"os/linux/x86_64.zig"	625	"os/linux/x86_64.zig"

std/dynamic_library.zig+2-3

 @@ -261,12 +261,11 @@ pub const WindowsDynLib = struct {
         return WindowsDynLib{
             .allocator = allocator,
             .dll = windows.LoadLibraryW(&wpath) orelse {
-                const err = windows.GetLastError();
+                switch (windows.GetLastError()) {
-                switch (err) {
                     windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
                     windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
                     windows.ERROR.MOD_NOT_FOUND => return error.FileNotFound,
-                    else => return os.unexpectedErrorWindows(err),
+                    else => |err| return windows.unexpectedError(err),
                 }
             },
         };

std/event/fs.zig+14-18

 @@ -154,16 +154,15 @@ pub async fn pwriteWindows(loop: *Loop, fd: fd_t, data: []const u8, offset: u64)
     }
     var bytes_transferred: windows.DWORD = undefined;
     if (windows.GetOverlappedResult(fd, &resume_node.base.overlapped, &bytes_transferred, windows.FALSE) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        return switch (err) {
             windows.ERROR.IO_PENDING => unreachable,
-            windows.ERROR.INVALID_USER_BUFFER => error.SystemResources,
+            windows.ERROR.INVALID_USER_BUFFER => return error.SystemResources,
-            windows.ERROR.NOT_ENOUGH_MEMORY => error.SystemResources,
+            windows.ERROR.NOT_ENOUGH_MEMORY => return error.SystemResources,
-            windows.ERROR.OPERATION_ABORTED => error.OperationAborted,
+            windows.ERROR.OPERATION_ABORTED => return error.OperationAborted,
-            windows.ERROR.NOT_ENOUGH_QUOTA => error.SystemResources,
+            windows.ERROR.NOT_ENOUGH_QUOTA => return error.SystemResources,
-            windows.ERROR.BROKEN_PIPE => error.BrokenPipe,
+            windows.ERROR.BROKEN_PIPE => return error.BrokenPipe,
-            else => os.unexpectedErrorWindows(err),
+            else => |err| return windows.unexpectedError(err),
-        };
+        }
     }
 }
 @@ -304,13 +303,12 @@ pub async fn preadWindows(loop: *Loop, fd: fd_t, data: []u8, offset: u64) !usize
     }
     var bytes_transferred: windows.DWORD = undefined;
     if (windows.GetOverlappedResult(fd, &resume_node.base.overlapped, &bytes_transferred, windows.FALSE) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        switch (err) {
             windows.ERROR.IO_PENDING => unreachable,
             windows.ERROR.OPERATION_ABORTED => return error.OperationAborted,
             windows.ERROR.BROKEN_PIPE => return error.BrokenPipe,
             windows.ERROR.HANDLE_EOF => return usize(bytes_transferred),
-            else => return os.unexpectedErrorWindows(err),
+            else => |err| return windows.unexpectedError(err),
         }
     }
     return usize(bytes_transferred);
 @@ -1042,11 +1040,10 @@ pub fn Watch(comptime V: type) type {
                 null,
             );
             if (dir_handle == windows.INVALID_HANDLE_VALUE) {
-                const err = windows.GetLastError();
+                switch (windows.GetLastError()) {
-                switch (err) {
                     windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
                     windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
-                    else => return os.unexpectedErrorWindows(err),
+                    else => |err| return windows.unexpectedError(err),
                 }
             }
             var dir_handle_consumed = false;
 @@ -1165,9 +1162,8 @@ pub fn Watch(comptime V: type) type {
                 }
                 var bytes_transferred: windows.DWORD = undefined;
                 if (windows.GetOverlappedResult(dir_handle, &resume_node.base.overlapped, &bytes_transferred, windows.FALSE) == 0) {
-                    const errno = windows.GetLastError();
+                    const err = switch (windows.GetLastError()) {
-                    const err = switch (errno) {
+                        else => |err| windows.unexpectedError(err),
-                        else => os.unexpectedErrorWindows(errno),
                     };
                     await (async self.channel.put(err) catch unreachable);
                 } else {

std/os.zig+14-8

 @@ -31,13 +31,14 @@ pub const zen = @import("os/zen.zig");
 pub const uefi = @import("os/uefi.zig");
 pub const wasi = @import("os/wasi.zig");
-pub const system = switch (builtin.os) {
+pub const system = if (builtin.link_libc) std.c else switch (builtin.os) {
     .linux => linux,
     .macosx, .ios, .watchos, .tvos => darwin,
     .freebsd => freebsd,
     .netbsd => netbsd,
     .zen => zen,
     .wasi => wasi,
+    .windows => windows,
     else => struct {},
 };
 @@ -53,6 +54,12 @@ pub const page_size = switch (builtin.arch) {
     else => 4 * 1024,
 };
+pub const unexpected_error_tracing = builtin.mode == .Debug;
+pub const UnexpectedError = error{
+    /// The Operating System returned an undocumented error code.
+    Unexpected,
+};
 /// This represents the maximum size of a UTF-8 encoded file path.
 /// All file system operations which return a path are guaranteed to
 /// fit into a UTF-8 encoded array of this length.
 @@ -259,7 +266,7 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned
                 return switch (err) {
                     windows.ERROR.ENVVAR_NOT_FOUND => error.EnvironmentVariableNotFound,
                     else => {
-                        unexpectedErrorWindows(err) catch {};
+                        windows.unexpectedError(err) catch {};
                         return error.EnvironmentVariableNotFound;
                     },
                 };
 @@ -825,7 +832,7 @@ pub const Dir = struct {
             if (self.handle.first) {
                 self.handle.first = false;
             } else {
-                if (!try windows_util.windowsFindNextFile(self.handle.handle, &self.handle.find_file_data))
+                if (!try posix.FindNextFile(self.handle.handle, &self.handle.find_file_data))
                     return null;
             }
             const name_utf16le = mem.toSlice(u16, self.handle.find_file_data.cFileName[0..].ptr);
 @@ -1333,7 +1340,7 @@ pub fn selfExePathW(out_buffer: *[posix.PATH_MAX_WIDE]u16) ![]u16 {
     if (rc == 0) {
         const err = windows.GetLastError();
         switch (err) {
-            else => return unexpectedErrorWindows(err),
+            else => return windows.unexpectedError(err),
         }
     }
     return out_buffer[0..rc];
 @@ -1597,10 +1604,9 @@ pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!*Thread
         const parameter = if (@sizeOf(Context) == 0) null else @ptrCast(*c_void, &outer_context.inner);
         outer_context.thread.data.handle = windows.CreateThread(null, default_stack_size, WinThread.threadMain, parameter, 0, null) orelse {
-            const err = windows.GetLastError();
+            switch (windows.GetLastError()) {
-            return switch (err) {
+                else => |err| windows.unexpectedError(err),
-                else => os.unexpectedErrorWindows(err),
+            }
-            };
         };
         return &outer_context.thread;
     }

std/os/child_process.zig+42-28

 @@ -558,7 +558,7 @@ pub const ChildProcess = struct {
         defer if (cwd_w) |cwd| self.allocator.free(cwd);
         const cwd_w_ptr = if (cwd_w) |cwd| cwd.ptr else null;
-        const maybe_envp_buf = if (self.env_map) |env_map| try os.createWindowsEnvBlock(self.allocator, env_map) else null;
+        const maybe_envp_buf = if (self.env_map) |env_map| try createWindowsEnvBlock(self.allocator, env_map) else null;
         defer if (maybe_envp_buf) |envp_buf| self.allocator.free(envp_buf);
         const envp_ptr = if (maybe_envp_buf) |envp_buf| envp_buf.ptr else null;
 @@ -679,13 +679,12 @@ fn windowsCreateProcess(app_name: [*]u16, cmd_line: [*]u16, envp_ptr: ?[*]u16, c
         lpStartupInfo,
         lpProcessInformation,
     ) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        switch (err) {
             windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
             windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
             windows.ERROR.INVALID_PARAMETER => unreachable,
             windows.ERROR.INVALID_NAME => return error.InvalidName,
-            else => return os.unexpectedErrorWindows(err),
+            else => |err| return windows.unexpectedError(err),
         }
     }
 }
 @@ -733,32 +732,10 @@ fn windowsDestroyPipe(rd: ?windows.HANDLE, wr: ?windows.HANDLE) void {
     if (wr) |h| os.close(h);
 }
-// TODO: workaround for bug where the `const` from `&const` is dropped when the type is
-// a namespace field lookup
-const SECURITY_ATTRIBUTES = windows.SECURITY_ATTRIBUTES;
-fn windowsMakePipe(rd: *windows.HANDLE, wr: *windows.HANDLE, sattr: *const SECURITY_ATTRIBUTES) !void {
-    if (windows.CreatePipe(rd, wr, sattr, 0) == 0) {
-        const err = windows.GetLastError();
-        return switch (err) {
-            else => os.unexpectedErrorWindows(err),
-        };
-    }
-}
-fn windowsSetHandleInfo(h: windows.HANDLE, mask: windows.DWORD, flags: windows.DWORD) !void {
-    if (windows.SetHandleInformation(h, mask, flags) == 0) {
-        const err = windows.GetLastError();
-        return switch (err) {
-            else => os.unexpectedErrorWindows(err),
-        };
-    }
-}
 fn windowsMakePipeIn(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *const SECURITY_ATTRIBUTES) !void {
     var rd_h: windows.HANDLE = undefined;
     var wr_h: windows.HANDLE = undefined;
-    try windowsMakePipe(&rd_h, &wr_h, sattr);
+    try windows.CreatePipe(&rd_h, &wr_h, sattr);
     errdefer windowsDestroyPipe(rd_h, wr_h);
     try windowsSetHandleInfo(wr_h, windows.HANDLE_FLAG_INHERIT, 0);
     rd.* = rd_h;
 @@ -768,7 +745,7 @@ fn windowsMakePipeIn(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *const S
 fn windowsMakePipeOut(rd: *?windows.HANDLE, wr: *?windows.HANDLE, sattr: *const SECURITY_ATTRIBUTES) !void {
     var rd_h: windows.HANDLE = undefined;
     var wr_h: windows.HANDLE = undefined;
-    try windowsMakePipe(&rd_h, &wr_h, sattr);
+    try windows.CreatePipe(&rd_h, &wr_h, sattr);
     errdefer windowsDestroyPipe(rd_h, wr_h);
     try windowsSetHandleInfo(rd_h, windows.HANDLE_FLAG_INHERIT, 0);
     rd.* = rd_h;
 @@ -810,3 +787,40 @@ fn readIntFd(fd: i32) !ErrInt {
     const stream = &os.File.openHandle(fd).inStream().stream;
     return stream.readIntNative(ErrInt) catch return error.SystemResources;
 }
+/// Caller must free result.
+pub fn createWindowsEnvBlock(allocator: *mem.Allocator, env_map: *const BufMap) ![]u16 {
+    // count bytes needed
+    const max_chars_needed = x: {
+        var max_chars_needed: usize = 4; // 4 for the final 4 null bytes
+        var it = env_map.iterator();
+        while (it.next()) |pair| {
+            // +1 for '='
+            // +1 for null byte
+            max_chars_needed += pair.key.len + pair.value.len + 2;
+        }
+        break :x max_chars_needed;
+    };
+    const result = try allocator.alloc(u16, max_chars_needed);
+    errdefer allocator.free(result);
+    var it = env_map.iterator();
+    var i: usize = 0;
+    while (it.next()) |pair| {
+        i += try unicode.utf8ToUtf16Le(result[i..], pair.key);
+        result[i] = '=';
+        i += 1;
+        i += try unicode.utf8ToUtf16Le(result[i..], pair.value);
+        result[i] = 0;
+        i += 1;
+    }
+    result[i] = 0;
+    i += 1;
+    result[i] = 0;
+    i += 1;
+    result[i] = 0;
+    i += 1;
+    result[i] = 0;
+    i += 1;
+    return allocator.shrink(result, i);
+}

std/os/linux.zig+2-765

...	@@ -1,771 +1,8 @@	...	@@ -1,771 +1,8 @@
1	const std = @import("../std.zig");	1	const std = @import("../std.zig");
2	const assert = std.debug.assert;
3	const builtin = @import("builtin");	2	const builtin = @import("builtin");
4	const maxInt = std.math.maxInt;
5	const elf = std.elf;
6	pub const tls = @import("linux/tls.zig");
7	const vdso = @import("linux/vdso.zig");
8	const dl = @import("../dynamic_library.zig");
9	pub use switch (builtin.arch) {
10	.x86_64 => @import("linux/x86_64.zig"),
11	.aarch64 => @import("linux/arm64.zig"),
12	else => struct {},
13	};
14	pub const is_the_target = builtin.os == .linux;	3	pub const is_the_target = builtin.os == .linux;
15	pub const posix = @import("linux/posix.zig");	4	pub const sys = @import("linux/sys.zig");
16	pub use posix;	5	pub use if (builtin.link_libc) std.c else sys;
17
18	/// See `std.os.posix.getauxval`.
19	pub var elf_aux_maybe: ?[*]std.elf.Auxv = null;
20
21	/// Get the errno from a syscall return value, or 0 for no error.
22	pub fn getErrno(r: usize) u12 {
23	const signed_r = @bitCast(isize, r);
24	return if (signed_r > -4096 and signed_r < 0) @intCast(u12, -signed_r) else 0;
25	}
26
27	pub fn dup2(old: i32, new: i32) usize {
28	return syscall2(SYS_dup2, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)));
29	}
30
31	pub fn dup3(old: i32, new: i32, flags: u32) usize {
32	return syscall3(SYS_dup3, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)), flags);
33	}
34
35	// TODO https://github.com/ziglang/zig/issues/265
36	pub fn chdir(path: [*]const u8) usize {
37	return syscall1(SYS_chdir, @ptrToInt(path));
38	}
39
40	// TODO https://github.com/ziglang/zig/issues/265
41	pub fn chroot(path: [*]const u8) usize {
42	return syscall1(SYS_chroot, @ptrToInt(path));
43	}
44
45	// TODO https://github.com/ziglang/zig/issues/265
46	pub fn execve(path: []const u8, argv: []const ?[]const u8, envp: []const ?[*]const u8) usize {
47	return syscall3(SYS_execve, @ptrToInt(path), @ptrToInt(argv), @ptrToInt(envp));
48	}
49
50	pub fn fork() usize {
51	return syscall0(SYS_fork);
52	}
53
54	/// This must be inline, and inline call the syscall function, because if the
55	/// child does a return it will clobber the parent's stack.
56	/// It is advised to avoid this function and use clone instead, because
57	/// the compiler is not aware of how vfork affects control flow and you may
58	/// see different results in optimized builds.
59	pub inline fn vfork() usize {
60	return @inlineCall(syscall0, SYS_vfork);
61	}
62
63	pub fn futex_wait(uaddr: const i32, futex_op: u32, val: i32, timeout: ?timespec) usize {
64	return syscall4(SYS_futex, @ptrToInt(uaddr), futex_op, @bitCast(u32, val), @ptrToInt(timeout));
65	}
66
67	pub fn futex_wake(uaddr: *const i32, futex_op: u32, val: i32) usize {
68	return syscall3(SYS_futex, @ptrToInt(uaddr), futex_op, @bitCast(u32, val));
69	}
70
71	pub fn getcwd(buf: [*]u8, size: usize) usize {
72	return syscall2(SYS_getcwd, @ptrToInt(buf), size);
73	}
74
75	pub fn getdents(fd: i32, dirp: [*]u8, count: usize) usize {
76	return syscall3(SYS_getdents, @bitCast(usize, isize(fd)), @ptrToInt(dirp), count);
77	}
78
79	pub fn getdents64(fd: i32, dirp: [*]u8, count: usize) usize {
80	return syscall3(SYS_getdents64, @bitCast(usize, isize(fd)), @ptrToInt(dirp), count);
81	}
82
83	pub fn inotify_init1(flags: u32) usize {
84	return syscall1(SYS_inotify_init1, flags);
85	}
86
87	pub fn inotify_add_watch(fd: i32, pathname: [*]const u8, mask: u32) usize {
88	return syscall3(SYS_inotify_add_watch, @bitCast(usize, isize(fd)), @ptrToInt(pathname), mask);
89	}
90
91	pub fn inotify_rm_watch(fd: i32, wd: i32) usize {
92	return syscall2(SYS_inotify_rm_watch, @bitCast(usize, isize(fd)), @bitCast(usize, isize(wd)));
93	}
94
95	// TODO https://github.com/ziglang/zig/issues/265
96	pub fn readlink(noalias path: []const u8, noalias buf_ptr: []u8, buf_len: usize) usize {
97	return syscall3(SYS_readlink, @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
98	}
99
100	// TODO https://github.com/ziglang/zig/issues/265
101	pub fn readlinkat(dirfd: i32, noalias path: []const u8, noalias buf_ptr: []u8, buf_len: usize) usize {
102	return syscall4(SYS_readlinkat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
103	}
104
105	// TODO https://github.com/ziglang/zig/issues/265
106	pub fn mkdir(path: [*]const u8, mode: u32) usize {
107	return syscall2(SYS_mkdir, @ptrToInt(path), mode);
108	}
109
110	// TODO https://github.com/ziglang/zig/issues/265
111	pub fn mkdirat(dirfd: i32, path: [*]const u8, mode: u32) usize {
112	return syscall3(SYS_mkdirat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), mode);
113	}
114
115	// TODO https://github.com/ziglang/zig/issues/265
116	pub fn mount(special: []const u8, dir: []const u8, fstype: [*]const u8, flags: u32, data: usize) usize {
117	return syscall5(SYS_mount, @ptrToInt(special), @ptrToInt(dir), @ptrToInt(fstype), flags, data);
118	}
119
120	// TODO https://github.com/ziglang/zig/issues/265
121	pub fn umount(special: [*]const u8) usize {
122	return syscall2(SYS_umount2, @ptrToInt(special), 0);
123	}
124
125	// TODO https://github.com/ziglang/zig/issues/265
126	pub fn umount2(special: [*]const u8, flags: u32) usize {
127	return syscall2(SYS_umount2, @ptrToInt(special), flags);
128	}
129
130	pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: u32, fd: i32, offset: isize) usize {
131	return syscall6(SYS_mmap, @ptrToInt(address), length, prot, flags, @bitCast(usize, isize(fd)), @bitCast(usize, offset));
132	}
133
134	pub fn mprotect(address: usize, length: usize, protection: usize) usize {
135	return syscall3(SYS_mprotect, address, length, protection);
136	}
137
138	pub fn munmap(address: usize, length: usize) usize {
139	return syscall2(SYS_munmap, address, length);
140	}
141
142	pub fn read(fd: i32, buf: [*]u8, count: usize) usize {
143	return syscall3(SYS_read, @bitCast(usize, isize(fd)), @ptrToInt(buf), count);
144	}
145
146	pub fn preadv(fd: i32, iov: [*]const iovec, count: usize, offset: u64) usize {
147	return syscall4(SYS_preadv, @bitCast(usize, isize(fd)), @ptrToInt(iov), count, offset);
148	}
149
150	pub fn readv(fd: i32, iov: [*]const iovec, count: usize) usize {
151	return syscall3(SYS_readv, @bitCast(usize, isize(fd)), @ptrToInt(iov), count);
152	}
153
154	pub fn writev(fd: i32, iov: [*]const iovec_const, count: usize) usize {
155	return syscall3(SYS_writev, @bitCast(usize, isize(fd)), @ptrToInt(iov), count);
156	}
157
158	pub fn pwritev(fd: i32, iov: [*]const iovec_const, count: usize, offset: u64) usize {
159	return syscall4(SYS_pwritev, @bitCast(usize, isize(fd)), @ptrToInt(iov), count, offset);
160	}
161
162	// TODO https://github.com/ziglang/zig/issues/265
163	pub fn rmdir(path: [*]const u8) usize {
164	return syscall1(SYS_rmdir, @ptrToInt(path));
165	}
166
167	// TODO https://github.com/ziglang/zig/issues/265
168	pub fn symlink(existing: []const u8, new: []const u8) usize {
169	return syscall2(SYS_symlink, @ptrToInt(existing), @ptrToInt(new));
170	}
171
172	// TODO https://github.com/ziglang/zig/issues/265
173	pub fn symlinkat(existing: []const u8, newfd: i32, newpath: []const u8) usize {
174	return syscall3(SYS_symlinkat, @ptrToInt(existing), @bitCast(usize, isize(newfd)), @ptrToInt(newpath));
175	}
176
177	// TODO https://github.com/ziglang/zig/issues/265
178	pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: usize) usize {
179	return syscall4(SYS_pread, @bitCast(usize, isize(fd)), @ptrToInt(buf), count, offset);
180	}
181
182	// TODO https://github.com/ziglang/zig/issues/265
183	pub fn access(path: [*]const u8, mode: u32) usize {
184	return syscall2(SYS_access, @ptrToInt(path), mode);
185	}
186
187	// TODO https://github.com/ziglang/zig/issues/265
188	pub fn faccessat(dirfd: i32, path: [*]const u8, mode: u32) usize {
189	return syscall3(SYS_faccessat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), mode);
190	}
191
192	pub fn pipe(fd: *[2]i32) usize {
193	return pipe2(fd, 0);
194	}
195
196	pub fn pipe2(fd: *[2]i32, flags: u32) usize {
197	return syscall2(SYS_pipe2, @ptrToInt(fd), flags);
198	}
199
200	pub fn write(fd: i32, buf: [*]const u8, count: usize) usize {
201	return syscall3(SYS_write, @bitCast(usize, isize(fd)), @ptrToInt(buf), count);
202	}
203
204	pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: usize) usize {
205	return syscall4(SYS_pwrite, @bitCast(usize, isize(fd)), @ptrToInt(buf), count, offset);
206	}
207
208	// TODO https://github.com/ziglang/zig/issues/265
209	pub fn rename(old: []const u8, new: []const u8) usize {
210	return syscall2(SYS_rename, @ptrToInt(old), @ptrToInt(new));
211	}
212
213	// TODO https://github.com/ziglang/zig/issues/265
214	pub fn renameat2(oldfd: i32, oldpath: []const u8, newfd: i32, newpath: []const u8, flags: u32) usize {
215	return syscall5(SYS_renameat2, @bitCast(usize, isize(oldfd)), @ptrToInt(oldpath), @bitCast(usize, isize(newfd)), @ptrToInt(newpath), flags);
216	}
217
218	// TODO https://github.com/ziglang/zig/issues/265
219	pub fn open(path: [*]const u8, flags: u32, perm: usize) usize {
220	return syscall3(SYS_open, @ptrToInt(path), flags, perm);
221	}
222
223	// TODO https://github.com/ziglang/zig/issues/265
224	pub fn create(path: [*]const u8, perm: usize) usize {
225	return syscall2(SYS_creat, @ptrToInt(path), perm);
226	}
227
228	// TODO https://github.com/ziglang/zig/issues/265
229	pub fn openat(dirfd: i32, path: [*]const u8, flags: u32, mode: usize) usize {
230	// dirfd could be negative, for example AT_FDCWD is -100
231	return syscall4(SYS_openat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), flags, mode);
232	}
233
234	/// See also `clone` (from the arch-specific include)
235	pub fn clone5(flags: usize, child_stack_ptr: usize, parent_tid: i32, child_tid: i32, newtls: usize) usize {
236	return syscall5(SYS_clone, flags, child_stack_ptr, @ptrToInt(parent_tid), @ptrToInt(child_tid), newtls);
237	}
238
239	/// See also `clone` (from the arch-specific include)
240	pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
241	return syscall2(SYS_clone, flags, child_stack_ptr);
242	}
243
244	pub fn close(fd: i32) usize {
245	return syscall1(SYS_close, @bitCast(usize, isize(fd)));
246	}
247
248	pub fn lseek(fd: i32, offset: isize, ref_pos: usize) usize {
249	return syscall3(SYS_lseek, @bitCast(usize, isize(fd)), @bitCast(usize, offset), ref_pos);
250	}
251
252	pub fn exit(status: i32) noreturn {
253	_ = syscall1(SYS_exit, @bitCast(usize, isize(status)));
254	unreachable;
255	}
256
257	pub fn exit_group(status: i32) noreturn {
258	_ = syscall1(SYS_exit_group, @bitCast(usize, isize(status)));
259	unreachable;
260	}
261
262	pub fn getrandom(buf: [*]u8, count: usize, flags: u32) usize {
263	return syscall3(SYS_getrandom, @ptrToInt(buf), count, flags);
264	}
265
266	pub fn kill(pid: i32, sig: i32) usize {
267	return syscall2(SYS_kill, @bitCast(usize, isize(pid)), @bitCast(usize, isize(sig)));
268	}
269
270	// TODO https://github.com/ziglang/zig/issues/265
271	pub fn unlink(path: [*]const u8) usize {
272	return syscall1(SYS_unlink, @ptrToInt(path));
273	}
274
275	// TODO https://github.com/ziglang/zig/issues/265
276	pub fn unlinkat(dirfd: i32, path: [*]const u8, flags: u32) usize {
277	return syscall3(SYS_unlinkat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), flags);
278	}
279
280	pub fn waitpid(pid: i32, status: *i32, options: i32) usize {
281	return syscall4(SYS_wait4, @bitCast(usize, isize(pid)), @ptrToInt(status), @bitCast(usize, isize(options)), 0);
282	}
283
284	var vdso_clock_gettime = @ptrCast(?*const c_void, init_vdso_clock_gettime);
285
286	// We must follow the C calling convention when we call into the VDSO
287	const vdso_clock_gettime_ty = extern fn (i32, *timespec) usize;
288
289	pub fn clock_gettime(clk_id: i32, tp: *timespec) usize {
290	if (VDSO_CGT_SYM.len != 0) {
291	const ptr = @atomicLoad(?*const c_void, &vdso_clock_gettime, .Unordered);
292	if (ptr) \|fn_ptr\| {
293	const f = @ptrCast(vdso_clock_gettime_ty, fn_ptr);
294	const rc = f(clk_id, tp);
295	switch (rc) {
296	0, @bitCast(usize, isize(-EINVAL)) => return rc,
297	else => {},
298	}
299	}
300	}
301	return syscall2(SYS_clock_gettime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
302	}
303
304	extern fn init_vdso_clock_gettime(clk: i32, ts: *timespec) usize {
305	const ptr = @intToPtr(?*const c_void, vdso.lookup(VDSO_CGT_VER, VDSO_CGT_SYM));
306	// Note that we may not have a VDSO at all, update the stub address anyway
307	// so that clock_gettime will fall back on the good old (and slow) syscall
308	_ = @cmpxchgStrong(?*const c_void, &vdso_clock_gettime, &init_vdso_clock_gettime, ptr, .Monotonic, .Monotonic);
309	// Call into the VDSO if available
310	if (ptr) \|fn_ptr\| {
311	const f = @ptrCast(vdso_clock_gettime_ty, fn_ptr);
312	return f(clk, ts);
313	}
314	return @bitCast(usize, isize(-ENOSYS));
315	}
316
317	pub fn clock_getres(clk_id: i32, tp: *timespec) usize {
318	return syscall2(SYS_clock_getres, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
319	}
320
321	pub fn clock_settime(clk_id: i32, tp: *const timespec) usize {
322	return syscall2(SYS_clock_settime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
323	}
324
325	pub fn gettimeofday(tv: timeval, tz: timezone) usize {
326	return syscall2(SYS_gettimeofday, @ptrToInt(tv), @ptrToInt(tz));
327	}
328
329	pub fn settimeofday(tv: const timeval, tz: const timezone) usize {
330	return syscall2(SYS_settimeofday, @ptrToInt(tv), @ptrToInt(tz));
331	}
332
333	pub fn nanosleep(req: const timespec, rem: ?timespec) usize {
334	return syscall2(SYS_nanosleep, @ptrToInt(req), @ptrToInt(rem));
335	}
336
337	pub fn setuid(uid: u32) usize {
338	return syscall1(SYS_setuid, uid);
339	}
340
341	pub fn setgid(gid: u32) usize {
342	return syscall1(SYS_setgid, gid);
343	}
344
345	pub fn setreuid(ruid: u32, euid: u32) usize {
346	return syscall2(SYS_setreuid, ruid, euid);
347	}
348
349	pub fn setregid(rgid: u32, egid: u32) usize {
350	return syscall2(SYS_setregid, rgid, egid);
351	}
352
353	pub fn getuid() u32 {
354	return u32(syscall0(SYS_getuid));
355	}
356
357	pub fn getgid() u32 {
358	return u32(syscall0(SYS_getgid));
359	}
360
361	pub fn geteuid() u32 {
362	return u32(syscall0(SYS_geteuid));
363	}
364
365	pub fn getegid() u32 {
366	return u32(syscall0(SYS_getegid));
367	}
368
369	pub fn seteuid(euid: u32) usize {
370	return syscall1(SYS_seteuid, euid);
371	}
372
373	pub fn setegid(egid: u32) usize {
374	return syscall1(SYS_setegid, egid);
375	}
376
377	pub fn getresuid(ruid: u32, euid: u32, suid: *u32) usize {
378	return syscall3(SYS_getresuid, @ptrToInt(ruid), @ptrToInt(euid), @ptrToInt(suid));
379	}
380
381	pub fn getresgid(rgid: u32, egid: u32, sgid: *u32) usize {
382	return syscall3(SYS_getresgid, @ptrToInt(rgid), @ptrToInt(egid), @ptrToInt(sgid));
383	}
384
385	pub fn setresuid(ruid: u32, euid: u32, suid: u32) usize {
386	return syscall3(SYS_setresuid, ruid, euid, suid);
387	}
388
389	pub fn setresgid(rgid: u32, egid: u32, sgid: u32) usize {
390	return syscall3(SYS_setresgid, rgid, egid, sgid);
391	}
392
393	pub fn getgroups(size: usize, list: *u32) usize {
394	return syscall2(SYS_getgroups, size, @ptrToInt(list));
395	}
396
397	pub fn setgroups(size: usize, list: *const u32) usize {
398	return syscall2(SYS_setgroups, size, @ptrToInt(list));
399	}
400
401	pub fn getpid() i32 {
402	return @bitCast(i32, @truncate(u32, syscall0(SYS_getpid)));
403	}
404
405	pub fn gettid() i32 {
406	return @bitCast(i32, @truncate(u32, syscall0(SYS_gettid)));
407	}
408
409	pub fn sigprocmask(flags: u32, noalias set: const sigset_t, noalias oldset: ?sigset_t) usize {
410	return syscall4(SYS_rt_sigprocmask, flags, @ptrToInt(set), @ptrToInt(oldset), NSIG / 8);
411	}
412
413	pub fn sigaction(sig: u6, noalias act: const Sigaction, noalias oact: ?Sigaction) usize {
414	assert(sig >= 1);
415	assert(sig != SIGKILL);
416	assert(sig != SIGSTOP);
417	var ksa = k_sigaction{
418	.handler = act.handler,
419	.flags = act.flags \| SA_RESTORER,
420	.mask = undefined,
421	.restorer = @ptrCast(extern fn () void, restore_rt),
422	};
423	var ksa_old: k_sigaction = undefined;
424	@memcpy(@ptrCast([]u8, &ksa.mask), @ptrCast([]const u8, &act.mask), 8);
425	const result = syscall4(SYS_rt_sigaction, sig, @ptrToInt(&ksa), @ptrToInt(&ksa_old), @sizeOf(@typeOf(ksa.mask)));
426	const err = getErrno(result);
427	if (err != 0) {
428	return result;
429	}
430	if (oact) \|old\| {
431	old.handler = ksa_old.handler;
432	old.flags = @truncate(u32, ksa_old.flags);
433	@memcpy(@ptrCast([]u8, &old.mask), @ptrCast([]const u8, &ksa_old.mask), @sizeOf(@typeOf(ksa_old.mask)));
434	}
435	return 0;
436	}
437
438	fn blockAllSignals(set: *sigset_t) void {
439	_ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&all_mask), @ptrToInt(set), NSIG / 8);
440	}
441
442	fn blockAppSignals(set: *sigset_t) void {
443	_ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&app_mask), @ptrToInt(set), NSIG / 8);
444	}
445
446	fn restoreSignals(set: *sigset_t) void {
447	_ = syscall4(SYS_rt_sigprocmask, SIG_SETMASK, @ptrToInt(set), 0, NSIG / 8);
448	}
449
450	pub fn sigaddset(set: *sigset_t, sig: u6) void {
451	const s = sig - 1;
452	(set.*)[@intCast(usize, s) / usize.bit_count] \|= @intCast(usize, 1) << (s & (usize.bit_count - 1));
453	}
454
455	pub fn sigismember(set: *const sigset_t, sig: u6) bool {
456	const s = sig - 1;
457	return ((set.*)[@intCast(usize, s) / usize.bit_count] & (@intCast(usize, 1) << (s & (usize.bit_count - 1)))) != 0;
458	}
459
460	pub fn getsockname(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
461	return syscall3(SYS_getsockname, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len));
462	}
463
464	pub fn getpeername(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
465	return syscall3(SYS_getpeername, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len));
466	}
467
468	pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize {
469	return syscall3(SYS_socket, domain, socket_type, protocol);
470	}
471
472	pub fn setsockopt(fd: i32, level: u32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize {
473	return syscall5(SYS_setsockopt, @bitCast(usize, isize(fd)), level, optname, @ptrToInt(optval), @intCast(usize, optlen));
474	}
475
476	pub fn getsockopt(fd: i32, level: u32, optname: u32, noalias optval: []u8, noalias optlen: socklen_t) usize {
477	return syscall5(SYS_getsockopt, @bitCast(usize, isize(fd)), level, optname, @ptrToInt(optval), @ptrToInt(optlen));
478	}
479
480	pub fn sendmsg(fd: i32, msg: *msghdr_const, flags: u32) usize {
481	return syscall3(SYS_sendmsg, @bitCast(usize, isize(fd)), @ptrToInt(msg), flags);
482	}
483
484	pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize {
485	if (@typeInfo(usize).Int.bits > @typeInfo(@typeOf(mmsghdr(undefined).msg_len)).Int.bits) {
486	// workaround kernel brokenness:
487	// if adding up all iov_len overflows a i32 then split into multiple calls
488	// see https://www.openwall.com/lists/musl/2014/06/07/5
489	const kvlen = if (vlen > IOV_MAX) IOV_MAX else vlen; // matches kernel
490	var next_unsent: usize = 0;
491	for (msgvec[0..kvlen]) \|*msg, i\| {
492	var size: i32 = 0;
493	const msg_iovlen = @intCast(usize, msg.msg_hdr.msg_iovlen); // kernel side this is treated as unsigned
494	for (msg.msg_hdr.msg_iov[0..msg_iovlen]) \|iov, j\| {
495	if (iov.iov_len > std.math.maxInt(i32) or @addWithOverflow(i32, size, @intCast(i32, iov.iov_len), &size)) {
496	// batch-send all messages up to the current message
497	if (next_unsent < i) {
498	const batch_size = i - next_unsent;
499	const r = syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
500	if (getErrno(r) != 0) return next_unsent;
501	if (r < batch_size) return next_unsent + r;
502	}
503	// send current message as own packet
504	const r = sendmsg(fd, &msg.msg_hdr, flags);
505	if (getErrno(r) != 0) return r;
506	// Linux limits the total bytes sent by sendmsg to INT_MAX, so this cast is safe.
507	msg.msg_len = @intCast(u32, r);
508	next_unsent = i + 1;
509	break;
510	}
511	}
512	}
513	if (next_unsent < kvlen or next_unsent == 0) { // want to make sure at least one syscall occurs (e.g. to trigger MSG_EOR)
514	const batch_size = kvlen - next_unsent;
515	const r = syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
516	if (getErrno(r) != 0) return r;
517	return next_unsent + r;
518	}
519	return kvlen;
520	}
521	return syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(msgvec), vlen, flags);
522	}
523
524	pub fn connect(fd: i32, addr: *const c_void, len: socklen_t) usize {
525	return syscall3(SYS_connect, @bitCast(usize, isize(fd)), @ptrToInt(addr), len);
526	}
527
528	pub fn recvmsg(fd: i32, msg: *msghdr, flags: u32) usize {
529	return syscall3(SYS_recvmsg, @bitCast(usize, isize(fd)), @ptrToInt(msg), flags);
530	}
531
532	pub fn recvfrom(fd: i32, noalias buf: []u8, len: usize, flags: u32, noalias addr: ?sockaddr, noalias alen: ?*socklen_t) usize {
533	return syscall6(SYS_recvfrom, @bitCast(usize, isize(fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen));
534	}
535
536	pub fn shutdown(fd: i32, how: i32) usize {
537	return syscall2(SYS_shutdown, @bitCast(usize, isize(fd)), @bitCast(usize, isize(how)));
538	}
539
540	pub fn bind(fd: i32, addr: *const sockaddr, len: socklen_t) usize {
541	return syscall3(SYS_bind, @bitCast(usize, isize(fd)), @ptrToInt(addr), @intCast(usize, len));
542	}
543
544	pub fn listen(fd: i32, backlog: u32) usize {
545	return syscall2(SYS_listen, @bitCast(usize, isize(fd)), backlog);
546	}
547
548	pub fn sendto(fd: i32, buf: []const u8, len: usize, flags: u32, addr: ?const sockaddr, alen: socklen_t) usize {
549	return syscall6(SYS_sendto, @bitCast(usize, isize(fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @intCast(usize, alen));
550	}
551
552	pub fn socketpair(domain: i32, socket_type: i32, protocol: i32, fd: [2]i32) usize {
553	return syscall4(SYS_socketpair, @intCast(usize, domain), @intCast(usize, socket_type), @intCast(usize, protocol), @ptrToInt(&fd[0]));
554	}
555
556	pub fn accept(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
557	return accept4(fd, addr, len, 0);
558	}
559
560	pub fn accept4(fd: i32, noalias addr: sockaddr, noalias len: socklen_t, flags: u32) usize {
561	return syscall4(SYS_accept4, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len), flags);
562	}
563
564	pub fn fstat(fd: i32, stat_buf: *Stat) usize {
565	return syscall2(SYS_fstat, @bitCast(usize, isize(fd)), @ptrToInt(stat_buf));
566	}
567
568	// TODO https://github.com/ziglang/zig/issues/265
569	pub fn stat(pathname: []const u8, statbuf: Stat) usize {
570	return syscall2(SYS_stat, @ptrToInt(pathname), @ptrToInt(statbuf));
571	}
572
573	// TODO https://github.com/ziglang/zig/issues/265
574	pub fn lstat(pathname: []const u8, statbuf: Stat) usize {
575	return syscall2(SYS_lstat, @ptrToInt(pathname), @ptrToInt(statbuf));
576	}
577
578	// TODO https://github.com/ziglang/zig/issues/265
579	pub fn fstatat(dirfd: i32, path: []const u8, stat_buf: Stat, flags: u32) usize {
580	return syscall4(SYS_fstatat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(stat_buf), flags);
581	}
582
583	// TODO https://github.com/ziglang/zig/issues/265
584	pub fn listxattr(path: []const u8, list: []u8, size: usize) usize {
585	return syscall3(SYS_listxattr, @ptrToInt(path), @ptrToInt(list), size);
586	}
587
588	// TODO https://github.com/ziglang/zig/issues/265
589	pub fn llistxattr(path: []const u8, list: []u8, size: usize) usize {
590	return syscall3(SYS_llistxattr, @ptrToInt(path), @ptrToInt(list), size);
591	}
592
593	pub fn flistxattr(fd: usize, list: [*]u8, size: usize) usize {
594	return syscall3(SYS_flistxattr, fd, @ptrToInt(list), size);
595	}
596
597	// TODO https://github.com/ziglang/zig/issues/265
598	pub fn getxattr(path: []const u8, name: []const u8, value: [*]u8, size: usize) usize {
599	return syscall4(SYS_getxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size);
600	}
601
602	// TODO https://github.com/ziglang/zig/issues/265
603	pub fn lgetxattr(path: []const u8, name: []const u8, value: [*]u8, size: usize) usize {
604	return syscall4(SYS_lgetxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size);
605	}
606
607	// TODO https://github.com/ziglang/zig/issues/265
608	pub fn fgetxattr(fd: usize, name: []const u8, value: []u8, size: usize) usize {
609	return syscall4(SYS_lgetxattr, fd, @ptrToInt(name), @ptrToInt(value), size);
610	}
611
612	// TODO https://github.com/ziglang/zig/issues/265
613	pub fn setxattr(path: []const u8, name: []const u8, value: *const void, size: usize, flags: usize) usize {
614	return syscall5(SYS_setxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size, flags);
615	}
616
617	// TODO https://github.com/ziglang/zig/issues/265
618	pub fn lsetxattr(path: []const u8, name: []const u8, value: *const void, size: usize, flags: usize) usize {
619	return syscall5(SYS_lsetxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size, flags);
620	}
621
622	// TODO https://github.com/ziglang/zig/issues/265
623	pub fn fsetxattr(fd: usize, name: []const u8, value: const void, size: usize, flags: usize) usize {
624	return syscall5(SYS_fsetxattr, fd, @ptrToInt(name), @ptrToInt(value), size, flags);
625	}
626
627	// TODO https://github.com/ziglang/zig/issues/265
628	pub fn removexattr(path: []const u8, name: []const u8) usize {
629	return syscall2(SYS_removexattr, @ptrToInt(path), @ptrToInt(name));
630	}
631
632	// TODO https://github.com/ziglang/zig/issues/265
633	pub fn lremovexattr(path: []const u8, name: []const u8) usize {
634	return syscall2(SYS_lremovexattr, @ptrToInt(path), @ptrToInt(name));
635	}
636
637	// TODO https://github.com/ziglang/zig/issues/265
638	pub fn fremovexattr(fd: usize, name: [*]const u8) usize {
639	return syscall2(SYS_fremovexattr, fd, @ptrToInt(name));
640	}
641
642	pub fn sched_getaffinity(pid: i32, set: []usize) usize {
643	return syscall3(SYS_sched_getaffinity, @bitCast(usize, isize(pid)), set.len * @sizeOf(usize), @ptrToInt(set.ptr));
644	}
645
646	pub fn epoll_create() usize {
647	return epoll_create1(0);
648	}
649
650	pub fn epoll_create1(flags: usize) usize {
651	return syscall1(SYS_epoll_create1, flags);
652	}
653
654	pub fn epoll_ctl(epoll_fd: i32, op: u32, fd: i32, ev: *epoll_event) usize {
655	return syscall4(SYS_epoll_ctl, @bitCast(usize, isize(epoll_fd)), @intCast(usize, op), @bitCast(usize, isize(fd)), @ptrToInt(ev));
656	}
657
658	pub fn epoll_wait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout: i32) usize {
659	return syscall4(
660	SYS_epoll_wait,
661	@bitCast(usize, isize(epoll_fd)),
662	@ptrToInt(events),
663	maxevents,
664	@bitCast(usize, isize(timeout)),
665	);
666	}
667
668	pub fn epoll_pwait(epoll_fd: i32, events: []epoll_event, maxevents: u32, timeout: i32, sigmask: ?sigset_t) usize {
669	return syscall6(
670	SYS_epoll_pwait,
671	@bitCast(usize, isize(epoll_fd)),
672	@ptrToInt(events),
673	@intCast(usize, maxevents),
674	@bitCast(usize, isize(timeout)),
675	@ptrToInt(sigmask),
676	@sizeOf(sigset_t),
677	);
678	}
679
680	pub fn eventfd(count: u32, flags: u32) usize {
681	return syscall2(SYS_eventfd2, count, flags);
682	}
683
684	pub fn timerfd_create(clockid: i32, flags: u32) usize {
685	return syscall2(SYS_timerfd_create, @bitCast(usize, isize(clockid)), flags);
686	}
687
688	pub const itimerspec = extern struct {
689	it_interval: timespec,
690	it_value: timespec,
691	};
692
693	pub fn timerfd_gettime(fd: i32, curr_value: *itimerspec) usize {
694	return syscall2(SYS_timerfd_gettime, @bitCast(usize, isize(fd)), @ptrToInt(curr_value));
695	}
696
697	pub fn timerfd_settime(fd: i32, flags: u32, new_value: const itimerspec, old_value: ?itimerspec) usize {
698	return syscall4(SYS_timerfd_settime, @bitCast(usize, isize(fd)), flags, @ptrToInt(new_value), @ptrToInt(old_value));
699	}
700
701	pub fn unshare(flags: usize) usize {
702	return syscall1(SYS_unshare, flags);
703	}
704
705	pub fn capget(hdrp: cap_user_header_t, datap: cap_user_data_t) usize {
706	return syscall2(SYS_capget, @ptrToInt(hdrp), @ptrToInt(datap));
707	}
708
709	pub fn capset(hdrp: cap_user_header_t, datap: const cap_user_data_t) usize {
710	return syscall2(SYS_capset, @ptrToInt(hdrp), @ptrToInt(datap));
711	}
712
713	// XXX: This should be weak
714	extern const __ehdr_start: elf.Ehdr = undefined;
715
716	pub fn dl_iterate_phdr(comptime T: type, callback: extern fn (info: dl_phdr_info, size: usize, data: ?T) i32, data: ?*T) isize {
717	if (builtin.link_libc) {
718	return std.c.dl_iterate_phdr(@ptrCast(std.c.dl_iterate_phdr_callback, callback), @ptrCast(?*c_void, data));
719	}
720
721	const elf_base = @ptrToInt(&__ehdr_start);
722	const n_phdr = __ehdr_start.e_phnum;
723	const phdrs = (@intToPtr([*]elf.Phdr, elf_base + __ehdr_start.e_phoff))[0..n_phdr];
724
725	var it = dl.linkmap_iterator(phdrs) catch return 0;
726
727	// The executable has no dynamic link segment, create a single entry for
728	// the whole ELF image
729	if (it.end()) {
730	var info = dl_phdr_info{
731	.dlpi_addr = elf_base,
732	.dlpi_name = c"/proc/self/exe",
733	.dlpi_phdr = @intToPtr([*]elf.Phdr, elf_base + __ehdr_start.e_phoff),
734	.dlpi_phnum = __ehdr_start.e_phnum,
735	};
736
737	return callback(&info, @sizeOf(dl_phdr_info), data);
738	}
739
740	// Last return value from the callback function
741	var last_r: isize = 0;
742	while (it.next()) \|entry\| {
743	var dlpi_phdr: usize = undefined;
744	var dlpi_phnum: u16 = undefined;
745
746	if (entry.l_addr != 0) {
747	const elf_header = @intToPtr(*elf.Ehdr, entry.l_addr);
748	dlpi_phdr = entry.l_addr + elf_header.e_phoff;
749	dlpi_phnum = elf_header.e_phnum;
750	} else {
751	// This is the running ELF image
752	dlpi_phdr = elf_base + __ehdr_start.e_phoff;
753	dlpi_phnum = __ehdr_start.e_phnum;
754	}
755
756	var info = dl_phdr_info{
757	.dlpi_addr = entry.l_addr,
758	.dlpi_name = entry.l_name,
759	.dlpi_phdr = @intToPtr([*]elf.Phdr, dlpi_phdr),
760	.dlpi_phnum = dlpi_phnum,
761	};
762
763	last_r = callback(&info, @sizeOf(dl_phdr_info), data);
764	if (last_r != 0) break;
765	}
766
767	return last_r;
768	}
769		6
770	test "import" {	7	test "import" {
771	if (is_the_target) {	8	if (is_the_target) {

std/os/linux/sys.zig created+847

...	@@ -0,0 +1,847 @@
1	// This file provides the system interface functions for Linux matching those
2	// that are provided by libc, whether or not libc is linked. The following
3	// abstractions are made:
4	// * Work around kernel bugs and limitations. For example, see sendmmsg.
5	// * Implement all the syscalls in the same way that libc functions will
6	// provide `rename` when only the `renameat` syscall exists.
7	// * Does not support POSIX thread cancellation.
8	const std = @import("../../std.zig");
9	const builtin = @import("builtin");
10	const assert = std.debug.assert;
11	const maxInt = std.math.maxInt;
12	const elf = std.elf;
13	const vdso = @import("vdso.zig");
14	const dl = @import("../../dynamic_library.zig");
15	pub use switch (builtin.arch) {
16	.x86_64 => @import("x86_64.zig"),
17	.aarch64 => @import("arm64.zig"),
18	else => struct {},
19	};
20	pub const posix = @import("posix.zig");
21	pub use posix;
22
23	/// See `std.os.posix.getauxval`.
24	pub var elf_aux_maybe: ?[*]std.elf.Auxv = null;
25
26	/// Get the errno from a syscall return value, or 0 for no error.
27	pub fn getErrno(r: usize) u12 {
28	const signed_r = @bitCast(isize, r);
29	return if (signed_r > -4096 and signed_r < 0) @intCast(u12, -signed_r) else 0;
30	}
31
32	pub fn dup2(old: i32, new: i32) usize {
33	if (@hasDecl(@This(), "SYS_dup2")) {
34	return syscall2(SYS_dup2, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)));
35	} else {
36	if (old == new) {
37	if (std.debug.runtime_safety) {
38	const rc = syscall2(SYS_fcntl, @bitCast(usize, isize(old)), F_GETFD);
39	if (@bitCast(isize, rc) < 0) return rc;
40	}
41	return @intCast(usize, old);
42	} else {
43	return syscall3(SYS_dup3, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)), 0);
44	}
45	}
46	}
47
48	pub fn dup3(old: i32, new: i32, flags: u32) usize {
49	return syscall3(SYS_dup3, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)), flags);
50	}
51
52	// TODO https://github.com/ziglang/zig/issues/265
53	pub fn chdir(path: [*]const u8) usize {
54	return syscall1(SYS_chdir, @ptrToInt(path));
55	}
56
57	// TODO https://github.com/ziglang/zig/issues/265
58	pub fn chroot(path: [*]const u8) usize {
59	return syscall1(SYS_chroot, @ptrToInt(path));
60	}
61
62	// TODO https://github.com/ziglang/zig/issues/265
63	pub fn execve(path: []const u8, argv: []const ?[]const u8, envp: []const ?[*]const u8) usize {
64	return syscall3(SYS_execve, @ptrToInt(path), @ptrToInt(argv), @ptrToInt(envp));
65	}
66
67	pub fn fork() usize {
68	if (@hasDecl(@This(), "SYS_fork")) {
69	return syscall0(SYS_fork);
70	} else {
71	return syscall2(SYS_clone, SIGCHLD, 0);
72	}
73	}
74
75	/// This must be inline, and inline call the syscall function, because if the
76	/// child does a return it will clobber the parent's stack.
77	/// It is advised to avoid this function and use clone instead, because
78	/// the compiler is not aware of how vfork affects control flow and you may
79	/// see different results in optimized builds.
80	pub inline fn vfork() usize {
81	return @inlineCall(syscall0, SYS_vfork);
82	}
83
84	pub fn futex_wait(uaddr: const i32, futex_op: u32, val: i32, timeout: ?timespec) usize {
85	return syscall4(SYS_futex, @ptrToInt(uaddr), futex_op, @bitCast(u32, val), @ptrToInt(timeout));
86	}
87
88	pub fn futex_wake(uaddr: *const i32, futex_op: u32, val: i32) usize {
89	return syscall3(SYS_futex, @ptrToInt(uaddr), futex_op, @bitCast(u32, val));
90	}
91
92	pub fn getcwd(buf: [*]u8, size: usize) usize {
93	return syscall2(SYS_getcwd, @ptrToInt(buf), size);
94	}
95
96	pub fn getdents(fd: i32, dirp: [*]u8, count: usize) usize {
97	return syscall3(SYS_getdents, @bitCast(usize, isize(fd)), @ptrToInt(dirp), count);
98	}
99
100	pub fn getdents64(fd: i32, dirp: [*]u8, count: usize) usize {
101	return syscall3(SYS_getdents64, @bitCast(usize, isize(fd)), @ptrToInt(dirp), count);
102	}
103
104	pub fn inotify_init1(flags: u32) usize {
105	return syscall1(SYS_inotify_init1, flags);
106	}
107
108	pub fn inotify_add_watch(fd: i32, pathname: [*]const u8, mask: u32) usize {
109	return syscall3(SYS_inotify_add_watch, @bitCast(usize, isize(fd)), @ptrToInt(pathname), mask);
110	}
111
112	pub fn inotify_rm_watch(fd: i32, wd: i32) usize {
113	return syscall2(SYS_inotify_rm_watch, @bitCast(usize, isize(fd)), @bitCast(usize, isize(wd)));
114	}
115
116	// TODO https://github.com/ziglang/zig/issues/265
117	pub fn readlink(noalias path: []const u8, noalias buf_ptr: []u8, buf_len: usize) usize {
118	if (@hasDecl(@This(), "SYS_readlink")) {
119	return syscall3(SYS_readlink, @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
120	} else {
121	return syscall4(SYS_readlinkat, AT_FDCWD, @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
122	}
123	}
124
125	// TODO https://github.com/ziglang/zig/issues/265
126	pub fn readlinkat(dirfd: i32, noalias path: []const u8, noalias buf_ptr: []u8, buf_len: usize) usize {
127	return syscall4(SYS_readlinkat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
128	}
129
130	// TODO https://github.com/ziglang/zig/issues/265
131	pub fn mkdir(path: [*]const u8, mode: u32) usize {
132	if (@hasDecl(@This(), "SYS_mkdir")) {
133	return syscall2(SYS_mkdir, @ptrToInt(path), mode);
134	} else {
135	return syscall3(SYS_mkdirat, AT_FDCWD, @ptrToInt(path), mode);
136	}
137	}
138
139	// TODO https://github.com/ziglang/zig/issues/265
140	pub fn mkdirat(dirfd: i32, path: [*]const u8, mode: u32) usize {
141	return syscall3(SYS_mkdirat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), mode);
142	}
143
144	// TODO https://github.com/ziglang/zig/issues/265
145	pub fn mount(special: []const u8, dir: []const u8, fstype: [*]const u8, flags: u32, data: usize) usize {
146	return syscall5(SYS_mount, @ptrToInt(special), @ptrToInt(dir), @ptrToInt(fstype), flags, data);
147	}
148
149	// TODO https://github.com/ziglang/zig/issues/265
150	pub fn umount(special: [*]const u8) usize {
151	return syscall2(SYS_umount2, @ptrToInt(special), 0);
152	}
153
154	// TODO https://github.com/ziglang/zig/issues/265
155	pub fn umount2(special: [*]const u8, flags: u32) usize {
156	return syscall2(SYS_umount2, @ptrToInt(special), flags);
157	}
158
159	pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: u32, fd: i32, offset: isize) usize {
160	return syscall6(SYS_mmap, @ptrToInt(address), length, prot, flags, @bitCast(usize, isize(fd)), @bitCast(usize, offset));
161	}
162
163	pub fn mprotect(address: usize, length: usize, protection: usize) usize {
164	return syscall3(SYS_mprotect, address, length, protection);
165	}
166
167	pub fn munmap(address: usize, length: usize) usize {
168	return syscall2(SYS_munmap, address, length);
169	}
170
171	pub fn read(fd: i32, buf: [*]u8, count: usize) usize {
172	return syscall3(SYS_read, @bitCast(usize, isize(fd)), @ptrToInt(buf), count);
173	}
174
175	pub fn preadv(fd: i32, iov: [*]const iovec, count: usize, offset: u64) usize {
176	return syscall4(SYS_preadv, @bitCast(usize, isize(fd)), @ptrToInt(iov), count, offset);
177	}
178
179	pub fn readv(fd: i32, iov: [*]const iovec, count: usize) usize {
180	return syscall3(SYS_readv, @bitCast(usize, isize(fd)), @ptrToInt(iov), count);
181	}
182
183	pub fn writev(fd: i32, iov: [*]const iovec_const, count: usize) usize {
184	return syscall3(SYS_writev, @bitCast(usize, isize(fd)), @ptrToInt(iov), count);
185	}
186
187	pub fn pwritev(fd: i32, iov: [*]const iovec_const, count: usize, offset: u64) usize {
188	return syscall4(SYS_pwritev, @bitCast(usize, isize(fd)), @ptrToInt(iov), count, offset);
189	}
190
191	// TODO https://github.com/ziglang/zig/issues/265
192	pub fn rmdir(path: [*]const u8) usize {
193	if (@hasDecl(@This(), "SYS_rmdir")) {
194	return syscall1(SYS_rmdir, @ptrToInt(path));
195	} else {
196	return syscall3(SYS_unlinkat, AT_FDCWD, @ptrToInt(path), AT_REMOVEDIR);
197	}
198	}
199
200	// TODO https://github.com/ziglang/zig/issues/265
201	pub fn symlink(existing: []const u8, new: []const u8) usize {
202	if (@hasDecl(@This(), "SYS_symlink")) {
203	return syscall2(SYS_symlink, @ptrToInt(existing), @ptrToInt(new));
204	} else {
205	return syscall3(SYS_symlinkat, @ptrToInt(existing), AT_FDCWD, @ptrToInt(new));
206	}
207	}
208
209	// TODO https://github.com/ziglang/zig/issues/265
210	pub fn symlinkat(existing: []const u8, newfd: i32, newpath: []const u8) usize {
211	return syscall3(SYS_symlinkat, @ptrToInt(existing), @bitCast(usize, isize(newfd)), @ptrToInt(newpath));
212	}
213
214	// TODO https://github.com/ziglang/zig/issues/265
215	pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: usize) usize {
216	return syscall4(SYS_pread, @bitCast(usize, isize(fd)), @ptrToInt(buf), count, offset);
217	}
218
219	// TODO https://github.com/ziglang/zig/issues/265
220	pub fn access(path: [*]const u8, mode: u32) usize {
221	return syscall2(SYS_access, @ptrToInt(path), mode);
222	}
223
224	// TODO https://github.com/ziglang/zig/issues/265
225	pub fn faccessat(dirfd: i32, path: [*]const u8, mode: u32) usize {
226	return syscall3(SYS_faccessat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), mode);
227	}
228
229	pub fn pipe(fd: *[2]i32) usize {
230	if (@hasDecl(@This(), "SYS_pipe")) {
231	return syscall1(SYS_pipe, @ptrToInt(fd));
232	} else {
233	return syscall2(SYS_pipe2, @ptrToInt(fd), 0);
234	}
235	}
236
237	pub fn pipe2(fd: *[2]i32, flags: u32) usize {
238	return syscall2(SYS_pipe2, @ptrToInt(fd), flags);
239	}
240
241	pub fn write(fd: i32, buf: [*]const u8, count: usize) usize {
242	return syscall3(SYS_write, @bitCast(usize, isize(fd)), @ptrToInt(buf), count);
243	}
244
245	pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: usize) usize {
246	return syscall4(SYS_pwrite, @bitCast(usize, isize(fd)), @ptrToInt(buf), count, offset);
247	}
248
249	// TODO https://github.com/ziglang/zig/issues/265
250	pub fn rename(old: []const u8, new: []const u8) usize {
251	if (@hasDecl(@This(), "SYS_rename")) {
252	return syscall2(SYS_rename, @ptrToInt(old), @ptrToInt(new));
253	} else if (@hasDecl(@This(), "SYS_renameat")) {
254	return syscall4(SYS_renameat, AT_FDCWD, @ptrToInt(old), AT_FDCWD, @ptrToInt(new));
255	} else {
256	return syscall5(SYS_renameat2, AT_FDCWD, @ptrToInt(old), AT_FDCWD, @ptrToInt(new), 0);
257	}
258	}
259
260	pub fn renameat(oldfd: i32, oldpath: []const u8, newfd: i32, newpath: []const u8) usize {
261	if (@hasDecl(@This(), "SYS_renameat")) {
262	return syscall4(
263	SYS_renameat,
264	@bitCast(usize, isize(oldfd)),
265	@ptrToInt(old),
266	@bitCast(usize, isize(newfd)),
267	@ptrToInt(new),
268	);
269	} else {
270	return syscall5(
271	SYS_renameat2,
272	@bitCast(usize, isize(oldfd)),
273	@ptrToInt(old),
274	@bitCast(usize, isize(newfd)),
275	@ptrToInt(new),
276	0,
277	);
278	}
279	}
280
281	// TODO https://github.com/ziglang/zig/issues/265
282	pub fn renameat2(oldfd: i32, oldpath: []const u8, newfd: i32, newpath: []const u8, flags: u32) usize {
283	return syscall5(
284	SYS_renameat2,
285	@bitCast(usize, isize(oldfd)),
286	@ptrToInt(oldpath),
287	@bitCast(usize, isize(newfd)),
288	@ptrToInt(newpath),
289	flags,
290	);
291	}
292
293	// TODO https://github.com/ziglang/zig/issues/265
294	pub fn open(path: [*]const u8, flags: u32, perm: usize) usize {
295	return syscall3(SYS_open, @ptrToInt(path), flags, perm);
296	}
297
298	// TODO https://github.com/ziglang/zig/issues/265
299	pub fn create(path: [*]const u8, perm: usize) usize {
300	return syscall2(SYS_creat, @ptrToInt(path), perm);
301	}
302
303	// TODO https://github.com/ziglang/zig/issues/265
304	pub fn openat(dirfd: i32, path: [*]const u8, flags: u32, mode: usize) usize {
305	// dirfd could be negative, for example AT_FDCWD is -100
306	return syscall4(SYS_openat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), flags, mode);
307	}
308
309	/// See also `clone` (from the arch-specific include)
310	pub fn clone5(flags: usize, child_stack_ptr: usize, parent_tid: i32, child_tid: i32, newtls: usize) usize {
311	return syscall5(SYS_clone, flags, child_stack_ptr, @ptrToInt(parent_tid), @ptrToInt(child_tid), newtls);
312	}
313
314	/// See also `clone` (from the arch-specific include)
315	pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
316	return syscall2(SYS_clone, flags, child_stack_ptr);
317	}
318
319	pub fn close(fd: i32) usize {
320	return syscall1(SYS_close, @bitCast(usize, isize(fd)));
321	}
322
323	pub fn lseek(fd: i32, offset: isize, ref_pos: usize) usize {
324	return syscall3(SYS_lseek, @bitCast(usize, isize(fd)), @bitCast(usize, offset), ref_pos);
325	}
326
327	pub fn exit(status: i32) noreturn {
328	_ = syscall1(SYS_exit, @bitCast(usize, isize(status)));
329	unreachable;
330	}
331
332	pub fn exit_group(status: i32) noreturn {
333	_ = syscall1(SYS_exit_group, @bitCast(usize, isize(status)));
334	unreachable;
335	}
336
337	pub fn getrandom(buf: [*]u8, count: usize, flags: u32) usize {
338	return syscall3(SYS_getrandom, @ptrToInt(buf), count, flags);
339	}
340
341	pub fn kill(pid: i32, sig: i32) usize {
342	return syscall2(SYS_kill, @bitCast(usize, isize(pid)), @bitCast(usize, isize(sig)));
343	}
344
345	// TODO https://github.com/ziglang/zig/issues/265
346	pub fn unlink(path: [*]const u8) usize {
347	if (@hasDecl(@This(), "SYS_unlink")) {
348	return syscall1(SYS_unlink, @ptrToInt(path));
349	} else {
350	return syscall3(SYS_unlinkat, AT_FDCWD, @ptrToInt(path), 0);
351	}
352	}
353
354	// TODO https://github.com/ziglang/zig/issues/265
355	pub fn unlinkat(dirfd: i32, path: [*]const u8, flags: u32) usize {
356	return syscall3(SYS_unlinkat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), flags);
357	}
358
359	pub fn waitpid(pid: i32, status: *i32, options: i32) usize {
360	return syscall4(SYS_wait4, @bitCast(usize, isize(pid)), @ptrToInt(status), @bitCast(usize, isize(options)), 0);
361	}
362
363	var vdso_clock_gettime = @ptrCast(?*const c_void, init_vdso_clock_gettime);
364
365	// We must follow the C calling convention when we call into the VDSO
366	const vdso_clock_gettime_ty = extern fn (i32, *timespec) usize;
367
368	pub fn clock_gettime(clk_id: i32, tp: *timespec) usize {
369	if (VDSO_CGT_SYM.len != 0) {
370	const ptr = @atomicLoad(?*const c_void, &vdso_clock_gettime, .Unordered);
371	if (ptr) \|fn_ptr\| {
372	const f = @ptrCast(vdso_clock_gettime_ty, fn_ptr);
373	const rc = f(clk_id, tp);
374	switch (rc) {
375	0, @bitCast(usize, isize(-EINVAL)) => return rc,
376	else => {},
377	}
378	}
379	}
380	return syscall2(SYS_clock_gettime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
381	}
382
383	extern fn init_vdso_clock_gettime(clk: i32, ts: *timespec) usize {
384	const ptr = @intToPtr(?*const c_void, vdso.lookup(VDSO_CGT_VER, VDSO_CGT_SYM));
385	// Note that we may not have a VDSO at all, update the stub address anyway
386	// so that clock_gettime will fall back on the good old (and slow) syscall
387	_ = @cmpxchgStrong(?*const c_void, &vdso_clock_gettime, &init_vdso_clock_gettime, ptr, .Monotonic, .Monotonic);
388	// Call into the VDSO if available
389	if (ptr) \|fn_ptr\| {
390	const f = @ptrCast(vdso_clock_gettime_ty, fn_ptr);
391	return f(clk, ts);
392	}
393	return @bitCast(usize, isize(-ENOSYS));
394	}
395
396	pub fn clock_getres(clk_id: i32, tp: *timespec) usize {
397	return syscall2(SYS_clock_getres, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
398	}
399
400	pub fn clock_settime(clk_id: i32, tp: *const timespec) usize {
401	return syscall2(SYS_clock_settime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
402	}
403
404	pub fn gettimeofday(tv: timeval, tz: timezone) usize {
405	return syscall2(SYS_gettimeofday, @ptrToInt(tv), @ptrToInt(tz));
406	}
407
408	pub fn settimeofday(tv: const timeval, tz: const timezone) usize {
409	return syscall2(SYS_settimeofday, @ptrToInt(tv), @ptrToInt(tz));
410	}
411
412	pub fn nanosleep(req: const timespec, rem: ?timespec) usize {
413	return syscall2(SYS_nanosleep, @ptrToInt(req), @ptrToInt(rem));
414	}
415
416	pub fn setuid(uid: u32) usize {
417	return syscall1(SYS_setuid, uid);
418	}
419
420	pub fn setgid(gid: u32) usize {
421	return syscall1(SYS_setgid, gid);
422	}
423
424	pub fn setreuid(ruid: u32, euid: u32) usize {
425	return syscall2(SYS_setreuid, ruid, euid);
426	}
427
428	pub fn setregid(rgid: u32, egid: u32) usize {
429	return syscall2(SYS_setregid, rgid, egid);
430	}
431
432	pub fn getuid() u32 {
433	return u32(syscall0(SYS_getuid));
434	}
435
436	pub fn getgid() u32 {
437	return u32(syscall0(SYS_getgid));
438	}
439
440	pub fn geteuid() u32 {
441	return u32(syscall0(SYS_geteuid));
442	}
443
444	pub fn getegid() u32 {
445	return u32(syscall0(SYS_getegid));
446	}
447
448	pub fn seteuid(euid: u32) usize {
449	return syscall1(SYS_seteuid, euid);
450	}
451
452	pub fn setegid(egid: u32) usize {
453	return syscall1(SYS_setegid, egid);
454	}
455
456	pub fn getresuid(ruid: u32, euid: u32, suid: *u32) usize {
457	return syscall3(SYS_getresuid, @ptrToInt(ruid), @ptrToInt(euid), @ptrToInt(suid));
458	}
459
460	pub fn getresgid(rgid: u32, egid: u32, sgid: *u32) usize {
461	return syscall3(SYS_getresgid, @ptrToInt(rgid), @ptrToInt(egid), @ptrToInt(sgid));
462	}
463
464	pub fn setresuid(ruid: u32, euid: u32, suid: u32) usize {
465	return syscall3(SYS_setresuid, ruid, euid, suid);
466	}
467
468	pub fn setresgid(rgid: u32, egid: u32, sgid: u32) usize {
469	return syscall3(SYS_setresgid, rgid, egid, sgid);
470	}
471
472	pub fn getgroups(size: usize, list: *u32) usize {
473	return syscall2(SYS_getgroups, size, @ptrToInt(list));
474	}
475
476	pub fn setgroups(size: usize, list: *const u32) usize {
477	return syscall2(SYS_setgroups, size, @ptrToInt(list));
478	}
479
480	pub fn getpid() i32 {
481	return @bitCast(i32, @truncate(u32, syscall0(SYS_getpid)));
482	}
483
484	pub fn gettid() i32 {
485	return @bitCast(i32, @truncate(u32, syscall0(SYS_gettid)));
486	}
487
488	pub fn sigprocmask(flags: u32, noalias set: const sigset_t, noalias oldset: ?sigset_t) usize {
489	return syscall4(SYS_rt_sigprocmask, flags, @ptrToInt(set), @ptrToInt(oldset), NSIG / 8);
490	}
491
492	pub fn sigaction(sig: u6, noalias act: const Sigaction, noalias oact: ?Sigaction) usize {
493	assert(sig >= 1);
494	assert(sig != SIGKILL);
495	assert(sig != SIGSTOP);
496	var ksa = k_sigaction{
497	.handler = act.handler,
498	.flags = act.flags \| SA_RESTORER,
499	.mask = undefined,
500	.restorer = @ptrCast(extern fn () void, restore_rt),
501	};
502	var ksa_old: k_sigaction = undefined;
503	@memcpy(@ptrCast([]u8, &ksa.mask), @ptrCast([]const u8, &act.mask), 8);
504	const result = syscall4(SYS_rt_sigaction, sig, @ptrToInt(&ksa), @ptrToInt(&ksa_old), @sizeOf(@typeOf(ksa.mask)));
505	const err = getErrno(result);
506	if (err != 0) {
507	return result;
508	}
509	if (oact) \|old\| {
510	old.handler = ksa_old.handler;
511	old.flags = @truncate(u32, ksa_old.flags);
512	@memcpy(@ptrCast([]u8, &old.mask), @ptrCast([]const u8, &ksa_old.mask), @sizeOf(@typeOf(ksa_old.mask)));
513	}
514	return 0;
515	}
516
517	fn blockAllSignals(set: *sigset_t) void {
518	_ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&all_mask), @ptrToInt(set), NSIG / 8);
519	}
520
521	fn blockAppSignals(set: *sigset_t) void {
522	_ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&app_mask), @ptrToInt(set), NSIG / 8);
523	}
524
525	fn restoreSignals(set: *sigset_t) void {
526	_ = syscall4(SYS_rt_sigprocmask, SIG_SETMASK, @ptrToInt(set), 0, NSIG / 8);
527	}
528
529	pub fn sigaddset(set: *sigset_t, sig: u6) void {
530	const s = sig - 1;
531	(set.*)[@intCast(usize, s) / usize.bit_count] \|= @intCast(usize, 1) << (s & (usize.bit_count - 1));
532	}
533
534	pub fn sigismember(set: *const sigset_t, sig: u6) bool {
535	const s = sig - 1;
536	return ((set.*)[@intCast(usize, s) / usize.bit_count] & (@intCast(usize, 1) << (s & (usize.bit_count - 1)))) != 0;
537	}
538
539	pub fn getsockname(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
540	return syscall3(SYS_getsockname, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len));
541	}
542
543	pub fn getpeername(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
544	return syscall3(SYS_getpeername, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len));
545	}
546
547	pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize {
548	return syscall3(SYS_socket, domain, socket_type, protocol);
549	}
550
551	pub fn setsockopt(fd: i32, level: u32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize {
552	return syscall5(SYS_setsockopt, @bitCast(usize, isize(fd)), level, optname, @ptrToInt(optval), @intCast(usize, optlen));
553	}
554
555	pub fn getsockopt(fd: i32, level: u32, optname: u32, noalias optval: []u8, noalias optlen: socklen_t) usize {
556	return syscall5(SYS_getsockopt, @bitCast(usize, isize(fd)), level, optname, @ptrToInt(optval), @ptrToInt(optlen));
557	}
558
559	pub fn sendmsg(fd: i32, msg: *msghdr_const, flags: u32) usize {
560	return syscall3(SYS_sendmsg, @bitCast(usize, isize(fd)), @ptrToInt(msg), flags);
561	}
562
563	pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize {
564	if (@typeInfo(usize).Int.bits > @typeInfo(@typeOf(mmsghdr(undefined).msg_len)).Int.bits) {
565	// workaround kernel brokenness:
566	// if adding up all iov_len overflows a i32 then split into multiple calls
567	// see https://www.openwall.com/lists/musl/2014/06/07/5
568	const kvlen = if (vlen > IOV_MAX) IOV_MAX else vlen; // matches kernel
569	var next_unsent: usize = 0;
570	for (msgvec[0..kvlen]) \|*msg, i\| {
571	var size: i32 = 0;
572	const msg_iovlen = @intCast(usize, msg.msg_hdr.msg_iovlen); // kernel side this is treated as unsigned
573	for (msg.msg_hdr.msg_iov[0..msg_iovlen]) \|iov, j\| {
574	if (iov.iov_len > std.math.maxInt(i32) or @addWithOverflow(i32, size, @intCast(i32, iov.iov_len), &size)) {
575	// batch-send all messages up to the current message
576	if (next_unsent < i) {
577	const batch_size = i - next_unsent;
578	const r = syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
579	if (getErrno(r) != 0) return next_unsent;
580	if (r < batch_size) return next_unsent + r;
581	}
582	// send current message as own packet
583	const r = sendmsg(fd, &msg.msg_hdr, flags);
584	if (getErrno(r) != 0) return r;
585	// Linux limits the total bytes sent by sendmsg to INT_MAX, so this cast is safe.
586	msg.msg_len = @intCast(u32, r);
587	next_unsent = i + 1;
588	break;
589	}
590	}
591	}
592	if (next_unsent < kvlen or next_unsent == 0) { // want to make sure at least one syscall occurs (e.g. to trigger MSG_EOR)
593	const batch_size = kvlen - next_unsent;
594	const r = syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
595	if (getErrno(r) != 0) return r;
596	return next_unsent + r;
597	}
598	return kvlen;
599	}
600	return syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(msgvec), vlen, flags);
601	}
602
603	pub fn connect(fd: i32, addr: *const c_void, len: socklen_t) usize {
604	return syscall3(SYS_connect, @bitCast(usize, isize(fd)), @ptrToInt(addr), len);
605	}
606
607	pub fn recvmsg(fd: i32, msg: *msghdr, flags: u32) usize {
608	return syscall3(SYS_recvmsg, @bitCast(usize, isize(fd)), @ptrToInt(msg), flags);
609	}
610
611	pub fn recvfrom(fd: i32, noalias buf: []u8, len: usize, flags: u32, noalias addr: ?sockaddr, noalias alen: ?*socklen_t) usize {
612	return syscall6(SYS_recvfrom, @bitCast(usize, isize(fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen));
613	}
614
615	pub fn shutdown(fd: i32, how: i32) usize {
616	return syscall2(SYS_shutdown, @bitCast(usize, isize(fd)), @bitCast(usize, isize(how)));
617	}
618
619	pub fn bind(fd: i32, addr: *const sockaddr, len: socklen_t) usize {
620	return syscall3(SYS_bind, @bitCast(usize, isize(fd)), @ptrToInt(addr), @intCast(usize, len));
621	}
622
623	pub fn listen(fd: i32, backlog: u32) usize {
624	return syscall2(SYS_listen, @bitCast(usize, isize(fd)), backlog);
625	}
626
627	pub fn sendto(fd: i32, buf: []const u8, len: usize, flags: u32, addr: ?const sockaddr, alen: socklen_t) usize {
628	return syscall6(SYS_sendto, @bitCast(usize, isize(fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @intCast(usize, alen));
629	}
630
631	pub fn socketpair(domain: i32, socket_type: i32, protocol: i32, fd: [2]i32) usize {
632	return syscall4(SYS_socketpair, @intCast(usize, domain), @intCast(usize, socket_type), @intCast(usize, protocol), @ptrToInt(&fd[0]));
633	}
634
635	pub fn accept(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
636	return accept4(fd, addr, len, 0);
637	}
638
639	pub fn accept4(fd: i32, noalias addr: sockaddr, noalias len: socklen_t, flags: u32) usize {
640	return syscall4(SYS_accept4, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len), flags);
641	}
642
643	pub fn fstat(fd: i32, stat_buf: *Stat) usize {
644	return syscall2(SYS_fstat, @bitCast(usize, isize(fd)), @ptrToInt(stat_buf));
645	}
646
647	// TODO https://github.com/ziglang/zig/issues/265
648	pub fn stat(pathname: []const u8, statbuf: Stat) usize {
649	return syscall2(SYS_stat, @ptrToInt(pathname), @ptrToInt(statbuf));
650	}
651
652	// TODO https://github.com/ziglang/zig/issues/265
653	pub fn lstat(pathname: []const u8, statbuf: Stat) usize {
654	return syscall2(SYS_lstat, @ptrToInt(pathname), @ptrToInt(statbuf));
655	}
656
657	// TODO https://github.com/ziglang/zig/issues/265
658	pub fn fstatat(dirfd: i32, path: []const u8, stat_buf: Stat, flags: u32) usize {
659	return syscall4(SYS_fstatat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(stat_buf), flags);
660	}
661
662	// TODO https://github.com/ziglang/zig/issues/265
663	pub fn listxattr(path: []const u8, list: []u8, size: usize) usize {
664	return syscall3(SYS_listxattr, @ptrToInt(path), @ptrToInt(list), size);
665	}
666
667	// TODO https://github.com/ziglang/zig/issues/265
668	pub fn llistxattr(path: []const u8, list: []u8, size: usize) usize {
669	return syscall3(SYS_llistxattr, @ptrToInt(path), @ptrToInt(list), size);
670	}
671
672	pub fn flistxattr(fd: usize, list: [*]u8, size: usize) usize {
673	return syscall3(SYS_flistxattr, fd, @ptrToInt(list), size);
674	}
675
676	// TODO https://github.com/ziglang/zig/issues/265
677	pub fn getxattr(path: []const u8, name: []const u8, value: [*]u8, size: usize) usize {
678	return syscall4(SYS_getxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size);
679	}
680
681	// TODO https://github.com/ziglang/zig/issues/265
682	pub fn lgetxattr(path: []const u8, name: []const u8, value: [*]u8, size: usize) usize {
683	return syscall4(SYS_lgetxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size);
684	}
685
686	// TODO https://github.com/ziglang/zig/issues/265
687	pub fn fgetxattr(fd: usize, name: []const u8, value: []u8, size: usize) usize {
688	return syscall4(SYS_lgetxattr, fd, @ptrToInt(name), @ptrToInt(value), size);
689	}
690
691	// TODO https://github.com/ziglang/zig/issues/265
692	pub fn setxattr(path: []const u8, name: []const u8, value: *const void, size: usize, flags: usize) usize {
693	return syscall5(SYS_setxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size, flags);
694	}
695
696	// TODO https://github.com/ziglang/zig/issues/265
697	pub fn lsetxattr(path: []const u8, name: []const u8, value: *const void, size: usize, flags: usize) usize {
698	return syscall5(SYS_lsetxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size, flags);
699	}
700
701	// TODO https://github.com/ziglang/zig/issues/265
702	pub fn fsetxattr(fd: usize, name: []const u8, value: const void, size: usize, flags: usize) usize {
703	return syscall5(SYS_fsetxattr, fd, @ptrToInt(name), @ptrToInt(value), size, flags);
704	}
705
706	// TODO https://github.com/ziglang/zig/issues/265
707	pub fn removexattr(path: []const u8, name: []const u8) usize {
708	return syscall2(SYS_removexattr, @ptrToInt(path), @ptrToInt(name));
709	}
710
711	// TODO https://github.com/ziglang/zig/issues/265
712	pub fn lremovexattr(path: []const u8, name: []const u8) usize {
713	return syscall2(SYS_lremovexattr, @ptrToInt(path), @ptrToInt(name));
714	}
715
716	// TODO https://github.com/ziglang/zig/issues/265
717	pub fn fremovexattr(fd: usize, name: [*]const u8) usize {
718	return syscall2(SYS_fremovexattr, fd, @ptrToInt(name));
719	}
720
721	pub fn sched_getaffinity(pid: i32, set: []usize) usize {
722	return syscall3(SYS_sched_getaffinity, @bitCast(usize, isize(pid)), set.len * @sizeOf(usize), @ptrToInt(set.ptr));
723	}
724
725	pub fn epoll_create() usize {
726	return epoll_create1(0);
727	}
728
729	pub fn epoll_create1(flags: usize) usize {
730	return syscall1(SYS_epoll_create1, flags);
731	}
732
733	pub fn epoll_ctl(epoll_fd: i32, op: u32, fd: i32, ev: *epoll_event) usize {
734	return syscall4(SYS_epoll_ctl, @bitCast(usize, isize(epoll_fd)), @intCast(usize, op), @bitCast(usize, isize(fd)), @ptrToInt(ev));
735	}
736
737	pub fn epoll_wait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout: i32) usize {
738	return syscall4(
739	SYS_epoll_wait,
740	@bitCast(usize, isize(epoll_fd)),
741	@ptrToInt(events),
742	maxevents,
743	@bitCast(usize, isize(timeout)),
744	);
745	}
746
747	pub fn epoll_pwait(epoll_fd: i32, events: []epoll_event, maxevents: u32, timeout: i32, sigmask: ?sigset_t) usize {
748	return syscall6(
749	SYS_epoll_pwait,
750	@bitCast(usize, isize(epoll_fd)),
751	@ptrToInt(events),
752	@intCast(usize, maxevents),
753	@bitCast(usize, isize(timeout)),
754	@ptrToInt(sigmask),
755	@sizeOf(sigset_t),
756	);
757	}
758
759	pub fn eventfd(count: u32, flags: u32) usize {
760	return syscall2(SYS_eventfd2, count, flags);
761	}
762
763	pub fn timerfd_create(clockid: i32, flags: u32) usize {
764	return syscall2(SYS_timerfd_create, @bitCast(usize, isize(clockid)), flags);
765	}
766
767	pub const itimerspec = extern struct {
768	it_interval: timespec,
769	it_value: timespec,
770	};
771
772	pub fn timerfd_gettime(fd: i32, curr_value: *itimerspec) usize {
773	return syscall2(SYS_timerfd_gettime, @bitCast(usize, isize(fd)), @ptrToInt(curr_value));
774	}
775
776	pub fn timerfd_settime(fd: i32, flags: u32, new_value: const itimerspec, old_value: ?itimerspec) usize {
777	return syscall4(SYS_timerfd_settime, @bitCast(usize, isize(fd)), flags, @ptrToInt(new_value), @ptrToInt(old_value));
778	}
779
780	pub fn unshare(flags: usize) usize {
781	return syscall1(SYS_unshare, flags);
782	}
783
784	pub fn capget(hdrp: cap_user_header_t, datap: cap_user_data_t) usize {
785	return syscall2(SYS_capget, @ptrToInt(hdrp), @ptrToInt(datap));
786	}
787
788	pub fn capset(hdrp: cap_user_header_t, datap: const cap_user_data_t) usize {
789	return syscall2(SYS_capset, @ptrToInt(hdrp), @ptrToInt(datap));
790	}
791
792	// XXX: This should be weak
793	extern const __ehdr_start: elf.Ehdr = undefined;
794
795	pub fn dl_iterate_phdr(comptime T: type, callback: extern fn (info: dl_phdr_info, size: usize, data: ?T) i32, data: ?*T) isize {
796	if (builtin.link_libc) {
797	return std.c.dl_iterate_phdr(@ptrCast(std.c.dl_iterate_phdr_callback, callback), @ptrCast(?*c_void, data));
798	}
799
800	const elf_base = @ptrToInt(&__ehdr_start);
801	const n_phdr = __ehdr_start.e_phnum;
802	const phdrs = (@intToPtr([*]elf.Phdr, elf_base + __ehdr_start.e_phoff))[0..n_phdr];
803
804	var it = dl.linkmap_iterator(phdrs) catch return 0;
805
806	// The executable has no dynamic link segment, create a single entry for
807	// the whole ELF image
808	if (it.end()) {
809	var info = dl_phdr_info{
810	.dlpi_addr = elf_base,
811	.dlpi_name = c"/proc/self/exe",
812	.dlpi_phdr = @intToPtr([*]elf.Phdr, elf_base + __ehdr_start.e_phoff),
813	.dlpi_phnum = __ehdr_start.e_phnum,
814	};
815
816	return callback(&info, @sizeOf(dl_phdr_info), data);
817	}
818
819	// Last return value from the callback function
820	var last_r: isize = 0;
821	while (it.next()) \|entry\| {
822	var dlpi_phdr: usize = undefined;
823	var dlpi_phnum: u16 = undefined;
824
825	if (entry.l_addr != 0) {
826	const elf_header = @intToPtr(*elf.Ehdr, entry.l_addr);
827	dlpi_phdr = entry.l_addr + elf_header.e_phoff;
828	dlpi_phnum = elf_header.e_phnum;
829	} else {
830	// This is the running ELF image
831	dlpi_phdr = elf_base + __ehdr_start.e_phoff;
832	dlpi_phnum = __ehdr_start.e_phnum;
833	}
834
835	var info = dl_phdr_info{
836	.dlpi_addr = entry.l_addr,
837	.dlpi_name = entry.l_name,
838	.dlpi_phdr = @intToPtr([*]elf.Phdr, dlpi_phdr),
839	.dlpi_phnum = dlpi_phnum,
840	};
841
842	last_r = callback(&info, @sizeOf(dl_phdr_info), data);
843	if (last_r != 0) break;
844	}
845
846	return last_r;
847	}

std/os/posix.zig+157-220

 @@ -2,21 +2,18 @@
 // The purpose is not to match POSIX as closely as possible. Instead,
 // the goal is to provide a very specific layer of abstraction:
 // * Implement the POSIX functions, types, and definitions where possible,
-//   using lower-level target-specific API. For example, on Linux `rename` might call
+//   using lower-level target-specific API.
-//   SYS_renameat or SYS_rename depending on the architecture.
 // * When null-terminated byte buffers are required, provide APIs which accept
 //   slices as well as APIs which accept null-terminated byte buffers. Same goes
 //   for UTF-16LE encoding.
 // * Convert "errno"-style error codes into Zig errors.
-// * Work around kernel bugs and limitations. For example, if a function accepts
-//   a `usize` number of bytes to write, but the kernel can only handle maxInt(u32)
-//   number of bytes, this API layer should introduce a loop to make multiple
-//   syscalls so that the full `usize` number of bytes are written.
 // * Implement the OS-specific functions, types, and definitions that the Zig
 //   standard library needs, at the same API abstraction layer as outlined above.
-//   this includes, for example Windows functions.
+//   For example kevent() and getrandom(). Windows-specific functions are separate,
-// * When there exists a corresponding libc function and linking libc, call the
+//   in `std.os.windows`.
-//   libc function.
+// * When there exists a corresponding libc function and linking libc, the libc
+//   implementation is used. Exceptions are made for known buggy areas of libc.
+//   On Linux libc can be side-stepped by using `std.os.linux.sys`.
 // Note: The Zig standard library does not support POSIX thread cancellation, and
 // in general EINTR is handled by trying again.
 @@ -29,18 +26,13 @@ const mem = std.mem;
 const BufMap = std.BufMap;
 const Allocator = mem.Allocator;
 const windows = os.windows;
+const kernel32 = windows.kernel32;
 const wasi = os.wasi;
 const linux = os.linux;
 const testing = std.testing;
 pub use system.posix;
-/// > The maximum path of 32,767 characters is approximate, because the "\\?\"
-/// > prefix may be expanded to a longer string by the system at run time, and
-/// > this expansion applies to the total length.
-/// from https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
-pub const PATH_MAX_WIDE = 32767;
 /// See also `getenv`.
 pub var environ: [][*]u8 = undefined;
 @@ -59,7 +51,7 @@ pub const errno = system.getErrno;
 /// Note: The Zig standard library does not support POSIX thread cancellation.
 pub fn close(fd: fd_t) void {
     if (windows.is_the_target and !builtin.link_libc) {
-        assert(windows.CloseHandle(fd) != 0);
+        assert(kernel32.CloseHandle(fd) != 0);
         return;
     }
     if (wasi.is_the_target) {
 @@ -87,11 +79,10 @@ pub fn getrandom(buf: []u8) GetRandomError!void {
         // Call RtlGenRandom() instead of CryptGetRandom() on Windows
         // https://github.com/rust-lang-nursery/rand/issues/111
         // https://bugzilla.mozilla.org/show_bug.cgi?id=504270
-        if (windows.RtlGenRandom(buf.ptr, buf.len) == 0) {
+        if (windows.advapi32.RtlGenRandom(buf.ptr, buf.len) == 0) {
-            const err = windows.GetLastError();
+            switch (kernel32.GetLastError()) {
-            return switch (err) {
+                else => |err| return windows.unexpectedError(err),
-                else => unexpectedErrorWindows(err),
+            }
-            };
         }
         return;
     }
 @@ -230,12 +221,11 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {
             const want_read_count = @intCast(windows.DWORD, math.min(windows.DWORD(math.maxInt(windows.DWORD)), buffer.len - index));
             var amt_read: windows.DWORD = undefined;
             if (windows.ReadFile(fd, buffer.ptr + index, want_read_count, &amt_read, null) == 0) {
-                const err = windows.GetLastError();
+                switch (windows.GetLastError()) {
-                return switch (err) {
                     windows.ERROR.OPERATION_ABORTED => continue,
                     windows.ERROR.BROKEN_PIPE => return index,
-                    else => unexpectedErrorWindows(err),
+                    else => |err| return windows.unexpectedError(err),
-                };
+                }
             }
             if (amt_read == 0) return index;
             index += amt_read;
 @@ -372,7 +362,7 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!void {
                 windows.ERROR.NOT_ENOUGH_QUOTA => return error.SystemResources,
                 windows.ERROR.IO_PENDING => unreachable,
                 windows.ERROR.BROKEN_PIPE => return error.BrokenPipe,
-                else => |err| return unexpectedErrorWindows(err),
+                else => |err| return windows.unexpectedError(err),
             }
         }
     }
 @@ -543,67 +533,6 @@ pub fn openC(file_path: [*]const u8, flags: u32, perm: usize) OpenError!fd_t {
     }
 }
-pub const WindowsOpenError = error{
-    SharingViolation,
-    PathAlreadyExists,
-    /// When any of the path components can not be found or the file component can not
-    /// be found. Some operating systems distinguish between path components not found and
-    /// file components not found, but they are collapsed into FileNotFound to gain
-    /// consistency across operating systems.
-    FileNotFound,
-    AccessDenied,
-    PipeBusy,
-    NameTooLong,
-    /// On Windows, file paths must be valid Unicode.
-    InvalidUtf8,
-    /// On Windows, file paths cannot contain these characters:
-    /// '/', '*', '?', '"', '<', '>', '|'
-    BadPathName,
-    Unexpected,
-};
-pub fn openWindows(
-    file_path: []const u8,
-    desired_access: windows.DWORD,
-    share_mode: windows.DWORD,
-    creation_disposition: windows.DWORD,
-    flags_and_attrs: windows.DWORD,
-) WindowsOpenError!fd_t {
-    const file_path_w = try sliceToPrefixedFileW(file_path);
-    return openW(&file_path_w, desired_access, share_mode, creation_disposition, flags_and_attrs);
-}
-pub fn openW(
-    file_path_w: [*]const u16,
-    desired_access: windows.DWORD,
-    share_mode: windows.DWORD,
-    creation_disposition: windows.DWORD,
-    flags_and_attrs: windows.DWORD,
-) WindowsOpenError!windows.HANDLE {
-    const result = windows.CreateFileW(file_path_w, desired_access, share_mode, null, creation_disposition, flags_and_attrs, null);
-    if (result == windows.INVALID_HANDLE_VALUE) {
-        const err = windows.GetLastError();
-        switch (err) {
-            windows.ERROR.SHARING_VIOLATION => return error.SharingViolation,
-            windows.ERROR.ALREADY_EXISTS => return error.PathAlreadyExists,
-            windows.ERROR.FILE_EXISTS => return error.PathAlreadyExists,
-            windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
-            windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
-            windows.ERROR.ACCESS_DENIED => return error.AccessDenied,
-            windows.ERROR.PIPE_BUSY => return error.PipeBusy,
-            else => return unexpectedErrorWindows(err),
-        }
-    }
-    return result;
-}
 pub fn dup2(old_fd: fd_t, new_fd: fd_t) !void {
     while (true) {
         switch (errno(system.dup2(old_fd, new_fd))) {
 @@ -797,14 +726,13 @@ pub const GetCwdError = error{
 /// The result is a slice of out_buffer, indexed from 0.
 pub fn getcwd(out_buffer: []u8) GetCwdError![]u8 {
     if (windows.is_the_target and !builtin.link_libc) {
-        var utf16le_buf: [windows_util.PATH_MAX_WIDE]u16 = undefined;
+        var utf16le_buf: [windows.PATH_MAX_WIDE]u16 = undefined;
         const casted_len = @intCast(windows.DWORD, utf16le_buf.len); // TODO shouldn't need this cast
         const casted_ptr = ([*]u16)(&utf16le_buf); // TODO shouldn't need this cast
         const result = windows.GetCurrentDirectoryW(casted_len, casted_ptr);
         if (result == 0) {
-            const err = windows.GetLastError();
+            switch (windows.GetLastError()) {
-            switch (err) {
+                else => |err| return windows.unexpectedError(err),
-                else => return unexpectedErrorWindows(err),
             }
         }
         assert(result <= utf16le_buf.len);
 @@ -910,12 +838,7 @@ pub fn symlinkC(target_path: [*]const u8, new_path: [*]const u8) SymLinkError!vo
         const new_path_w = try cStrToPrefixedFileW(new_path);
         return symlinkW(&target_path_w, &new_path_w);
     }
-    const err = if (builtin.link_libc or @hasDecl(system, "SYS_symlink")) blk: {
+    switch (errno(system.symlink(target_path, new_path))) {
-        break :blk errno(system.symlink(target_path, new_path));
-    } else blk: {
-        break :blk errno(system.symlinkat(target_path, AT_FDCWD, new_path));
-    };
-    switch (err) {
         0 => return,
         EFAULT => unreachable,
         EINVAL => unreachable,
 @@ -931,7 +854,7 @@ pub fn symlinkC(target_path: [*]const u8, new_path: [*]const u8) SymLinkError!vo
         ENOMEM => return error.SystemResources,
         ENOSPC => return error.NoSpaceLeft,
         EROFS => return error.ReadOnlyFileSystem,
-        else => return unexpectedErrno(err),
+        else => |err| return unexpectedErrno(err),
     }
 }
 @@ -941,9 +864,8 @@ pub fn symlinkC(target_path: [*]const u8, new_path: [*]const u8) SymLinkError!vo
 /// TODO handle when linking libc
 pub fn symlinkW(target_path_w: [*]const u16, new_path_w: [*]const u16) SymLinkError!void {
     if (windows.CreateSymbolicLinkW(target_path_w, new_path_w, 0) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        switch (err) {
+            else => |err| return windows.unexpectedError(err),
-            else => return unexpectedErrorWindows(err),
         }
     }
 }
 @@ -984,13 +906,12 @@ pub fn unlink(file_path: []const u8) UnlinkError!void {
 /// TODO handle when linking libc
 pub fn unlinkW(file_path: [*]const u16) UnlinkError!void {
     if (windows.unlinkW(file_path) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        switch (err) {
             windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
             windows.ERROR.ACCESS_DENIED => return error.AccessDenied,
             windows.ERROR.FILENAME_EXCED_RANGE => return error.NameTooLong,
             windows.ERROR.INVALID_PARAMETER => return error.NameTooLong,
-            else => return unexpectedErrorWindows(err),
+            else => |err| return windows.unexpectedError(err),
         }
     }
 }
 @@ -1001,12 +922,7 @@ pub fn unlinkC(file_path: [*]const u8) UnlinkError!void {
         const file_path_w = try cStrToPrefixedFileW(file_path);
         return unlinkW(&file_path_w);
     }
-    const err = if (builtin.link_libc or @hasDecl(system, "SYS_unlink")) blk: {
+    switch (errno(system.unlink(file_path))) {
-        break :blk errno(system.unlink(file_path));
-    } else blk: {
-        break :blk errno(system.unlinkat(AT_FDCWD, file_path, 0));
-    };
-    switch (err) {
         0 => return,
         EACCES => return error.AccessDenied,
         EPERM => return error.AccessDenied,
 @@ -1021,7 +937,7 @@ pub fn unlinkC(file_path: [*]const u8) UnlinkError!void {
         ENOTDIR => return error.NotDir,
         ENOMEM => return error.SystemResources,
         EROFS => return error.ReadOnlyFileSystem,
-        else => return unexpectedErrno(err),
+        else => |err| return unexpectedErrno(err),
     }
 }
 @@ -1047,14 +963,7 @@ pub fn renameC(old_path: [*]const u8, new_path: [*]const u8) RenameError!void {
         const new_path_w = try cStrToPrefixedFileW(new_path);
         return renameW(&old_path_w, &new_path_w);
     }
-    const err = if (builtin.link_libc or @hasDecl(system, "SYS_rename")) blk: {
+    switch (errno(system.rename(old_path, new_path))) {
-        break :blk errno(system.rename(old_path, new_path));
-    } else if (@hasDecl(system, "SYS_renameat")) blk: {
-        break :blk errno(system.renameat(AT_FDCWD, old_path, AT_FDCWD, new_path));
-    } else blk: {
-        break :blk errno(system.renameat2(AT_FDCWD, old_path, AT_FDCWD, new_path, 0));
-    };
-    switch (err) {
         0 => return,
         EACCES => return error.AccessDenied,
         EPERM => return error.AccessDenied,
 @@ -1074,7 +983,7 @@ pub fn renameC(old_path: [*]const u8, new_path: [*]const u8) RenameError!void {
         ENOTEMPTY => return error.PathAlreadyExists,
         EROFS => return error.ReadOnlyFileSystem,
         EXDEV => return error.RenameAcrossMountPoints,
-        else => return unexpectedErrno(err),
+        else => |err| return unexpectedErrno(err),
     }
 }
 @@ -1083,9 +992,8 @@ pub fn renameC(old_path: [*]const u8, new_path: [*]const u8) RenameError!void {
 pub fn renameW(old_path: [*]const u16, new_path: [*]const u16) RenameError!void {
     const flags = windows.MOVEFILE_REPLACE_EXISTING | windows.MOVEFILE_WRITE_THROUGH;
     if (windows.MoveFileExW(old_path, new_path, flags) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        switch (err) {
+            else => |err| return windows.unexpectedError(err),
-            else => return unexpectedErrorWindows(err),
         }
     }
 }
 @@ -1110,12 +1018,7 @@ pub fn mkdirC(dir_path: [*]const u8, mode: u32) MakeDirError!void {
         const dir_path_w = try cStrToPrefixedFileW(dir_path);
         return mkdirW(&dir_path_w, mode);
     }
-    const err = if (builtin.link_libc or @hasDecl(system, "SYS_mkdir")) blk: {
+    switch (errno(system.mkdir(dir_path, mode))) {
-        break :blk errno(system.mkdir(dir_path, mode));
-    } else blk: {
-        break :blk errno(system.mkdirat(AT_FDCWD, dir_path, mode));
-    };
-    switch (err) {
         0 => return,
         EACCES => return error.AccessDenied,
         EPERM => return error.AccessDenied,
 @@ -1130,7 +1033,7 @@ pub fn mkdirC(dir_path: [*]const u8, mode: u32) MakeDirError!void {
         ENOSPC => return error.NoSpaceLeft,
         ENOTDIR => return error.NotDir,
         EROFS => return error.ReadOnlyFileSystem,
-        else => return unexpectedErrno(err),
+        else => |err| return unexpectedErrno(err),
     }
 }
 @@ -1139,11 +1042,10 @@ pub fn mkdirW(dir_path: []const u8, mode: u32) MakeDirError!void {
     const dir_path_w = try sliceToPrefixedFileW(dir_path);
     if (windows.CreateDirectoryW(&dir_path_w, null) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        switch (err) {
             windows.ERROR.ALREADY_EXISTS => return error.PathAlreadyExists,
             windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
-            else => return unexpectedErrorWindows(err),
+            else => |err| return windows.unexpectedError(err),
         }
     }
 }
 @@ -1180,12 +1082,7 @@ pub fn rmdirC(dir_path: [*]const u8) DeleteDirError!void {
         const dir_path_w = try cStrToPrefixedFileW(dir_path);
         return rmdirW(&dir_path_w);
     }
-    const err = if (builtin.link_libc or @hasDecl(system, "SYS_rmdir")) blk: {
+    switch (errno(system.rmdir(dir_path))) {
-        break :blk errno(system.rmdir(dir_path));
-    } else blk: {
-        break :blk errno(system.unlinkat(AT_FDCWD, dir_path, AT_REMOVEDIR));
-    };
-    switch (err) {
         0 => return,
         EACCES => return error.AccessDenied,
         EPERM => return error.AccessDenied,
 @@ -1200,7 +1097,7 @@ pub fn rmdirC(dir_path: [*]const u8) DeleteDirError!void {
         EEXIST => return error.DirNotEmpty,
         ENOTEMPTY => return error.DirNotEmpty,
         EROFS => return error.ReadOnlyFileSystem,
-        else => return unexpectedErrno(err),
+        else => |err| return unexpectedErrno(err),
     }
 }
 @@ -1208,11 +1105,10 @@ pub fn rmdirC(dir_path: [*]const u8) DeleteDirError!void {
 /// TODO handle linking libc
 pub fn rmdirW(dir_path_w: [*]const u16) DeleteDirError!void {
     if (windows.RemoveDirectoryW(dir_path_w) == 0) {
-        const err = windows.GetLastError();
+        switch (windows.GetLastError()) {
-        switch (err) {
             windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
             windows.ERROR.DIR_NOT_EMPTY => return error.DirNotEmpty,
-            else => return unexpectedErrorWindows(err),
+            else => |err| return windows.unexpectedError(err),
         }
     }
 }
 @@ -1277,11 +1173,7 @@ pub fn readlinkC(file_path: [*]const u8, out_buffer: []u8) ReadLinkError![]u8 {
         const file_path_w = try cStrToPrefixedFileW(file_path);
         return readlinkW(&file_path_w, out_buffer);
     }
-    const rc = if (builtin.link_libc or @hasDecl(system, "SYS_readlink")) blk: {
+    const rc = system.readlink(file_path, out_buffer.ptr, out_buffer.len);
-        break :blk system.readlink(file_path, out_buffer.ptr, out_buffer.len);
-    } else blk: {
-        break :blk system.readlinkat(AT_FDCWD, file_path, out_buffer.ptr, out_buffer.len);
-    };
     switch (errno(rc)) {
         0 => return out_buffer[0..rc],
         EACCES => return error.AccessDenied,
 @@ -1354,7 +1246,7 @@ pub fn GetStdHandle(handle_id: windows.DWORD) GetStdHandleError!fd_t {
         const handle = windows.GetStdHandle(handle_id) orelse return error.NoStandardHandleAttached;
         if (handle == windows.INVALID_HANDLE_VALUE) {
             switch (windows.GetLastError()) {
-                else => |err| unexpectedErrorWindows(err),
+                else => |err| windows.unexpectedError(err),
             }
         }
         return handle;
 @@ -2070,17 +1962,12 @@ pub const ForkError = error{
 };
 pub fn fork() ForkError!pid_t {
-    if (builtin.link_libc) {
+    const rc = system.fork();
-        return system.fork();
+    switch (errno(rc)) {
-    }
+        0 => return rc,
-    if (linux.is_the_target) {
+        EAGAIN => return error.SystemResources,
-        const rc = if (@hasDecl(system, "SYS_fork")) system.fork() else system.clone2(SIGCHLD, 0);
+        ENOMEM => return error.SystemResources,
-        switch (errno(rc)) {
+        else => |err| return unexpectedErrno(err),
-            0 => return rc,
-            EAGAIN => return error.SystemResources,
-            ENOMEM => return error.SystemResources,
-            else => |err| return unexpectedErrno(err),
-        }
     }
 }
 @@ -2173,7 +2060,7 @@ pub fn accessW(path: [*]const u16, mode: u32) AccessError!void {
         windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
         windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
         windows.ERROR.ACCESS_DENIED => return error.PermissionDenied,
-        else => |err| return unexpectedErrorWindows(err),
+        else => |err| return windows.unexpectedError(err),
     }
 }
 @@ -2209,11 +2096,7 @@ pub const PipeError = error{
 /// Creates a unidirectional data channel that can be used for interprocess communication.
 pub fn pipe(fds: *[2]fd_t) PipeError!void {
-    const rc = if (builtin.link_libc or @hasDecl(system, SYS_pipe))
+    switch (errno(system.pipe(fds))) {
-        system.pipe(fds)
-    else
-        system.pipe2(fds, 0);
-    switch (errno(rc)) {
         0 => return,
         EINVAL => unreachable, // Invalid parameters to pipe()
         EFAULT => unreachable, // Invalid fds pointer
 @@ -2296,6 +2179,112 @@ pub const realpath = std.os.path.real;
 pub const realpathC = std.os.path.realC;
 pub const realpathW = std.os.path.realW;
+pub const WaitForSingleObjectError = error{
+    WaitAbandoned,
+    WaitTimeOut,
+    Unexpected,
+};
+pub fn WaitForSingleObject(handle: windows.HANDLE, milliseconds: windows.DWORD) WaitForSingleObjectError!void {
+    switch (windows.WaitForSingleObject(handle, milliseconds)) {
+        windows.WAIT_ABANDONED => return error.WaitAbandoned,
+        windows.WAIT_OBJECT_0 => return,
+        windows.WAIT_TIMEOUT => return error.WaitTimeOut,
+        windows.WAIT_FAILED => {
+            switch (windows.GetLastError()) {
+                else => |err| return windows.unexpectedError(err),
+            }
+        },
+        else => return error.Unexpected,
+    }
+}
+pub fn FindFirstFile(
+    dir_path: []const u8,
+    find_file_data: *windows.WIN32_FIND_DATAW,
+) !windows.HANDLE {
+    const dir_path_w = try sliceToPrefixedSuffixedFileW(dir_path, []u16{ '\\', '*', 0 });
+    const handle = windows.FindFirstFileW(&dir_path_w, find_file_data);
+    if (handle == windows.INVALID_HANDLE_VALUE) {
+        switch (windows.GetLastError()) {
+            windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
+            windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
+            else => |err| return windows.unexpectedError(err),
+        }
+    }
+    return handle;
+}
+/// Returns `true` if there was another file, `false` otherwise.
+pub fn FindNextFile(handle: windows.HANDLE, find_file_data: *windows.WIN32_FIND_DATAW) !bool {
+    if (windows.FindNextFileW(handle, find_file_data) == 0) {
+        switch (windows.GetLastError()) {
+            windows.ERROR.NO_MORE_FILES => return false,
+            else => |err| return windows.unexpectedError(err),
+        }
+    }
+    return true;
+}
+pub const CreateIoCompletionPortError = error{Unexpected};
+pub fn CreateIoCompletionPort(
+    file_handle: windows.HANDLE,
+    existing_completion_port: ?windows.HANDLE,
+    completion_key: usize,
+    concurrent_thread_count: windows.DWORD,
+) CreateIoCompletionPortError!windows.HANDLE {
+    const handle = windows.CreateIoCompletionPort(file_handle, existing_completion_port, completion_key, concurrent_thread_count) orelse {
+        switch (windows.GetLastError()) {
+            windows.ERROR.INVALID_PARAMETER => unreachable,
+            else => |err| return windows.unexpectedError(err),
+        }
+    };
+    return handle;
+}
+pub const WindowsPostQueuedCompletionStatusError = error{Unexpected};
+pub fn windowsPostQueuedCompletionStatus(completion_port: windows.HANDLE, bytes_transferred_count: windows.DWORD, completion_key: usize, lpOverlapped: ?*windows.OVERLAPPED) WindowsPostQueuedCompletionStatusError!void {
+    if (windows.PostQueuedCompletionStatus(completion_port, bytes_transferred_count, completion_key, lpOverlapped) == 0) {
+        const err = windows.GetLastError();
+        switch (err) {
+            else => return windows.unexpectedError(err),
+        }
+    }
+}
+pub const GetQueuedCompletionStatusResult = enum {
+    Normal,
+    Aborted,
+    Cancelled,
+    EOF,
+};
+pub fn GetQueuedCompletionStatus(
+    completion_port: windows.HANDLE,
+    bytes_transferred_count: *windows.DWORD,
+    lpCompletionKey: *usize,
+    lpOverlapped: *?*windows.OVERLAPPED,
+    dwMilliseconds: windows.DWORD,
+) GetQueuedCompletionStatusResult {
+    if (windows.GetQueuedCompletionStatus(completion_port, bytes_transferred_count, lpCompletionKey, lpOverlapped, dwMilliseconds) == windows.FALSE) {
+        switch (windows.GetLastError()) {
+            windows.ERROR.ABANDONED_WAIT_0 => return GetQueuedCompletionStatusResult.Aborted,
+            windows.ERROR.OPERATION_ABORTED => return GetQueuedCompletionStatusResult.Cancelled,
+            windows.ERROR.HANDLE_EOF => return GetQueuedCompletionStatusResult.EOF,
+            else => |err| {
+                if (std.debug.runtime_safety) {
+                    std.debug.panic("unexpected error: {}\n", err);
+                }
+            },
+        }
+    }
+    return GetQueuedCompletionStatusResult.Normal;
+}
 /// Used to convert a slice to a null terminated slice on the stack.
 /// TODO https://github.com/ziglang/zig/issues/287
 pub fn toPosixPath(file_path: []const u8) ![PATH_MAX]u8 {
 @@ -2307,64 +2296,12 @@ pub fn toPosixPath(file_path: []const u8) ![PATH_MAX]u8 {
     return path_with_null;
 }
-const unexpected_error_tracing = builtin.mode == .Debug;
-const UnexpectedError = error{
-    /// The Operating System returned an undocumented error code.
-    Unexpected,
-};
 /// Call this when you made a syscall or something that sets errno
 /// and you get an unexpected error.
-pub fn unexpectedErrno(errno: usize) UnexpectedError {
+pub fn unexpectedErrno(errno: usize) os.UnexpectedError {
-    if (unexpected_error_tracing) {
+    if (os.unexpected_error_tracing) {
         std.debug.warn("unexpected errno: {}\n", errno);
         std.debug.dumpCurrentStackTrace(null);
     }
     return error.Unexpected;
 }
-/// Call this when you made a windows DLL call or something that does SetLastError
-/// and you get an unexpected error.
-pub fn unexpectedErrorWindows(err: windows.DWORD) UnexpectedError {
-    if (unexpected_error_tracing) {
-        std.debug.warn("unexpected GetLastError(): {}\n", err);
-        std.debug.dumpCurrentStackTrace(null);
-    }
-    return error.Unexpected;
-}
-pub fn cStrToPrefixedFileW(s: [*]const u8) ![PATH_MAX_WIDE + 1]u16 {
-    return sliceToPrefixedFileW(mem.toSliceConst(u8, s));
-}
-pub fn sliceToPrefixedFileW(s: []const u8) ![PATH_MAX_WIDE + 1]u16 {
-    return sliceToPrefixedSuffixedFileW(s, []u16{0});
-}
-pub fn sliceToPrefixedSuffixedFileW(s: []const u8, comptime suffix: []const u16) ![PATH_MAX_WIDE + suffix.len]u16 {
-    // TODO well defined copy elision
-    var result: [PATH_MAX_WIDE + suffix.len]u16 = undefined;
-    // > File I/O functions in the Windows API convert "/" to "\" as part of
-    // > converting the name to an NT-style name, except when using the "\\?\"
-    // > prefix as detailed in the following sections.
-    // from https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
-    // Because we want the larger maximum path length for absolute paths, we
-    // disallow forward slashes in zig std lib file functions on Windows.
-    for (s) |byte| {
-        switch (byte) {
-            '/', '*', '?', '"', '<', '>', '|' => return error.BadPathName,
-            else => {},
-        }
-    }
-    const start_index = if (mem.startsWith(u8, s, "\\\\") or !os.path.isAbsolute(s)) 0 else blk: {
-        const prefix = []u16{ '\\', '\\', '?', '\\' };
-        mem.copy(u16, result[0..], prefix);
-        break :blk prefix.len;
-    };
-    const end_index = start_index + try std.unicode.utf8ToUtf16Le(result[start_index..], s);
-    assert(end_index <= result.len);
-    if (end_index + suffix.len > result.len) return error.NameTooLong;
-    mem.copy(u16, result[end_index..], suffix);
-    return result;
-}

std/os/windows.zig+248-16

...	@@ -1,28 +1,30 @@	...	@@ -1,28 +1,30 @@
		1	// This file contains the types and constants of the Windows API,
		2	// as well as the Windows-equivalent of "Zig-flavored POSIX" API layer.
1	const std = @import("../std.zig");	3	const std = @import("../std.zig");
2	const assert = std.debug.assert;	4	const assert = std.debug.assert;
3	const maxInt = std.math.maxInt;	5	const maxInt = std.math.maxInt;
4		6
5	pub const is_the_target = switch (builtin.os) {	7	pub const is_the_target = builtin.os == .windows;
6	.windows => true,	8	pub const posix = if (builtin.link_libc) struct {} else @import("windows/posix.zig");
7	else => false,
8	};
9	pub const posix = @import("windows/posix.zig");
10	pub use posix;	9	pub use posix;
11		10
12	pub use @import("windows/advapi32.zig");	11	pub const advapi32 = @import("windows/advapi32.zig");
13	pub use @import("windows/kernel32.zig");	12	pub const kernel32 = @import("windows/kernel32.zig");
14	pub use @import("windows/ntdll.zig");	13	pub const ntdll = @import("windows/ntdll.zig");
15	pub use @import("windows/ole32.zig");	14	pub const ole32 = @import("windows/ole32.zig");
16	pub use @import("windows/shell32.zig");	15	pub const shell32 = @import("windows/shell32.zig");
17
18	test "import" {
19	if (is_the_target) {
20	_ = @import("windows/util.zig");
21	}
22	}
23		16
24	pub const ERROR = @import("windows/error.zig");	17	pub const ERROR = @import("windows/error.zig");
25		18
		19	/// The standard input device. Initially, this is the console input buffer, CONIN$.
		20	pub const STD_INPUT_HANDLE = maxInt(DWORD) - 10 + 1;
		21
		22	/// The standard output device. Initially, this is the active console screen buffer, CONOUT$.
		23	pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
		24
		25	/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
		26	pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;
		27
26	pub const SHORT = c_short;	28	pub const SHORT = c_short;
27	pub const BOOL = c_int;	29	pub const BOOL = c_int;
28	pub const BOOLEAN = BYTE;	30	pub const BOOLEAN = BYTE;
...	@@ -428,3 +430,233 @@ pub const IMAGE_TLS_DIRECTORY64 = IMAGE_TLS_DIRECTORY;	...	@@ -428,3 +430,233 @@ pub const IMAGE_TLS_DIRECTORY64 = IMAGE_TLS_DIRECTORY;
428	pub const IMAGE_TLS_DIRECTORY32 = IMAGE_TLS_DIRECTORY;	430	pub const IMAGE_TLS_DIRECTORY32 = IMAGE_TLS_DIRECTORY;
429		431
430	pub const PIMAGE_TLS_CALLBACK = ?extern fn (PVOID, DWORD, PVOID) void;	432	pub const PIMAGE_TLS_CALLBACK = ?extern fn (PVOID, DWORD, PVOID) void;
		433
		434	pub const PROV_RSA_FULL = 1;
		435
		436	pub const REGSAM = ACCESS_MASK;
		437	pub const ACCESS_MASK = DWORD;
		438	pub const PHKEY = *HKEY;
		439	pub const HKEY = *HKEY__;
		440	pub const HKEY__ = extern struct {
		441	unused: c_int,
		442	};
		443	pub const LSTATUS = LONG;
		444
		445	pub const FILE_NOTIFY_INFORMATION = extern struct {
		446	NextEntryOffset: DWORD,
		447	Action: DWORD,
		448	FileNameLength: DWORD,
		449	FileName: [1]WCHAR,
		450	};
		451
		452	pub const FILE_ACTION_ADDED = 0x00000001;
		453	pub const FILE_ACTION_REMOVED = 0x00000002;
		454	pub const FILE_ACTION_MODIFIED = 0x00000003;
		455	pub const FILE_ACTION_RENAMED_OLD_NAME = 0x00000004;
		456	pub const FILE_ACTION_RENAMED_NEW_NAME = 0x00000005;
		457
		458	pub const LPOVERLAPPED_COMPLETION_ROUTINE = ?extern fn (DWORD, DWORD, *OVERLAPPED) void;
		459
		460	pub const FILE_LIST_DIRECTORY = 1;
		461
		462	pub const FILE_NOTIFY_CHANGE_CREATION = 64;
		463	pub const FILE_NOTIFY_CHANGE_SIZE = 8;
		464	pub const FILE_NOTIFY_CHANGE_SECURITY = 256;
		465	pub const FILE_NOTIFY_CHANGE_LAST_ACCESS = 32;
		466	pub const FILE_NOTIFY_CHANGE_LAST_WRITE = 16;
		467	pub const FILE_NOTIFY_CHANGE_DIR_NAME = 2;
		468	pub const FILE_NOTIFY_CHANGE_FILE_NAME = 1;
		469	pub const FILE_NOTIFY_CHANGE_ATTRIBUTES = 4;
		470
		471	pub const CONSOLE_SCREEN_BUFFER_INFO = extern struct {
		472	dwSize: COORD,
		473	dwCursorPosition: COORD,
		474	wAttributes: WORD,
		475	srWindow: SMALL_RECT,
		476	dwMaximumWindowSize: COORD,
		477	};
		478
		479	pub const FOREGROUND_BLUE = 1;
		480	pub const FOREGROUND_GREEN = 2;
		481	pub const FOREGROUND_RED = 4;
		482	pub const FOREGROUND_INTENSITY = 8;
		483
		484	pub const LIST_ENTRY = extern struct {
		485	Flink: *LIST_ENTRY,
		486	Blink: *LIST_ENTRY,
		487	};
		488
		489	pub const RTL_CRITICAL_SECTION_DEBUG = extern struct {
		490	Type: WORD,
		491	CreatorBackTraceIndex: WORD,
		492	CriticalSection: *RTL_CRITICAL_SECTION,
		493	ProcessLocksList: LIST_ENTRY,
		494	EntryCount: DWORD,
		495	ContentionCount: DWORD,
		496	Flags: DWORD,
		497	CreatorBackTraceIndexHigh: WORD,
		498	SpareWORD: WORD,
		499	};
		500
		501	pub const RTL_CRITICAL_SECTION = extern struct {
		502	DebugInfo: *RTL_CRITICAL_SECTION_DEBUG,
		503	LockCount: LONG,
		504	RecursionCount: LONG,
		505	OwningThread: HANDLE,
		506	LockSemaphore: HANDLE,
		507	SpinCount: ULONG_PTR,
		508	};
		509
		510	pub const CRITICAL_SECTION = RTL_CRITICAL_SECTION;
		511	pub const INIT_ONCE = RTL_RUN_ONCE;
		512	pub const INIT_ONCE_STATIC_INIT = RTL_RUN_ONCE_INIT;
		513	pub const INIT_ONCE_FN = extern fn (InitOnce: INIT_ONCE, Parameter: ?c_void, Context: ?*c_void) BOOL;
		514
		515	pub const RTL_RUN_ONCE = extern struct {
		516	Ptr: ?*c_void,
		517	};
		518
		519	pub const RTL_RUN_ONCE_INIT = RTL_RUN_ONCE{ .Ptr = null };
		520
		521	pub const COINIT_APARTMENTTHREADED = COINIT.COINIT_APARTMENTTHREADED;
		522	pub const COINIT_MULTITHREADED = COINIT.COINIT_MULTITHREADED;
		523	pub const COINIT_DISABLE_OLE1DDE = COINIT.COINIT_DISABLE_OLE1DDE;
		524	pub const COINIT_SPEED_OVER_MEMORY = COINIT.COINIT_SPEED_OVER_MEMORY;
		525	pub const COINIT = extern enum {
		526	COINIT_APARTMENTTHREADED = 2,
		527	COINIT_MULTITHREADED = 0,
		528	COINIT_DISABLE_OLE1DDE = 4,
		529	COINIT_SPEED_OVER_MEMORY = 8,
		530	};
		531
		532	/// > The maximum path of 32,767 characters is approximate, because the "\\?\"
		533	/// > prefix may be expanded to a longer string by the system at run time, and
		534	/// > this expansion applies to the total length.
		535	/// from https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
		536	pub const PATH_MAX_WIDE = 32767;
		537
		538	pub const OpenError = error{
		539	SharingViolation,
		540	PathAlreadyExists,
		541
		542	/// When any of the path components can not be found or the file component can not
		543	/// be found. Some operating systems distinguish between path components not found and
		544	/// file components not found, but they are collapsed into FileNotFound to gain
		545	/// consistency across operating systems.
		546	FileNotFound,
		547
		548	AccessDenied,
		549	PipeBusy,
		550	NameTooLong,
		551
		552	/// On Windows, file paths must be valid Unicode.
		553	InvalidUtf8,
		554
		555	/// On Windows, file paths cannot contain these characters:
		556	/// '/', '*', '?', '"', '<', '>', '\|'
		557	BadPathName,
		558
		559	Unexpected,
		560	};
		561
		562	pub fn CreateFile(
		563	file_path: []const u8,
		564	desired_access: DWORD,
		565	share_mode: DWORD,
		566	creation_disposition: DWORD,
		567	flags_and_attrs: DWORD,
		568	) OpenError!fd_t {
		569	const file_path_w = try sliceToPrefixedFileW(file_path);
		570	return CreateFileW(&file_path_w, desired_access, share_mode, creation_disposition, flags_and_attrs);
		571	}
		572
		573	pub fn CreateFileW(
		574	file_path_w: [*]const u16,
		575	desired_access: DWORD,
		576	share_mode: DWORD,
		577	creation_disposition: DWORD,
		578	flags_and_attrs: DWORD,
		579	) OpenError!HANDLE {
		580	const result = kernel32.CreateFileW(file_path_w, desired_access, share_mode, null, creation_disposition, flags_and_attrs, null);
		581
		582	if (result == INVALID_HANDLE_VALUE) {
		583	switch (kernel32.GetLastError()) {
		584	ERROR.SHARING_VIOLATION => return error.SharingViolation,
		585	ERROR.ALREADY_EXISTS => return error.PathAlreadyExists,
		586	ERROR.FILE_EXISTS => return error.PathAlreadyExists,
		587	ERROR.FILE_NOT_FOUND => return error.FileNotFound,
		588	ERROR.PATH_NOT_FOUND => return error.FileNotFound,
		589	ERROR.ACCESS_DENIED => return error.AccessDenied,
		590	ERROR.PIPE_BUSY => return error.PipeBusy,
		591	else => \|err\| return unexpectedErrorWindows(err),
		592	}
		593	}
		594
		595	return result;
		596	}
		597
		598	pub const CreatePipeError = error{Unexpected};
		599
		600	fn CreatePipe(rd: HANDLE, wr: HANDLE, sattr: *const SECURITY_ATTRIBUTES) CreatePipeError!void {
		601	if (kernel32.CreatePipe(rd, wr, sattr, 0) == 0) {
		602	switch (kernel32.GetLastError()) {
		603	else => \|err\| return unexpectedError(err),
		604	}
		605	}
		606	}
		607
		608	pub const SetHandleInformationError = error{Unexpected};
		609
		610	fn SetHandleInformation(h: HANDLE, mask: DWORD, flags: DWORD) SetHandleInformationError!void {
		611	if (SetHandleInformation(h, mask, flags) == 0) {
		612	switch (kernel32.GetLastError()) {
		613	else => \|err\| return unexpectedError(err),
		614	}
		615	}
		616	}
		617
		618	pub fn cStrToPrefixedFileW(s: [*]const u8) ![PATH_MAX_WIDE + 1]u16 {
		619	return sliceToPrefixedFileW(mem.toSliceConst(u8, s));
		620	}
		621
		622	pub fn sliceToPrefixedFileW(s: []const u8) ![PATH_MAX_WIDE + 1]u16 {
		623	return sliceToPrefixedSuffixedFileW(s, []u16{0});
		624	}
		625
		626	pub fn sliceToPrefixedSuffixedFileW(s: []const u8, comptime suffix: []const u16) ![PATH_MAX_WIDE + suffix.len]u16 {
		627	// TODO well defined copy elision
		628	var result: [PATH_MAX_WIDE + suffix.len]u16 = undefined;
		629
		630	// > File I/O functions in the Windows API convert "/" to "\" as part of
		631	// > converting the name to an NT-style name, except when using the "\\?\"
		632	// > prefix as detailed in the following sections.
		633	// from https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
		634	// Because we want the larger maximum path length for absolute paths, we
		635	// disallow forward slashes in zig std lib file functions on Windows.
		636	for (s) \|byte\| {
		637	switch (byte) {
		638	'/', '*', '?', '"', '<', '>', '\|' => return error.BadPathName,
		639	else => {},
		640	}
		641	}
		642	const start_index = if (mem.startsWith(u8, s, "\\\\") or !os.path.isAbsolute(s)) 0 else blk: {
		643	const prefix = []u16{ '\\', '\\', '?', '\\' };
		644	mem.copy(u16, result[0..], prefix);
		645	break :blk prefix.len;
		646	};
		647	const end_index = start_index + try std.unicode.utf8ToUtf16Le(result[start_index..], s);
		648	assert(end_index <= result.len);
		649	if (end_index + suffix.len > result.len) return error.NameTooLong;
		650	mem.copy(u16, result[end_index..], suffix);
		651	return result;
		652	}
		653
		654	/// Call this when you made a windows DLL call or something that does SetLastError
		655	/// and you get an unexpected error.
		656	pub fn unexpectedError(err: DWORD) std.os.UnexpectedError {
		657	if (std.os.unexpected_error_tracing) {
		658	std.debug.warn("unexpected GetLastError(): {}\n", err);
		659	std.debug.dumpCurrentStackTrace(null);
		660	}
		661	return error.Unexpected;
		662	}

std/os/windows/advapi32.zig-11

...	@@ -1,16 +1,5 @@	...	@@ -1,16 +1,5 @@
1	use @import("../windows.zig");	1	use @import("../windows.zig");
2		2
3	pub const PROV_RSA_FULL = 1;
4
5	pub const REGSAM = ACCESS_MASK;
6	pub const ACCESS_MASK = DWORD;
7	pub const PHKEY = *HKEY;
8	pub const HKEY = *HKEY__;
9	pub const HKEY__ = extern struct {
10	unused: c_int,
11	};
12	pub const LSTATUS = LONG;
13
14	pub extern "advapi32" stdcallcc fn RegOpenKeyExW(	3	pub extern "advapi32" stdcallcc fn RegOpenKeyExW(
15	hKey: HKEY,	4	hKey: HKEY,
16	lpSubKey: LPCWSTR,	5	lpSubKey: LPCWSTR,

std/os/windows/kernel32.zig-77

...	@@ -189,86 +189,9 @@ pub extern "kernel32" stdcallcc fn GetProcAddress(hModule: HMODULE, lpProcName:	...	@@ -189,86 +189,9 @@ pub extern "kernel32" stdcallcc fn GetProcAddress(hModule: HMODULE, lpProcName:
189		189
190	pub extern "kernel32" stdcallcc fn FreeLibrary(hModule: HMODULE) BOOL;	190	pub extern "kernel32" stdcallcc fn FreeLibrary(hModule: HMODULE) BOOL;
191		191
192	pub const FILE_NOTIFY_INFORMATION = extern struct {
193	NextEntryOffset: DWORD,
194	Action: DWORD,
195	FileNameLength: DWORD,
196	FileName: [1]WCHAR,
197	};
198
199	pub const FILE_ACTION_ADDED = 0x00000001;
200	pub const FILE_ACTION_REMOVED = 0x00000002;
201	pub const FILE_ACTION_MODIFIED = 0x00000003;
202	pub const FILE_ACTION_RENAMED_OLD_NAME = 0x00000004;
203	pub const FILE_ACTION_RENAMED_NEW_NAME = 0x00000005;
204
205	pub const LPOVERLAPPED_COMPLETION_ROUTINE = ?extern fn (DWORD, DWORD, *OVERLAPPED) void;
206
207	pub const FILE_LIST_DIRECTORY = 1;
208
209	pub const FILE_NOTIFY_CHANGE_CREATION = 64;
210	pub const FILE_NOTIFY_CHANGE_SIZE = 8;
211	pub const FILE_NOTIFY_CHANGE_SECURITY = 256;
212	pub const FILE_NOTIFY_CHANGE_LAST_ACCESS = 32;
213	pub const FILE_NOTIFY_CHANGE_LAST_WRITE = 16;
214	pub const FILE_NOTIFY_CHANGE_DIR_NAME = 2;
215	pub const FILE_NOTIFY_CHANGE_FILE_NAME = 1;
216	pub const FILE_NOTIFY_CHANGE_ATTRIBUTES = 4;
217
218	pub const CONSOLE_SCREEN_BUFFER_INFO = extern struct {
219	dwSize: COORD,
220	dwCursorPosition: COORD,
221	wAttributes: WORD,
222	srWindow: SMALL_RECT,
223	dwMaximumWindowSize: COORD,
224	};
225
226	pub const FOREGROUND_BLUE = 1;
227	pub const FOREGROUND_GREEN = 2;
228	pub const FOREGROUND_RED = 4;
229	pub const FOREGROUND_INTENSITY = 8;
230
231	pub extern "kernel32" stdcallcc fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;	192	pub extern "kernel32" stdcallcc fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
232	pub extern "kernel32" stdcallcc fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;	193	pub extern "kernel32" stdcallcc fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
233	pub extern "kernel32" stdcallcc fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;	194	pub extern "kernel32" stdcallcc fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
234	pub extern "kernel32" stdcallcc fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;	195	pub extern "kernel32" stdcallcc fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) void;
235		196
236	pub const LIST_ENTRY = extern struct {
237	Flink: *LIST_ENTRY,
238	Blink: *LIST_ENTRY,
239	};
240
241	pub const RTL_CRITICAL_SECTION_DEBUG = extern struct {
242	Type: WORD,
243	CreatorBackTraceIndex: WORD,
244	CriticalSection: *RTL_CRITICAL_SECTION,
245	ProcessLocksList: LIST_ENTRY,
246	EntryCount: DWORD,
247	ContentionCount: DWORD,
248	Flags: DWORD,
249	CreatorBackTraceIndexHigh: WORD,
250	SpareWORD: WORD,
251	};
252
253	pub const RTL_CRITICAL_SECTION = extern struct {
254	DebugInfo: *RTL_CRITICAL_SECTION_DEBUG,
255	LockCount: LONG,
256	RecursionCount: LONG,
257	OwningThread: HANDLE,
258	LockSemaphore: HANDLE,
259	SpinCount: ULONG_PTR,
260	};
261
262	pub const CRITICAL_SECTION = RTL_CRITICAL_SECTION;
263	pub const INIT_ONCE = RTL_RUN_ONCE;
264	pub const INIT_ONCE_STATIC_INIT = RTL_RUN_ONCE_INIT;
265
266	pub extern "kernel32" stdcallcc fn InitOnceExecuteOnce(InitOnce: INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?c_void, Context: ?*c_void) BOOL;	197	pub extern "kernel32" stdcallcc fn InitOnceExecuteOnce(InitOnce: INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?c_void, Context: ?*c_void) BOOL;
267
268	pub const INIT_ONCE_FN = extern fn (InitOnce: INIT_ONCE, Parameter: ?c_void, Context: ?*c_void) BOOL;
269
270	pub const RTL_RUN_ONCE = extern struct {
271	Ptr: ?*c_void,
272	};
273
274	pub const RTL_RUN_ONCE_INIT = RTL_RUN_ONCE{ .Ptr = null };

std/os/windows/ole32.zig-11

...	@@ -4,14 +4,3 @@ pub extern "ole32" stdcallcc fn CoTaskMemFree(pv: LPVOID) void;	...	@@ -4,14 +4,3 @@ pub extern "ole32" stdcallcc fn CoTaskMemFree(pv: LPVOID) void;
4	pub extern "ole32" stdcallcc fn CoUninitialize() void;	4	pub extern "ole32" stdcallcc fn CoUninitialize() void;
5	pub extern "ole32" stdcallcc fn CoGetCurrentProcess() DWORD;	5	pub extern "ole32" stdcallcc fn CoGetCurrentProcess() DWORD;
6	pub extern "ole32" stdcallcc fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) HRESULT;	6	pub extern "ole32" stdcallcc fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) HRESULT;
7
8	pub const COINIT_APARTMENTTHREADED = COINIT.COINIT_APARTMENTTHREADED;
9	pub const COINIT_MULTITHREADED = COINIT.COINIT_MULTITHREADED;
10	pub const COINIT_DISABLE_OLE1DDE = COINIT.COINIT_DISABLE_OLE1DDE;
11	pub const COINIT_SPEED_OVER_MEMORY = COINIT.COINIT_SPEED_OVER_MEMORY;
12	pub const COINIT = extern enum {
13	COINIT_APARTMENTTHREADED = 2,
14	COINIT_MULTITHREADED = 0,
15	COINIT_DISABLE_OLE1DDE = 4,
16	COINIT_SPEED_OVER_MEMORY = 8,
17	};

std/os/windows/posix.zig+4-13

...	@@ -1,15 +1,6 @@	...	@@ -1,15 +1,6 @@
1	// Declarations that are intended to be imported into the POSIX namespace.	1	// Declarations that are intended to be imported into the POSIX namespace,
		2	// when not linking libc.
2	const std = @import("../../std.zig");	3	const std = @import("../../std.zig");
3	const maxInt = std.math.maxInt;	4	const builtin = @import("builtin");
4	use std.os.windows;
5		5
6	pub const fd_t = HANDLE;	6	pub const fd_t = std.os.windows.HANDLE;
7
8	/// The standard input device. Initially, this is the console input buffer, CONIN$.
9	pub const STD_INPUT_HANDLE = maxInt(DWORD) - 10 + 1;
10
11	/// The standard output device. Initially, this is the active console screen buffer, CONOUT$.
12	pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
13
14	/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
15	pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;

std/os/windows/util.zig deleted-147

...	@@ -1,147 +0,0 @@
1	const std = @import("../../std.zig");
2	const builtin = @import("builtin");
3	const os = std.os;
4	const unicode = std.unicode;
5	const windows = std.os.windows;
6	const assert = std.debug.assert;
7	const mem = std.mem;
8	const BufMap = std.BufMap;
9	const cstr = std.cstr;
10
11	pub const WaitError = error{
12	WaitAbandoned,
13	WaitTimeOut,
14	Unexpected,
15	};
16
17	pub fn windowsWaitSingle(handle: windows.HANDLE, milliseconds: windows.DWORD) WaitError!void {
18	const result = windows.WaitForSingleObject(handle, milliseconds);
19	return switch (result) {
20	windows.WAIT_ABANDONED => error.WaitAbandoned,
21	windows.WAIT_OBJECT_0 => {},
22	windows.WAIT_TIMEOUT => error.WaitTimeOut,
23	windows.WAIT_FAILED => x: {
24	const err = windows.GetLastError();
25	break :x switch (err) {
26	else => os.unexpectedErrorWindows(err),
27	};
28	},
29	else => error.Unexpected,
30	};
31	}
32
33	/// Caller must free result.
34	pub fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: const BufMap) ![]u16 {
35	// count bytes needed
36	const max_chars_needed = x: {
37	var max_chars_needed: usize = 4; // 4 for the final 4 null bytes
38	var it = env_map.iterator();
39	while (it.next()) \|pair\| {
40	// +1 for '='
41	// +1 for null byte
42	max_chars_needed += pair.key.len + pair.value.len + 2;
43	}
44	break :x max_chars_needed;
45	};
46	const result = try allocator.alloc(u16, max_chars_needed);
47	errdefer allocator.free(result);
48
49	var it = env_map.iterator();
50	var i: usize = 0;
51	while (it.next()) \|pair\| {
52	i += try unicode.utf8ToUtf16Le(result[i..], pair.key);
53	result[i] = '=';
54	i += 1;
55	i += try unicode.utf8ToUtf16Le(result[i..], pair.value);
56	result[i] = 0;
57	i += 1;
58	}
59	result[i] = 0;
60	i += 1;
61	result[i] = 0;
62	i += 1;
63	result[i] = 0;
64	i += 1;
65	result[i] = 0;
66	i += 1;
67	return allocator.shrink(result, i);
68	}
69
70	pub fn windowsFindFirstFile(
71	dir_path: []const u8,
72	find_file_data: *windows.WIN32_FIND_DATAW,
73	) !windows.HANDLE {
74	const dir_path_w = try sliceToPrefixedSuffixedFileW(dir_path, []u16{ '\\', '*', 0 });
75	const handle = windows.FindFirstFileW(&dir_path_w, find_file_data);
76
77	if (handle == windows.INVALID_HANDLE_VALUE) {
78	const err = windows.GetLastError();
79	switch (err) {
80	windows.ERROR.FILE_NOT_FOUND => return error.FileNotFound,
81	windows.ERROR.PATH_NOT_FOUND => return error.FileNotFound,
82	else => return os.unexpectedErrorWindows(err),
83	}
84	}
85
86	return handle;
87	}
88
89	/// Returns `true` if there was another file, `false` otherwise.
90	pub fn windowsFindNextFile(handle: windows.HANDLE, find_file_data: *windows.WIN32_FIND_DATAW) !bool {
91	if (windows.FindNextFileW(handle, find_file_data) == 0) {
92	const err = windows.GetLastError();
93	return switch (err) {
94	windows.ERROR.NO_MORE_FILES => false,
95	else => os.unexpectedErrorWindows(err),
96	};
97	}
98	return true;
99	}
100
101	pub const WindowsCreateIoCompletionPortError = error{Unexpected};
102
103	pub fn windowsCreateIoCompletionPort(file_handle: windows.HANDLE, existing_completion_port: ?windows.HANDLE, completion_key: usize, concurrent_thread_count: windows.DWORD) !windows.HANDLE {
104	const handle = windows.CreateIoCompletionPort(file_handle, existing_completion_port, completion_key, concurrent_thread_count) orelse {
105	const err = windows.GetLastError();
106	switch (err) {
107	windows.ERROR.INVALID_PARAMETER => unreachable,
108	else => return os.unexpectedErrorWindows(err),
109	}
110	};
111	return handle;
112	}
113
114	pub const WindowsPostQueuedCompletionStatusError = error{Unexpected};
115
116	pub fn windowsPostQueuedCompletionStatus(completion_port: windows.HANDLE, bytes_transferred_count: windows.DWORD, completion_key: usize, lpOverlapped: ?*windows.OVERLAPPED) WindowsPostQueuedCompletionStatusError!void {
117	if (windows.PostQueuedCompletionStatus(completion_port, bytes_transferred_count, completion_key, lpOverlapped) == 0) {
118	const err = windows.GetLastError();
119	switch (err) {
120	else => return os.unexpectedErrorWindows(err),
121	}
122	}
123	}
124
125	pub const WindowsWaitResult = enum {
126	Normal,
127	Aborted,
128	Cancelled,
129	EOF,
130	};
131
132	pub fn windowsGetQueuedCompletionStatus(completion_port: windows.HANDLE, bytes_transferred_count: windows.DWORD, lpCompletionKey: usize, lpOverlapped: ?windows.OVERLAPPED, dwMilliseconds: windows.DWORD) WindowsWaitResult {
133	if (windows.GetQueuedCompletionStatus(completion_port, bytes_transferred_count, lpCompletionKey, lpOverlapped, dwMilliseconds) == windows.FALSE) {
134	const err = windows.GetLastError();
135	switch (err) {
136	windows.ERROR.ABANDONED_WAIT_0 => return WindowsWaitResult.Aborted,
137	windows.ERROR.OPERATION_ABORTED => return WindowsWaitResult.Cancelled,
138	windows.ERROR.HANDLE_EOF => return WindowsWaitResult.EOF,
139	else => {
140	if (std.debug.runtime_safety) {
141	std.debug.panic("unexpected error: {}\n", err);
142	}
143	},
144	}
145	}
146	return WindowsWaitResult.Normal;
147	}