srctree

"${CMAKE_SOURCE_DIR}/lib/std/os/linux/errno/generic.zig"

std.os.exit(1);

var iovec = [_]std.os.iovec_const{.{ .iov_base = data.data.ptr, .iov_len = data.data.len }};

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

const os = std.os;

pub const use_pthreads = target.os.tag != .windows and target.os.tag != .wasi and builtin.link_libc;

const Impl = if (target.os.tag == .windows)

else if (target.os.tag == .linux)

else if (target.os.tag == .wasi)

pub const max_name_len = switch (target.os.tag) {

} || os.PrctlError || os.WriteError || std.fs.File.OpenError || std.fmt.BufPrintError;

switch (target.os.tag) {

const err = try os.prctl(.SET_NAME, .{@intFromPtr(name_with_terminator.ptr)});

switch (@as(os.E, @enumFromInt(err))) {

else => |e| return os.unexpectedErrno(e),

else => |e| return os.unexpectedErrno(e),

const unicode_string = os.windows.UNICODE_STRING{

switch (os.windows.ntdll.NtSetInformationThread(

@sizeOf(os.windows.UNICODE_STRING),

else => |err| return os.windows.unexpectedStatus(err),

else => |e| return os.unexpectedErrno(e),

else => |e| return os.unexpectedErrno(e),

else => |e| return os.unexpectedErrno(e),

} || os.PrctlError || os.ReadError || std.fs.File.OpenError || std.fmt.BufPrintError;

switch (target.os.tag) {

const err = try os.prctl(.GET_NAME, .{@intFromPtr(buffer.ptr)});

switch (@as(os.E, @enumFromInt(err))) {

else => |e| return os.unexpectedErrno(e),

else => |e| return os.unexpectedErrno(e),

const buf_capacity = @sizeOf(os.windows.UNICODE_STRING) + (@sizeOf(u16) * max_name_len);

var buf: [buf_capacity]u8 align(@alignOf(os.windows.UNICODE_STRING)) = undefined;

switch (os.windows.ntdll.NtQueryInformationThread(

const string = @as(*const os.windows.UNICODE_STRING, @ptrCast(&buf));

else => |err| return os.windows.unexpectedStatus(err),

else => |e| return os.unexpectedErrno(e),

else => |e| return os.unexpectedErrno(e),

else => |e| return os.unexpectedErrno(e),

pub const Id = switch (target.os.tag) {

.windows => os.windows.DWORD,

if (builtin.os.tag == .windows) {

_ = os.windows.kernel32.SwitchToThread();

switch (os.errno(os.system.sched_yield())) {

WindowsThreadImpl => std.os.windows.DWORD,

@compileError("Unsupported operating system " ++ @tagName(target.os.tag));

const windows = os.windows;

 

switch (target.os.tag) {

switch (target.os.tag) {

const mib = [_]c_int{ os.CTL.HW, os.system.HW.NCPUONLINE };

os.sysctl(&mib, &count, &count_size, null, 0) catch |err| switch (err) {

const rc = c.sysconf(os._SC.NPROCESSORS_ONLN);

return switch (os.errno(rc)) {

else => |err| os.unexpectedErrno(err),

var system_info: os.system.system_info = undefined;

const rc = os.system.get_system_info(&system_info); // always returns B_OK

return switch (os.errno(rc)) {

else => |err| os.unexpectedErrno(err),

os.sysctlbynameZ(name, &count, &count_len, null, 0) catch |err| switch (err) {

else => |err| return os.unexpectedErrno(err),

const linux = os.linux;

const cpu_set = try os.sched_getaffinity(0);

return @as(usize, os.CPU_COUNT(cpu_set));

const mapped = os.mmap(

os.PROT.NONE,

errdefer os.munmap(mapped);

os.mprotect(

os.PROT.READ | os.PROT.WRITE,

var tls_ptr = os.linux.tls.prepareTLS(mapped[tls_offset..]);

var user_desc: if (target.cpu.arch == .x86) os.linux.user_desc else void = undefined;

.entry_number = os.linux.tls.tls_image.gdt_entry_number,

switch (linux.getErrno(linux.clone(

else => |err| return os.unexpectedErrno(err),

defer os.munmap(self.thread.mapped);

switch (linux.getErrno(linux.futex_wait(

switch (target.os.tag) {

switch (target.os.tag) {

//! Futex is a mechanism used to block (`wait`) and unblock (`wake`) threads using a 32bit memory address as hints.

//! Blocking a thread is acknowledged only if the 32bit memory address is equal to a given value.

//! This check helps avoid block/unblock deadlocks which occur if a `wake()` happens before a `wait()`.

//! Using Futex, other Thread synchronization primitives can be built which efficiently wait for cross-thread events or signals.

const os = std.os;

var timeout_value: os.windows.LARGE_INTEGER = undefined;

var timeout_ptr: ?*const os.windows.LARGE_INTEGER = null;

timeout_value = @as(os.windows.LARGE_INTEGER, @intCast(delay / 100));

const rc = os.windows.ntdll.RtlWaitOnAddress(

1 => os.windows.ntdll.RtlWakeAddressSingle(address),

else => os.windows.ntdll.RtlWakeAddressAll(address),

const flags = os.darwin.UL_COMPARE_AND_WAIT | os.darwin.ULF_NO_ERRNO;

break :blk os.darwin.__ulock_wait2(flags, addr, expect, timeout_ns, 0);

break :blk os.darwin.__ulock_wait(flags, addr, expect, timeout_us);

switch (@as(std.os.E, @enumFromInt(-status))) {

var flags: u32 = os.darwin.UL_COMPARE_AND_WAIT | os.darwin.ULF_NO_ERRNO;

flags |= os.darwin.ULF_WAKE_ALL;

const status = os.darwin.__ulock_wake(flags, addr, 0);

switch (@as(std.os.E, @enumFromInt(-status))) {

var ts: os.timespec = undefined;

const rc = os.linux.futex_wait(

os.linux.FUTEX.PRIVATE_FLAG | os.linux.FUTEX.WAIT,

switch (os.linux.getErrno(rc)) {

const rc = os.linux.futex_wake(

os.linux.FUTEX.PRIVATE_FLAG | os.linux.FUTEX.WAKE,

switch (os.linux.getErrno(rc)) {

var tm: os.freebsd._umtx_time = undefined;

var tm_ptr: ?*const os.freebsd._umtx_time = null;

tm._clockid = os.CLOCK.MONOTONIC;

const rc = os.freebsd._umtx_op(

@intFromEnum(os.freebsd.UMTX_OP.WAIT_UINT_PRIVATE),

switch (os.errno(rc)) {

const rc = os.freebsd._umtx_op(

@intFromEnum(os.freebsd.UMTX_OP.WAKE_PRIVATE),

switch (os.errno(rc)) {

var ts: os.timespec = undefined;

const rc = os.openbsd.futex(

os.openbsd.FUTEX_WAIT | os.openbsd.FUTEX_PRIVATE_FLAG,

switch (os.errno(rc)) {

const rc = os.openbsd.futex(

os.openbsd.FUTEX_WAKE | os.openbsd.FUTEX_PRIVATE_FLAG,

const rc = os.dragonfly.umtx_sleep(addr, value, timeout_us);

switch (os.errno(rc)) {

_ = os.dragonfly.umtx_wakeup(addr, to_wake);

cond: std.c.pthread_cond_t,

mutex: std.c.pthread_mutex_t,

const rc = std.c.pthread_cond_destroy(&self.cond);

const rm = std.c.pthread_mutex_destroy(&self.mutex);

assert(std.c.pthread_mutex_lock(&self.mutex) == .SUCCESS);

defer assert(std.c.pthread_mutex_unlock(&self.mutex) == .SUCCESS);

var ts: os.timespec = undefined;

os.clock_gettime(os.CLOCK.REALTIME, &ts) catch unreachable;

if (timeout == null) break :blk std.c.pthread_cond_wait(&self.cond, &self.mutex);

break :blk std.c.pthread_cond_timedwait(&self.cond, &self.mutex, &ts);

assert(std.c.pthread_mutex_lock(&self.mutex) == .SUCCESS);

defer assert(std.c.pthread_mutex_unlock(&self.mutex) == .SUCCESS);

assert(std.c.pthread_cond_signal(&self.cond) == .SUCCESS);

mutex: std.c.pthread_mutex_t align(atomic.cache_line) = .{},

assert(std.c.pthread_mutex_lock(&bucket.mutex) == .SUCCESS);

defer assert(std.c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);

assert(std.c.pthread_mutex_lock(&bucket.mutex) == .SUCCESS);

defer assert(std.c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);

assert(std.c.pthread_mutex_lock(&bucket.mutex) == .SUCCESS);

defer assert(std.c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);

const os = std.os;

srwlock: os.windows.SRWLOCK = .{},

return os.windows.kernel32.TryAcquireSRWLockExclusive(&self.srwlock) != os.windows.FALSE;

os.windows.kernel32.AcquireSRWLockExclusive(&self.srwlock);

os.windows.kernel32.ReleaseSRWLockExclusive(&self.srwlock);

oul: os.darwin.os_unfair_lock = .{},

return os.darwin.os_unfair_lock_trylock(&self.oul);

os.darwin.os_unfair_lock_lock(&self.oul);

os.darwin.os_unfair_lock_unlock(&self.oul);

std.os.abort();

std.os.abort();

.cuda, .amdhsa => std.os.abort(),

const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

.linux => std.os.linux.AT,

.linux => std.os.linux.O,

ACCMODE: std.os.ACCMODE = .RDONLY,

ACCMODE: std.os.ACCMODE = .RDONLY,

ACCMODE: std.os.ACCMODE = .RDONLY,

ACCMODE: std.os.ACCMODE = .RDONLY,

ACCMODE: std.os.ACCMODE = .RDONLY,

ACCMODE: std.os.ACCMODE = .RDONLY,

ACCMODE: std.os.ACCMODE = .RDONLY,

ACCMODE: std.os.ACCMODE = .RDONLY,

.linux => std.os.linux.MAP,

.linux => std.os.linux.V,

.linux => std.os.linux.NCCS,

.linux => std.os.linux.termios,

.linux => std.os.linux.tc_iflag_t,

.linux => std.os.linux.tc_oflag_t,

.linux => std.os.linux.CSIZE,

.linux => std.os.linux.tc_cflag_t,

.linux => std.os.linux.tc_lflag_t,

.linux => std.os.linux.speed_t,

pub fn getErrno(rc: anytype) c.E {

if (rc == -1) {

return @enumFromInt(c._errno().*);

} else {

return .SUCCESS;

}

}

 

std.os.linux.getcontext

extern fn getcontext(ucp: *std.os.ucontext_t) c_int;

const iovec_const = std.os.iovec_const;

pub const PosixSpawn = struct {

const errno = std.os.errno;

const unexpectedErrno = std.os.unexpectedErrno;

 

pub const Error = error{

SystemResources,

InvalidFileDescriptor,

NameTooLong,

TooBig,

PermissionDenied,

InputOutput,

FileSystem,

FileNotFound,

InvalidExe,

NotDir,

FileBusy,

/// Returned when the child fails to execute either in the pre-exec() initialization step, or

/// when exec(3) is invoked.

ChildExecFailed,

} || std.os.UnexpectedError;

 

pub const Attr = struct {

attr: posix_spawnattr_t,

 

pub fn init() Error!Attr {

var attr: posix_spawnattr_t = undefined;

switch (errno(posix_spawnattr_init(&attr))) {

.SUCCESS => return Attr{ .attr = attr },

.NOMEM => return error.SystemResources,

.INVAL => unreachable,

else => |err| return unexpectedErrno(err),

}

}

 

pub fn deinit(self: *Attr) void {

defer self.* = undefined;

switch (errno(posix_spawnattr_destroy(&self.attr))) {

.SUCCESS => return,

.INVAL => unreachable, // Invalid parameters.

else => unreachable,

}

}

 

pub fn get(self: Attr) Error!u16 {

var flags: c_short = undefined;

switch (errno(posix_spawnattr_getflags(&self.attr, &flags))) {

.SUCCESS => return @as(u16, @bitCast(flags)),

.INVAL => unreachable,

else => |err| return unexpectedErrno(err),

}

}

 

pub fn set(self: *Attr, flags: u16) Error!void {

switch (errno(posix_spawnattr_setflags(&self.attr, @as(c_short, @bitCast(flags))))) {

.SUCCESS => return,

.INVAL => unreachable,

else => |err| return unexpectedErrno(err),

}

}

};

 

pub const Actions = struct {

actions: posix_spawn_file_actions_t,

 

pub fn init() Error!Actions {

var actions: posix_spawn_file_actions_t = undefined;

switch (errno(posix_spawn_file_actions_init(&actions))) {

.SUCCESS => return Actions{ .actions = actions },

.NOMEM => return error.SystemResources,

.INVAL => unreachable,

else => |err| return unexpectedErrno(err),

}

}

 

pub fn deinit(self: *Actions) void {

defer self.* = undefined;

switch (errno(posix_spawn_file_actions_destroy(&self.actions))) {

.SUCCESS => return,

.INVAL => unreachable, // Invalid parameters.

else => unreachable,

}

}

 

pub fn open(self: *Actions, fd: fd_t, path: []const u8, flags: u32, mode: mode_t) Error!void {

const posix_path = try std.os.toPosixPath(path);

return self.openZ(fd, &posix_path, flags, mode);

}

 

pub fn openZ(self: *Actions, fd: fd_t, path: [*:0]const u8, flags: u32, mode: mode_t) Error!void {

switch (errno(posix_spawn_file_actions_addopen(&self.actions, fd, path, @as(c_int, @bitCast(flags)), mode))) {

.SUCCESS => return,

.BADF => return error.InvalidFileDescriptor,

.NOMEM => return error.SystemResources,

.NAMETOOLONG => return error.NameTooLong,

.INVAL => unreachable, // the value of file actions is invalid

else => |err| return unexpectedErrno(err),

}

}

 

pub fn close(self: *Actions, fd: fd_t) Error!void {

switch (errno(posix_spawn_file_actions_addclose(&self.actions, fd))) {

.SUCCESS => return,

.BADF => return error.InvalidFileDescriptor,

.NOMEM => return error.SystemResources,

.INVAL => unreachable, // the value of file actions is invalid

.NAMETOOLONG => unreachable,

else => |err| return unexpectedErrno(err),

}

}

 

pub fn dup2(self: *Actions, fd: fd_t, newfd: fd_t) Error!void {

switch (errno(posix_spawn_file_actions_adddup2(&self.actions, fd, newfd))) {

.SUCCESS => return,

.BADF => return error.InvalidFileDescriptor,

.NOMEM => return error.SystemResources,

.INVAL => unreachable, // the value of file actions is invalid

.NAMETOOLONG => unreachable,

else => |err| return unexpectedErrno(err),

}

}

 

pub fn inherit(self: *Actions, fd: fd_t) Error!void {

switch (errno(posix_spawn_file_actions_addinherit_np(&self.actions, fd))) {

.SUCCESS => return,

.BADF => return error.InvalidFileDescriptor,

.NOMEM => return error.SystemResources,

.INVAL => unreachable, // the value of file actions is invalid

.NAMETOOLONG => unreachable,

else => |err| return unexpectedErrno(err),

}

}

 

pub fn chdir(self: *Actions, path: []const u8) Error!void {

const posix_path = try std.os.toPosixPath(path);

return self.chdirZ(&posix_path);

}

 

pub fn chdirZ(self: *Actions, path: [*:0]const u8) Error!void {

switch (errno(posix_spawn_file_actions_addchdir_np(&self.actions, path))) {

.SUCCESS => return,

.NOMEM => return error.SystemResources,

.NAMETOOLONG => return error.NameTooLong,

.BADF => unreachable,

.INVAL => unreachable, // the value of file actions is invalid

else => |err| return unexpectedErrno(err),

}

}

 

pub fn fchdir(self: *Actions, fd: fd_t) Error!void {

switch (errno(posix_spawn_file_actions_addfchdir_np(&self.actions, fd))) {

.SUCCESS => return,

.BADF => return error.InvalidFileDescriptor,

.NOMEM => return error.SystemResources,

.INVAL => unreachable, // the value of file actions is invalid

.NAMETOOLONG => unreachable,

else => |err| return unexpectedErrno(err),

}

}

};

 

pub fn spawn(

path: []const u8,

actions: ?Actions,

attr: ?Attr,

argv: [*:null]?[*:0]const u8,

envp: [*:null]?[*:0]const u8,

) Error!pid_t {

const posix_path = try std.os.toPosixPath(path);

return spawnZ(&posix_path, actions, attr, argv, envp);

}

 

pub fn spawnZ(

path: [*:0]const u8,

actions: ?Actions,

attr: ?Attr,

argv: [*:null]?[*:0]const u8,

envp: [*:null]?[*:0]const u8,

) Error!pid_t {

var pid: pid_t = undefined;

switch (errno(posix_spawn(

&pid,

path,

if (actions) |a| &a.actions else null,

if (attr) |a| &a.attr else null,

argv,

envp,

))) {

.SUCCESS => return pid,

.@"2BIG" => return error.TooBig,

.NOMEM => return error.SystemResources,

.BADF => return error.InvalidFileDescriptor,

.ACCES => return error.PermissionDenied,

.IO => return error.InputOutput,

.LOOP => return error.FileSystem,

.NAMETOOLONG => return error.NameTooLong,

.NOENT => return error.FileNotFound,

.NOEXEC => return error.InvalidExe,

.NOTDIR => return error.NotDir,

.TXTBSY => return error.FileBusy,

.BADARCH => return error.InvalidExe,

.BADEXEC => return error.InvalidExe,

.FAULT => unreachable,

.INVAL => unreachable,

else => |err| return unexpectedErrno(err),

}

}

 

pub fn waitpid(pid: pid_t, flags: u32) Error!std.os.WaitPidResult {

var status: c_int = undefined;

while (true) {

const rc = waitpid(pid, &status, @as(c_int, @intCast(flags)));

switch (errno(rc)) {

.SUCCESS => return std.os.WaitPidResult{

.pid = @as(pid_t, @intCast(rc)),

.status = @as(u32, @bitCast(status)),

},

.INTR => continue,

.CHILD => return error.ChildExecFailed,

.INVAL => unreachable, // Invalid flags.

else => unreachable,

}

}

}

};

 

pub fn unexpectedKernError(err: KernE) std.os.UnexpectedError {

if (std.os.unexpected_error_tracing) {

} || std.os.UnexpectedError;

pub fn pidForTask(self: MachTask) MachError!std.os.pid_t {

var pid: std.os.pid_t = undefined;

pub fn machTaskForPid(pid: std.os.pid_t) MachError!MachTask {

const iovec = std.os.iovec;

const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

const os = std.os;

const windows = os.windows;

const linux = os.linux;

pub const Id = switch (builtin.os.tag) {

else => os.pid_t,

thread_handle: if (builtin.os.tag == .windows) windows.HANDLE else void,

uid: if (builtin.os.tag == .windows or builtin.os.tag == .wasi) void else ?os.uid_t,

gid: if (builtin.os.tag == .windows or builtin.os.tag == .wasi) void else ?os.gid_t,

err_pipe: ?if (builtin.os.tag == .windows) void else [2]os.fd_t,

switch (builtin.os.tag) {

const rusage_init = switch (builtin.os.tag) {

.linux, .macos, .ios => @as(?std.os.rusage, null),

pub const Arg0Expand = os.Arg0Expand;

os.ExecveError ||

os.SetIdError ||

os.ChangeCurDirError ||

.uid = if (builtin.os.tag == .windows or builtin.os.tag == .wasi) {} else null,

.gid = if (builtin.os.tag == .windows or builtin.os.tag == .wasi) {} else null,

if (builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

os.kill(self.id, os.SIG.TERM) catch |err| switch (err) {

const term = if (builtin.os.tag == .windows)

pub const RunError = os.GetCwdError || os.ReadError || SpawnError || os.PollError || error{

os.close(self.id);

os.close(self.thread_handle);

const res: os.WaitPidResult = res: {

switch (builtin.os.tag) {

var ru: std.os.rusage = undefined;

const res = os.wait4(self.id, 0, &ru);

break :res os.waitpid(self.id, 0);

if (builtin.os.tag == .linux) {

var fd = [1]std.os.pollfd{std.os.pollfd{

.events = std.os.POLL.IN,

_ = std.os.poll(&fd, 0) catch unreachable;

if ((fd[0].revents & std.os.POLL.IN) != 0) {

return if (os.W.IFEXITED(status))

Term{ .Exited = os.W.EXITSTATUS(status) }

else if (os.W.IFSIGNALED(status))

Term{ .Signal = os.W.TERMSIG(status) }

else if (os.W.IFSTOPPED(status))

Term{ .Stopped = os.W.STOPSIG(status) }

const pipe_flags: os.O = .{};

const stdin_pipe = if (self.stdin_behavior == StdIo.Pipe) try os.pipe2(pipe_flags) else undefined;

const stdout_pipe = if (self.stdout_behavior == StdIo.Pipe) try os.pipe2(pipe_flags) else undefined;

const stderr_pipe = if (self.stderr_behavior == StdIo.Pipe) try os.pipe2(pipe_flags) else undefined;

os.openZ("/dev/null", .{ .ACCMODE = .RDWR }, 0) catch |err| switch (err) {

if (any_ignore) os.close(dev_null_fd);

break :m @as([*:null]const ?[*:0]const u8, @ptrCast(os.environ.ptr));

if (builtin.os.tag == .linux) {

const fd = try os.eventfd(0, linux.EFD.CLOEXEC);

break :blk [2]os.fd_t{ fd, fd };

break :blk try os.pipe2(.{ .CLOEXEC = true });

const pid_result = try os.fork();

setUpChildIo(self.stdin_behavior, stdin_pipe[0], os.STDIN_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);

setUpChildIo(self.stdout_behavior, stdout_pipe[1], os.STDOUT_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);

setUpChildIo(self.stderr_behavior, stderr_pipe[1], os.STDERR_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);

os.close(stdin_pipe[0]);

os.close(stdin_pipe[1]);

os.close(stdout_pipe[0]);

os.close(stdout_pipe[1]);

os.close(stderr_pipe[0]);

os.close(stderr_pipe[1]);

os.fchdir(cwd.fd) catch |err| forkChildErrReport(err_pipe[1], err);

os.chdir(cwd) catch |err| forkChildErrReport(err_pipe[1], err);

os.setregid(gid, gid) catch |err| forkChildErrReport(err_pipe[1], err);

os.setreuid(uid, uid) catch |err| forkChildErrReport(err_pipe[1], err);

.expand => os.execvpeZ_expandArg0(.expand, argv_buf.ptr[0].?, argv_buf.ptr, envp),

.no_expand => os.execvpeZ_expandArg0(.no_expand, argv_buf.ptr[0].?, argv_buf.ptr, envp),

const pid = @as(i32, @intCast(pid_result));

os.close(stdin_pipe[0]);

os.close(stdout_pipe[1]);

os.close(stderr_pipe[1]);

if (any_ignore) os.close(nul_handle);

const PATH: [:0]const u16 = std.os.getenvW(unicode.utf8ToUtf16LeStringLiteral("PATH")) orelse &[_:0]u16{};

const PATHEXT: [:0]const u16 = std.os.getenvW(unicode.utf8ToUtf16LeStringLiteral("PATHEXT")) orelse &[_:0]u16{};

os.close(g_hChildStd_IN_Rd.?);

os.close(g_hChildStd_ERR_Wr.?);

os.close(g_hChildStd_OUT_Wr.?);

.Pipe => try os.dup2(pipe_fd, std_fileno),

.Close => os.close(std_fileno),

.Ignore => try os.dup2(dev_null_fd, std_fileno),

var file_information_buf: [2048]u8 align(@alignOf(os.windows.FILE_DIRECTORY_INFORMATION)) = undefined;

if (rd) |h| os.close(h);

if (wr) |h| os.close(h);

errdefer os.close(read_handle);

errdefer os.close(write_handle);

fn destroyPipe(pipe: [2]os.fd_t) void {

os.close(pipe[0]);

if (pipe[0] != pipe[1]) os.close(pipe[1]);

os.exit(1);

const RescanWindowsError = Allocator.Error || ParseCertError || std.os.UnexpectedError || error{FileNotFound};

if (@as(std.os.darwin.cssm.DB_RECORDTYPE, @enumFromInt(table_header.table_id)) != .X509_CERTIFICATE) {

const os = std.os;

const os_has_fork = switch (builtin.os.tag) {

const is_haiku = builtin.os.tag == .haiku;

wipe_mem = os.mmap(

os.PROT.READ | os.PROT.WRITE,

if (os.madvise(wipe_mem.ptr, 0, 0xffffffff)) |_| {

if (os.madvise(wipe_mem.ptr, wipe_mem.len, os.MADV.WIPEONFORK)) |_| {

os.getrandom(buffer) catch @panic("getrandom() failed to provide entropy");

pub fn readv(this: @This(), iovecs: []std.os.iovec) ReadError!usize {

pub fn writev(this: @This(), iovecs: []const std.os.iovec_const) WriteError!usize {

pub fn writevAll(this: @This(), iovecs: []std.os.iovec_const) WriteError!usize {

var iovecs = [_]std.os.iovec_const{

var both_msgs_vec = [_]std.os.iovec_const{.{

var iovecs_buf: [6]std.os.iovec_const = undefined;

iovecs: []std.os.iovec_const,

var iovecs = [1]std.os.iovec{.{ .iov_base = buffer.ptr, .iov_len = buffer.len }};

pub fn readv(c: *Client, stream: anytype, iovecs: []std.os.iovec) !usize {

pub fn readvAtLeast(c: *Client, stream: anytype, iovecs: []std.os.iovec, len: usize) !usize {

pub fn readvAdvanced(c: *Client, stream: anytype, iovecs: []const std.os.iovec) !usize {

var ask_iovecs_buf: [2]std.os.iovec = .{

iovecs: []const std.os.iovec,

fn limitVecs(iovecs: []std.os.iovec, len: usize) []std.os.iovec {

const os = std.os;

=> builtin.os.tag == .emscripten,

pub const have_ucontext = @hasDecl(os.system, "ucontext_t") and

(builtin.os.tag != .linux or switch (builtin.cpu.arch) {

break :blk std.os.windows.CONTEXT;

break :blk os.ucontext_t;

pub const have_getcontext = @hasDecl(os.system, "getcontext") and

builtin.os.tag != .openbsd and

(builtin.os.tag != .linux or switch (builtin.cpu.arch) {

const result = have_getcontext and os.system.getcontext(context) == 0;

stderr.print("panic: ", .{}) catch os.abort();

stderr.print("thread {} panic: ", .{current_thread_id}) catch os.abort();

stderr.print("{s}\n", .{msg}) catch os.abort();

stderr.print("Panicked during a panic. Aborting.\n", .{}) catch os.abort();

os.abort();

pub fn initWithContext(first_address: ?usize, debug_info: *DebugInfo, context: *const os.ucontext_t) !StackIterator {

const w = os.windows;

var memory_info: w.MEMORY_BASIC_INFORMATION = undefined;

const rc = w.VirtualQuery(aligned_memory, &memory_info, aligned_memory.len) catch {

if (memory_info.State == w.MEM_FREE) {

} else if (@hasDecl(os.system, "msync") and native_os != .wasi and native_os != .emscripten) {

os.msync(aligned_memory, os.MSF.ASYNC) catch |err| {

os.MSyncError.UnmappedMemory => {

return false;

},

const cwd_path = os.realpath(".", &cwd_buf) catch break :blk;

const mapped_mem = try os.mmap(

os.PROT.READ,

errdefer os.munmap(mapped_mem);

if (os.dl_iterate_phdr(&ctx, error{Found}, struct {

fn callback(info: *os.dl_phdr_info, size: usize, context: *CtxTy) !void {

if (os.dl_iterate_phdr(&ctx, error{Found}, struct {

fn callback(info: *os.dl_phdr_info, size: usize, context: *CtxTy) !void {

os.munmap(self.mapped_memory);

os.munmap(self.mapped_memory);

if (self.external_mapped_memory) |m| os.munmap(m);

.freebsd, .openbsd => @hasDecl(os.system, "ucontext_t"),

pub fn updateSegfaultHandler(act: ?*const os.Sigaction) error{OperationNotSupported}!void {

try os.sigaction(os.SIG.SEGV, act, null);

try os.sigaction(os.SIG.ILL, act, null);

try os.sigaction(os.SIG.BUS, act, null);

try os.sigaction(os.SIG.FPE, act, null);

var act = os.Sigaction{

.mask = os.empty_sigset,

.flags = (os.SA.SIGINFO | os.SA.RESTART | os.SA.RESETHAND),

var act = os.Sigaction{

.handler = .{ .handler = os.SIG.DFL },

.mask = os.empty_sigset,

fn handleSegfaultPosix(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const anyopaque) callconv(.C) noreturn {

os.abort();

os.SIG.SEGV => if (native_arch == .x86_64 and native_os == .linux and code == 128) // SI_KERNEL

os.SIG.ILL => stderr.print("Illegal instruction at address 0x{x}\n", .{addr}),

os.SIG.BUS => stderr.print("Bus error at address 0x{x}\n", .{addr}),

os.SIG.FPE => stderr.print("Arithmetic exception at address 0x{x}\n", .{addr}),

} catch os.abort();

const ctx: *const os.ucontext_t = @ptrCast(@alignCast(ctx_ptr));

os.abort();

} catch os.abort();

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .windows) {

//std.os.abort(); // can be handy to uncomment when working on this file

//std.os.abort(); // can be handy to uncomment when working on this file

const os = std.os;

if (builtin.os.tag == .windows) {

.x86 => switch (builtin.os.tag) {

0 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EAX]),

1 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ECX]),

2 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EDX]),

3 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EBX]),

mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EBP])

mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ESP]);

mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ESP])

mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EBP]);

6 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ESI]),

7 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EDI]),

8 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EIP]),

9 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EFL]),

10 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.CS]),

11 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.SS]),

12 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.DS]),

13 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ES]),

14 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.FS]),

15 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.GS]),

.x86_64 => switch (builtin.os.tag) {

0 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RAX]),

1 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RDX]),

2 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RCX]),

3 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RBX]),

4 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RSI]),

5 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RDI]),

6 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RBP]),

7 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RSP]),

8 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R8]),

9 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R9]),

10 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R10]),

11 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R11]),

12 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R12]),

13 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R13]),

14 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R14]),

15 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R15]),

16 => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RIP]),

17...32 => |i| if (builtin.os.tag.isSolarish())

.arm => switch (builtin.os.tag) {

.aarch64 => switch (builtin.os.tag) {

const os = std.os;

const system = std.os.system;

const InnerType = switch (builtin.os.tag) {

hashtab: [*]os.Elf_Symndx,

} || os.OpenError || os.MMapError;

const fd = try os.open(path, .{ .ACCMODE = .RDONLY, .CLOEXEC = true }, 0);

defer os.close(fd);

const stat = try os.fstat(fd);

const file_bytes = try os.mmap(

os.PROT.READ,

defer os.munmap(file_bytes);

const all_loaded_mem = try os.mmap(

os.PROT.NONE,

errdefer os.munmap(all_loaded_mem);

_ = try os.mmap(

const sect_mem = try os.mmap(

var maybe_hashtab: ?[*]os.Elf_Symndx = null;

elf.DT_HASH => maybe_hashtab = @as([*]os.Elf_Symndx, @ptrFromInt(p)),

os.munmap(self.memory);

var result: u32 = os.PROT.NONE;

if ((elf_prot & elf.PF_R) != 0) result |= os.PROT.READ;

if ((elf_prot & elf.PF_W) != 0) result |= os.PROT.WRITE;

if ((elf_prot & elf.PF_X) != 0) result |= os.PROT.EXEC;

if (builtin.os.tag != .linux) {

const path_c = try os.toPosixPath(path);

.handle = system.dlopen(path_c, system.RTLD.LAZY) orelse {

switch (std.os.errno(system.dlclose(self.handle))) {

if (@call(.never_tail, system.dlsym, .{ self.handle, name.ptr })) |symbol| {

return mem.span(system.dlerror());

const libname = switch (builtin.os.tag) {

const os = std.os;

const is_darwin = builtin.os.tag.isDarwin();

pub const has_executable_bit = switch (builtin.os.tag) {

pub const realpath = os.realpath;

pub const realpathZ = os.realpathZ;

pub const realpathW = os.realpathW;

/// This represents the maximum size of a `[]u8` file path that the

/// operating system will accept. Paths, including those returned from file

/// system operations, may be longer than this length, but such paths cannot

/// be successfully passed back in other file system operations. However,

/// all path components returned by file system operations are assumed to

/// fit into a `u8` array of this length.

/// On Windows, `[]u8` file paths are encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).

/// On WASI, `[]u8` file paths are encoded as valid UTF-8.

/// On other platforms, `[]u8` file paths are opaque sequences of bytes with no particular encoding.

pub const MAX_PATH_BYTES = switch (builtin.os.tag) {

.linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .haiku, .solaris, .illumos, .plan9, .emscripten => os.PATH_MAX,

.windows => os.windows.PATH_MAX_WIDE * 3 + 1,

// TODO work out what a reasonable value we should use here

.wasi => 4096,

@compileError("PATH_MAX not implemented for " ++ @tagName(builtin.os.tag)),

pub const MAX_NAME_BYTES = switch (builtin.os.tag) {

.linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .solaris, .illumos => os.NAME_MAX,

.haiku => os.NAME_MAX - 1,

.windows => os.windows.NAME_MAX * 3,

.wasi => os.windows.NAME_MAX * 3,

@compileError("NAME_MAX not implemented for " ++ @tagName(builtin.os.tag)),

return os.mkdir(absolute_path, Dir.default_mode);

return os.mkdirZ(absolute_path_z, Dir.default_mode);

return os.mkdirW(absolute_path_w, Dir.default_mode);

return os.rmdir(dir_path);

return os.rmdirZ(dir_path);

return os.rmdirW(dir_path);

return os.rename(old_path, new_path);

return os.renameZ(old_path, new_path);

return os.renameW(old_path, new_path);

return os.renameat(old_dir.fd, old_sub_path, new_dir.fd, new_sub_path);

return os.renameatZ(old_dir.fd, old_sub_path_z, new_dir.fd, new_sub_path_z);

return os.renameatW(old_dir.fd, old_sub_path_w, new_dir.fd, new_sub_path_w);

if (builtin.os.tag == .windows) {

return .{ .fd = os.windows.peb().ProcessParameters.CurrentDirectory.Handle };

} else if (builtin.os.tag == .wasi) {

return .{ .fd = os.AT.FDCWD };

return os.readlink(pathname, buffer);

return os.readlinkW(pathname_w, buffer);

return os.readlinkZ(pathname_c, buffer);

if (builtin.os.tag == .windows) {

const target_path_w = try os.windows.sliceToPrefixedFileW(null, target_path);

const sym_link_path_w = try os.windows.sliceToPrefixedFileW(null, sym_link_path);

return os.windows.CreateSymbolicLink(null, sym_link_path_w.span(), target_path_w.span(), flags.is_directory);

return os.symlink(target_path, sym_link_path);

return os.windows.CreateSymbolicLink(null, sym_link_path_w, target_path_w, flags.is_directory);

if (builtin.os.tag == .windows) {

const target_path_w = try os.windows.cStrToPrefixedFileW(null, target_path_c);

const sym_link_path_w = try os.windows.cStrToPrefixedFileW(null, sym_link_path_c);

return os.windows.CreateSymbolicLink(null, sym_link_path_w.span(), target_path_w.span(), flags.is_directory);

return os.symlinkZ(target_path_c, sym_link_path_c);

pub const OpenSelfExeError = os.OpenError || SelfExePathError || os.FlockError;

if (builtin.os.tag == .linux) {

if (builtin.os.tag == .windows) {

const image_path_unicode_string = &os.windows.peb().ProcessParameters.ImagePathName;

const prefixed_path_w = try os.windows.wToPrefixedFileW(null, image_path_name);

// This is os.ReadLinkError || os.RealPathError with impossible errors excluded

} || os.SysCtlError;

const real_path = std.os.realpathZ(&symlink_path_buf, &real_path_buf) catch |err| switch (err) {

switch (builtin.os.tag) {

.linux => return os.readlinkZ("/proc/self/exe", out_buffer) catch |err| switch (err) {

.solaris, .illumos => return os.readlinkZ("/proc/self/path/a.out", out_buffer) catch |err| switch (err) {

var mib = [4]c_int{ os.CTL.KERN, os.KERN.PROC, os.KERN.PROC_PATHNAME, -1 };

try os.sysctl(&mib, out_buffer.ptr, &out_len, null, 0);

var mib = [4]c_int{ os.CTL.KERN, os.KERN.PROC_ARGS, -1, os.KERN.PROC_PATHNAME };

try os.sysctl(&mib, out_buffer.ptr, &out_len, null, 0);

if (os.argv.len == 0)

const argv0 = mem.span(os.argv[0]);

const real_path = os.realpathZ(os.argv[0], &real_path_buf) catch |err| switch (err) {

const PATH = std.os.getenvZ("PATH") orelse return error.FileNotFound;

os.argv[0],

if (os.realpathZ(resolved_path, &real_path_buf)) |real_path| {

const image_path_unicode_string = &os.windows.peb().ProcessParameters.ImagePathName;

const pathname_w = try os.windows.wToPrefixedFileW(null, image_path_name);

return allocator.dupe(u8, try os.realpath(pathname, &buf));

if (builtin.os.tag != .wasi) {

// https://github.com/ziglang/zig/issues/5019

const posix = std.os;

pub const Iterator = switch (builtin.os.tag) {

switch (builtin.os.tag) {

const skip_zero_fileno = switch (builtin.os.tag) {

buf: [1024]u8 align(if (builtin.os.tag != .linux) 1 else @alignOf(linux.dirent64)),

switch (linux.getErrno(rc)) {

buf: [1024]u8 align(@alignOf(std.os.windows.FILE_BOTH_DIR_INFORMATION)),

const w = std.os.windows;

switch (builtin.os.tag) {

if (builtin.os.tag == .windows) {

const path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sub_path);

if (builtin.os.tag == .wasi) {

switch (builtin.os.tag) {

const path_w = try std.os.windows.cStrToPrefixedFileW(self.fd, sub_path);

const w = std.os.windows;

if (builtin.os.tag == .windows) {

const path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sub_path);

if (builtin.os.tag == .wasi) {

switch (builtin.os.tag) {

const path_w = try std.os.windows.cStrToPrefixedFileW(self.fd, sub_path_c);

var os_flags: std.os.O = .{

const w = std.os.windows;

const w = std.os.windows;

return switch (builtin.os.tag) {

const w = std.os.windows;

if (builtin.os.tag == .wasi) {

if (builtin.os.tag == .windows) {

const pathname_w = try std.os.windows.sliceToPrefixedFileW(self.fd, pathname);

if (builtin.os.tag == .windows) {

const pathname_w = try posix.windows.cStrToPrefixedFileW(self.fd, pathname);

const flags: posix.O = switch (builtin.os.tag) {

// Use of MAX_PATH_BYTES here is valid as the realpath function does not

// have a variant that takes an arbitrary-size buffer.

// TODO(#4812): Consider reimplementing realpath or using the POSIX.1-2008

// NULL out parameter (GNU's canonicalize_file_name) to handle overelong

// paths. musl supports passing NULL but restricts the output to PATH_MAX

// anyway.

const out_path = try posix.getFdPath(fd, &buffer);

const w = std.os.windows;

if (builtin.os.tag == .wasi) {

if (builtin.os.tag == .windows) {

var dir_path_buffer: [std.os.windows.PATH_MAX_WIDE]u16 = undefined;

const dir_path = try std.os.windows.GetFinalPathNameByHandle(self.fd, .{}, &dir_path_buffer);

return std.os.windows.SetCurrentDirectory(dir_path);

switch (builtin.os.tag) {

const sub_path_w = try posix.windows.sliceToPrefixedFileW(self.fd, sub_path);

switch (builtin.os.tag) {

const sub_path_w = try std.os.windows.cStrToPrefixedFileW(self.fd, sub_path_c);

const w = std.os.windows;

const w = std.os.windows;

if (builtin.os.tag == .windows) {

const sub_path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sub_path);

} else if (builtin.os.tag == .wasi and !builtin.link_libc) {

error.AccessDenied => |e| switch (builtin.os.tag) {

if (builtin.os.tag == .windows) {

const sub_path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sub_path);

} else if (builtin.os.tag == .wasi and !builtin.link_libc) {

if (builtin.os.tag == .wasi and !builtin.link_libc) {

if (builtin.os.tag == .windows) {

var target_path_w: std.os.windows.PathSpace = undefined;

const sym_link_path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sym_link_path);

if (builtin.os.tag == .windows) {

const target_path_w = try std.os.windows.cStrToPrefixedFileW(self.fd, target_path_c);

const sym_link_path_w = try std.os.windows.cStrToPrefixedFileW(self.fd, sym_link_path_c);

return std.os.windows.CreateSymbolicLink(self.fd, sym_link_path_w, target_path_w, flags.is_directory);

if (builtin.os.tag == .wasi and !builtin.link_libc) {

if (builtin.os.tag == .windows) {

const sub_path_w = try std.os.windows.sliceToPrefixedFileW(self.fd, sub_path);

if (builtin.os.tag == .windows) {

const sub_path_w = try std.os.windows.cStrToPrefixedFileW(self.fd, sub_path_c);

return std.os.windows.ReadLink(self.fd, sub_path_w, buffer);

if (builtin.os.tag == .windows) {

const sub_path_w = std.os.windows.sliceToPrefixedFileW(self.fd, sub_path) catch |err| switch (err) {

if (builtin.os.tag == .windows) {

const sub_path_w = std.os.windows.cStrToPrefixedFileW(self.fd, sub_path) catch |err| switch (err) {

return posix.faccessatW(self.fd, sub_path_w, 0, 0);

if (builtin.os.tag == .linux) {

if (builtin.os.tag == .windows) {

if (builtin.os.tag == .wasi and !builtin.link_libc) {

const st = try posix.fstatat_wasi(self.fd, sub_path, .{ .SYMLINK_FOLLOW = true });

// https://github.com/ziglang/zig/issues/5019

const posix = std.os;

return posix.isCygwinPty(self.handle);

const st = try posix.fstat_wasi(self.handle);

.wasi => .{ .stat = try posix.fstat_wasi(self.handle) },

// https://github.com/ziglang/zig/issues/5019

const posix = std.os;

const os = std.os;

switch (builtin.os.tag) {

const home_dir = os.getenv("HOME") orelse {

if (os.getenv("XDG_DATA_HOME")) |xdg| {

const home_dir = os.getenv("HOME") orelse {

const rc = os.system.find_directory(be_user_settings, -1, true, dir_path_ptr, 1);

if (builtin.os.tag == .wasi) return error.SkipZigTest;

const os = std.os;

pub const TransformError = std.os.RealPathError || error{OutOfMemory};

const dir_path = try os.getFdPath(dir.fd, &fd_path_buf);

const dir_path = try os.getFdPath(dir.fd, &fd_path_buf);

const windows_path_type = std.os.windows.getUnprefixedPathType(u8, dir_path);

if (builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

error.AccessDenied => if (builtin.os.tag == .windows) return error.SkipZigTest else return err,

error.AccessDenied => if (builtin.os.tag == .windows) return error.SkipZigTest else return err,

const w = std.os.windows;

 

const sub_path_w = try std.os.windows.cStrToPrefixedFileW(ctx.dir.fd, "symlink");

var nt_name = w.UNICODE_STRING{

var attr = w.OBJECT_ATTRIBUTES{

.Length = @sizeOf(w.OBJECT_ATTRIBUTES),

var io: w.IO_STATUS_BLOCK = undefined;

const rc = w.ntdll.NtCreateFile(

w.STANDARD_RIGHTS_READ | w.FILE_READ_ATTRIBUTES | w.FILE_READ_EA | w.SYNCHRONIZE | w.FILE_TRAVERSE,

w.FILE_ATTRIBUTE_NORMAL,

w.FILE_SHARE_READ | w.FILE_SHARE_WRITE,

w.FILE_OPEN,

w.FILE_OPEN_REPARSE_POINT | w.FILE_DIRECTORY_FILE | w.FILE_SYNCHRONOUS_IO_NONALERT | w.FILE_OPEN_FOR_BACKUP_INTENT,

else => return w.unexpectedStatus(rc),

const sub_path_c = try os.toPosixPath("symlink");

const flags: os.O = .{

const fd = try os.openatZ(ctx.dir.fd, &sub_path_c, flags, 0);

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

switch (builtin.os.tag) {

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .linux) {

if (builtin.os.tag == .freebsd) return error.SkipZigTest;

switch (builtin.os.tag) {

if (builtin.os.tag == .windows) return error.SkipZigTest;

if (builtin.os.tag == .windows) return error.SkipZigTest;

if (builtin.os.tag == .windows) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .windows) return error.SkipZigTest; // Windows returns FileBusy if attempting to remove an open dir

switch (builtin.os.tag) {

if (builtin.os.tag == .windows) {

const maxed_windows_filename = ("\u{FFFF}".*) ** std.os.windows.NAME_MAX;

} else if (builtin.os.tag == .wasi) {

var write_vecs = [_]std.os.iovec_const{

var read_vecs = [_]std.os.iovec{

var write_vecs = [_]std.os.iovec_const{

var read_vecs = [_]std.os.iovec{

var vecs = [_]std.os.iovec_const{

var hdtr = [_]std.os.iovec_const{

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;

if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;

if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;

if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64) {

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .windows or builtin.os.tag == .wasi)

if (builtin.os.tag == .windows or builtin.os.tag == .wasi)

if (builtin.os.tag == .wasi)

if (builtin.os.tag == .windows or builtin.os.tag == .wasi)

if (builtin.os.tag != .windows)

if (builtin.os.tag != .windows) return error.SkipZigTest;

const expected_err = switch (builtin.os.tag) {

if (builtin.os.tag == .wasi) {

if (builtin.os.tag == .wasi) {

if (builtin.os.tag != .wasi) {

if (builtin.os.tag != .wasi and ctx.path_type != .relative) {

const os = std.os;

pub fn find(p: Preopens, name: []const u8) ?os.fd_t {

return @as(os.fd_t, @intCast(i));

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

std.os.exit(1);

const os = std.os;

const HeapHandle = os.windows.HANDLE;

os.windows.HeapDestroy(heap_handle);

const options = if (builtin.single_threaded) os.windows.HEAP_NO_SERIALIZE else 0;

const hh = os.windows.kernel32.HeapCreate(options, amt, 0) orelse return null;

os.windows.HeapDestroy(hh);

const ptr = os.windows.kernel32.HeapAlloc(heap_handle, 0, amt) orelse return null;

const new_ptr = os.windows.kernel32.HeapReAlloc(

os.windows.HEAP_REALLOC_IN_PLACE_ONLY,

os.windows.HeapFree(self.heap_handle.?, 0, @as(*anyopaque, @ptrFromInt(getRecordPtr(buf).*)));

const os = std.os;

if (builtin.os.tag == .windows) {

const w = os.windows;

const addr = w.VirtualAlloc(

w.MEM_COMMIT | w.MEM_RESERVE,

w.PAGE_READWRITE,

const slice = os.mmap(

os.PROT.READ | os.PROT.WRITE,

if (builtin.os.tag == .windows) {

const w = os.windows;

w.VirtualFree(

w.MEM_DECOMMIT,

os.munmap(@alignCast(ptr[0 .. buf_aligned_len - new_size_aligned]));

if (builtin.os.tag == .windows) {

os.windows.VirtualFree(slice.ptr, 0, os.windows.MEM_RELEASE);

os.munmap(@alignCast(slice.ptr[0..buf_aligned_len]));

pub fn readvDirectTls(conn: *Connection, buffers: []std.os.iovec) ReadError!usize {

pub fn readvDirect(conn: *Connection, buffers: []std.os.iovec) ReadError!usize {

var iovecs = [1]std.os.iovec{

var iovecs = [2]std.os.iovec{

pub const ConnectUnixError = Allocator.Error || std.os.SocketError || error{NameTooLong} || std.os.ConnectError;

const os = std.os;

fn getStdOutHandle() os.fd_t {

if (builtin.os.tag == .windows) {

return os.windows.GetStdHandle(os.windows.STD_OUTPUT_HANDLE) catch os.windows.INVALID_HANDLE_VALUE;

return os.windows.peb().ProcessParameters.hStdOutput;

return os.STDOUT_FILENO;

return File{ .handle = getStdOutHandle() };

fn getStdErrHandle() os.fd_t {

if (builtin.os.tag == .windows) {

return os.windows.GetStdHandle(os.windows.STD_ERROR_HANDLE) catch os.windows.INVALID_HANDLE_VALUE;

return os.windows.peb().ProcessParameters.hStdError;

return os.STDERR_FILENO;

return File{ .handle = getStdErrHandle() };

fn getStdInHandle() os.fd_t {

if (builtin.os.tag == .windows) {

return os.windows.GetStdHandle(os.windows.STD_INPUT_HANDLE) catch os.windows.INVALID_HANDLE_VALUE;

return os.windows.peb().ProcessParameters.hStdInput;

return os.STDIN_FILENO;

return File{ .handle = getStdInHandle() };

if (builtin.os.tag == .windows) result.windows = .{

.overlapped = [1]os.windows.OVERLAPPED{

mem.zeroes(os.windows.OVERLAPPED),

if (builtin.os.tag == .windows) {

.events = os.POLL.IN,

const PollFd = if (builtin.os.tag == .windows) void else std.os.pollfd;

windows: if (builtin.os.tag == .windows) struct {

overlapped: [enum_fields.len]os.windows.OVERLAPPED,

handles_buf: [enum_fields.len]os.windows.HANDLE,

if (builtin.os.tag == .windows) {

_ = os.windows.kernel32.CancelIo(h);

if (builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

const status = os.windows.kernel32.WaitForMultipleObjects(

@min(std.math.cast(u32, ns / std.time.ns_per_ms) orelse (os.windows.INFINITE - 1), os.windows.INFINITE - 1)

os.windows.INFINITE,

if (status == os.windows.WAIT_FAILED)

return os.windows.unexpectedError(os.windows.kernel32.GetLastError());

if (status == os.windows.WAIT_TIMEOUT)

if (status < os.windows.WAIT_OBJECT_0 or status > os.windows.WAIT_OBJECT_0 + enum_fields.len - 1)

const active_idx = status - os.windows.WAIT_OBJECT_0;

if (0 == os.windows.kernel32.GetOverlappedResult(

)) switch (os.windows.kernel32.GetLastError()) {

else => |err| return os.windows.unexpectedError(err),

const err_mask = os.POLL.ERR | os.POLL.NVAL | os.POLL.HUP;

const events_len = try os.poll(&self.poll_fds, if (nanoseconds) |ns|

if (poll_fd.revents & os.POLL.IN != 0) {

const amt = try os.read(poll_fd.fd, buf);

handle: os.windows.HANDLE,

overlapped: *os.windows.OVERLAPPED,

const read_result = os.windows.kernel32.ReadFile(handle, buf.ptr, math.cast(u32, buf.len) orelse math.maxInt(u32), &read_bytes, overlapped);

if (read_result == 0) return switch (os.windows.kernel32.GetLastError()) {

else => |err| os.windows.unexpectedError(err),

const os = std.os;

switch (@as(os.E, @enumFromInt(std.c._errno().*))) {

else => |err| return os.unexpectedErrno(err),

test "C Writer" {

const os = std.os;

pub const has_unix_sockets = switch (builtin.os.tag) {

pub const IPv6InterfaceError = os.SocketError || os.IoCtl_SIOCGIFINDEX_Error || error{NameTooLong};

any: os.sockaddr,

un: if (has_unix_sockets) os.sockaddr.un else void,

pub fn parseExpectingFamily(name: []const u8, family: os.sa_family_t, port: u16) !Address {

os.AF.INET => return parseIp4(name, port),

os.AF.INET6 => return parseIp6(name, port),

os.AF.UNSPEC => return parseIp(name, port),

return Address{ .in6 = try Ip6Address.parse(buf, port) };

return Address{ .in6 = try Ip6Address.resolve(buf, port) };

return Address{ .in = try Ip4Address.parse(buf, port) };

return Address{ .in = Ip4Address.init(addr, port) };

return Address{ .in6 = Ip6Address.init(addr, port, flowinfo, scope_id) };

var sock_addr = os.sockaddr.un{

.family = os.AF.UNIX,

os.AF.INET => self.in.getPort(),

os.AF.INET6 => self.in6.getPort(),

os.AF.INET => self.in.setPort(port),

os.AF.INET6 => self.in6.setPort(port),

pub fn initPosix(addr: *align(4) const os.sockaddr) Address {

os.AF.INET => return Address{ .in = Ip4Address{ .sa = @as(*const os.sockaddr.in, @ptrCast(addr)).* } },

os.AF.INET6 => return Address{ .in6 = Ip6Address{ .sa = @as(*const os.sockaddr.in6, @ptrCast(addr)).* } },

os.AF.INET => try self.in.format(fmt, options, out_stream),

os.AF.INET6 => try self.in6.format(fmt, options, out_stream),

os.AF.UNIX => {

pub fn getOsSockLen(self: Address) os.socklen_t {

os.AF.INET => return self.in.getOsSockLen(),

os.AF.INET6 => return self.in6.getOsSockLen(),

os.AF.UNIX => {

return @as(os.socklen_t, @intCast(@sizeOf(os.sockaddr.un)));

switch (builtin.os.tag) {

sa: os.sockaddr.in,

.sa = os.sockaddr.in{

pub fn getOsSockLen(self: Ip4Address) os.socklen_t {

return @sizeOf(os.sockaddr.in);

sa: os.sockaddr.in6,

.sa = os.sockaddr.in6{

.sa = os.sockaddr.in6{

var scope_id_value: [os.IFNAMESIZE - 1]u8 = undefined;

.sa = os.sockaddr.in6{

pub fn getOsSockLen(self: Ip6Address) os.socklen_t {

return @sizeOf(os.sockaddr.in6);

const sockfd = try os.socket(

os.AF.UNIX,

os.SOCK.STREAM | os.SOCK.CLOEXEC | opt_non_block,

try os.connect(sockfd, &addr.any, addr.getOsSockLen());

return Stream{ .handle = sockfd };

if (builtin.target.os.tag == .linux) {

var ifr: os.ifreq = undefined;

const sockfd = try os.socket(os.AF.UNIX, os.SOCK.DGRAM | os.SOCK.CLOEXEC, 0);

try os.ioctl_SIOCGIFINDEX(sockfd, &ifr);

return @as(u32, @bitCast(ifr.ifru.ivalue));

if (comptime builtin.target.os.tag.isDarwin()) {

if (name.len >= os.IFNAMESIZE)

var if_name: [os.IFNAMESIZE:0]u8 = undefined;

const index = os.system.if_nametoindex(if_slice);

return std.os.ConnectError.ConnectionRefused;

pub const TcpConnectToAddressError = std.os.SocketError || std.os.ConnectError;

const sock_flags = os.SOCK.STREAM | nonblock |

(if (builtin.target.os.tag == .windows) 0 else os.SOCK.CLOEXEC);

const sockfd = try os.socket(address.any.family, sock_flags, os.IPPROTO.TCP);

try os.connect(sockfd, &address.any, address.getOsSockLen());

const GetAddressListError = std.mem.Allocator.Error || std.fs.File.OpenError || std.fs.File.ReadError || std.os.SocketError || std.os.BindError || std.os.SetSockOptError || error{

if (builtin.target.os.tag == .windows) {

const ws2_32 = os.windows.ws2_32;

const hints = os.addrinfo{

.family = os.AF.UNSPEC,

.socktype = os.SOCK.STREAM,

.protocol = os.IPPROTO.TCP,

var res: ?*os.addrinfo = null;

switch (@as(os.windows.ws2_32.WinsockError, @enumFromInt(@as(u16, @intCast(rc))))) {

@as(os.windows.ws2_32.WinsockError, @enumFromInt(0)) => break,

try os.windows.callWSAStartup();

else => |err| return os.windows.unexpectedWSAError(err),

const sys = if (builtin.target.os.tag == .windows) os.windows.ws2_32 else os.system;

const hints = os.addrinfo{

.family = os.AF.UNSPEC,

.socktype = os.SOCK.STREAM,

.protocol = os.IPPROTO.TCP,

var res: ?*os.addrinfo = null;

.SYSTEM => switch (os.errno(-1)) {

else => |e| return os.unexpectedErrno(e),

if (builtin.target.os.tag == .linux) {

const family = os.AF.UNSPEC;

family: os.sa_family_t,

if (addrs.items.len == 1 or family == os.AF.INET) return;

if (addr.addr.any.family != os.AF.INET) break false;

var sa6: os.sockaddr.in6 = undefined;

@memset(@as([*]u8, @ptrCast(&sa6))[0..@sizeOf(os.sockaddr.in6)], 0);

var da6 = os.sockaddr.in6{

.family = os.AF.INET6,

var sa4: os.sockaddr.in = undefined;

@memset(@as([*]u8, @ptrCast(&sa4))[0..@sizeOf(os.sockaddr.in)], 0);

var da4 = os.sockaddr.in{

.family = os.AF.INET,

var sa: *align(4) os.sockaddr = undefined;

var da: *align(4) os.sockaddr = undefined;

var salen: os.socklen_t = undefined;

var dalen: os.socklen_t = undefined;

if (addr.addr.any.family == os.AF.INET6) {

dalen = @sizeOf(os.sockaddr.in6);

salen = @sizeOf(os.sockaddr.in6);

dalen = @sizeOf(os.sockaddr.in);

salen = @sizeOf(os.sockaddr.in);

const sock_flags = os.SOCK.DGRAM | os.SOCK.CLOEXEC;

if (os.socket(addr.addr.any.family, sock_flags, os.IPPROTO.UDP)) |fd| syscalls: {

os.connect(fd, da, dalen) catch break :syscalls;

os.getsockname(fd, sa, &salen) catch break :syscalls;

if (addr.addr.any.family == os.AF.INET) {

family: os.sa_family_t,

if (family != os.AF.INET6) {

if (family != os.AF.INET) {

if (family != os.AF.INET6) {

if (family != os.AF.INET) {

family: os.sa_family_t,

family: os.sa_family_t,

family: os.sa_family_t,

af: os.sa_family_t,

AfRr{ .af = os.AF.INET6, .rr = os.RR.A },

AfRr{ .af = os.AF.INET, .rr = os.RR.AAAA },

const len = os.res_mkquery(0, name, 1, afrr.rr, &[_]u8{}, null, &qbuf[nq]);

var sl: os.socklen_t = @sizeOf(os.sockaddr.in);

var family: os.sa_family_t = os.AF.INET;

if (iplit.addr.any.family != os.AF.INET) {

family = os.AF.INET6;

const flags = os.SOCK.DGRAM | os.SOCK.CLOEXEC | os.SOCK.NONBLOCK;

const fd = os.socket(family, flags, 0) catch |err| switch (err) {

if (family == os.AF.INET6) {

family = os.AF.INET;

break :blk try os.socket(os.AF.INET, flags, 0);

if (family == os.AF.INET6) {

try os.setsockopt(

os.SOL.IPV6,

os.linux.IPV6.V6ONLY,

if (ns[i].any.family != os.AF.INET) continue;

ns[i].any.family = os.AF.INET6;

sl = @sizeOf(os.sockaddr.in6);

try os.bind(fd, &sa.any, sl);

var pfd = [1]os.pollfd{os.pollfd{

.events = os.POLL.IN,

_ = os.sendto(fd, queries[i], os.MSG.NOSIGNAL, &ns[j].any, sl) catch undefined;

const nevents = os.poll(&pfd, clamped_timeout) catch 0;

const rlen = os.recvfrom(fd, answer_bufs[next], 0, &sa.any, &sl_copy) catch break;

_ = os.sendto(fd, queries[i], os.MSG.NOSIGNAL, &ns[j].any, sl) catch undefined;

os.RR.A => {

os.RR.AAAA => {

os.RR.CNAME => {

_ = try os.dn_expand(packet, data, &tmp);

switch (builtin.os.tag) {

.windows => std.os.windows.closesocket(s.handle) catch unreachable,

pub const ReadError = os.ReadError;

pub const WriteError = os.WriteError;

if (builtin.os.tag == .windows) {

return os.windows.ReadFile(self.handle, buffer, null);

return os.read(self.handle, buffer);

pub fn readv(s: Stream, iovecs: []const os.iovec) ReadError!usize {

if (builtin.os.tag == .windows) {

return os.windows.ReadFile(s.handle, first.iov_base[0..first.iov_len], null);

return os.readv(s.handle, iovecs);

if (builtin.os.tag == .windows) {

return os.windows.WriteFile(self.handle, buffer, null);

return os.write(self.handle, buffer);

pub fn writev(self: Stream, iovecs: []const os.iovec_const) WriteError!usize {

return os.writev(self.handle, iovecs);

pub fn writevAll(self: Stream, iovecs: []os.iovec_const) WriteError!void {

//! Note: The Zig standard library does not support POSIX thread cancellation, and

//! in general EINTR is handled by trying again.

pub const darwin = std.c;

pub const dragonfly = std.c;

pub const freebsd = std.c;

pub const haiku = std.c;

pub const netbsd = std.c;

pub const openbsd = std.c;

pub const solaris = std.c;

pub const illumos = std.c;

comptime {

assert(@import("std") == std); // std lib tests require --zig-lib-dir

}

 

_ = darwin;

 

_ = @import("os/test.zig");

/// Applications can override the `system` API layer in their root source file.

/// Otherwise, when linking libc, this is the C API.

/// When not linking libc, it is the OS-specific system interface.

pub const system = if (@hasDecl(root, "os") and @hasDecl(root.os, "system") and root.os != @This())

root.os.system

else if (use_libc)

std.c

else switch (builtin.os.tag) {

.linux => linux,

.plan9 => plan9,

.uefi => uefi,

else => struct {},

};

 

/// Whether to use libc for the POSIX API layer.

const use_libc = builtin.link_libc or switch (builtin.os.tag) {

.windows, .wasi => true,

else => false,

};

 

pub const AF = system.AF;

pub const AF_SUN = system.AF_SUN;

pub const ARCH = system.ARCH;

pub const AT = system.AT;

pub const AT_SUN = system.AT_SUN;

pub const CLOCK = system.CLOCK;

pub const CPU_COUNT = system.CPU_COUNT;

pub const CTL = system.CTL;

pub const DT = system.DT;

pub const E = system.E;

pub const Elf_Symndx = system.Elf_Symndx;

pub const F = system.F;

pub const FD_CLOEXEC = system.FD_CLOEXEC;

pub const Flock = system.Flock;

pub const HOST_NAME_MAX = system.HOST_NAME_MAX;

pub const HW = system.HW;

pub const IFNAMESIZE = system.IFNAMESIZE;

pub const IOV_MAX = system.IOV_MAX;

pub const IPPROTO = system.IPPROTO;

pub const KERN = system.KERN;

pub const Kevent = system.Kevent;

pub const LOCK = system.LOCK;

pub const MADV = system.MADV;

pub const MAP = system.MAP;

pub const MSF = system.MSF;

pub const MAX_ADDR_LEN = system.MAX_ADDR_LEN;

pub const MFD = system.MFD;

pub const MMAP2_UNIT = system.MMAP2_UNIT;

pub const MSG = system.MSG;

pub const NAME_MAX = system.NAME_MAX;

pub const O = system.O;

pub const PATH_MAX = system.PATH_MAX;

pub const POLL = system.POLL;

pub const POSIX_FADV = system.POSIX_FADV;

pub const PR = system.PR;

pub const PROT = system.PROT;

pub const REG = system.REG;

pub const RLIM = system.RLIM;

pub const RR = system.RR;

pub const S = system.S;

pub const SA = system.SA;

pub const SC = system.SC;

pub const _SC = system._SC;

pub const SEEK = system.SEEK;

pub const SHUT = system.SHUT;

pub const SIG = system.SIG;

pub const SIOCGIFINDEX = system.SIOCGIFINDEX;

pub const SO = system.SO;

pub const SOCK = system.SOCK;

pub const SOL = system.SOL;

pub const STDERR_FILENO = system.STDERR_FILENO;

pub const STDIN_FILENO = system.STDIN_FILENO;

pub const STDOUT_FILENO = system.STDOUT_FILENO;

pub const SYS = system.SYS;

pub const Sigaction = system.Sigaction;

pub const Stat = system.Stat;

pub const T = system.T;

pub const TCSA = system.TCSA;

pub const TCP = system.TCP;

pub const VDSO = system.VDSO;

pub const W = system.W;

pub const addrinfo = system.addrinfo;

pub const blkcnt_t = system.blkcnt_t;

pub const blksize_t = system.blksize_t;

pub const clock_t = system.clock_t;

pub const cpu_set_t = system.cpu_set_t;

pub const dev_t = system.dev_t;

pub const dl_phdr_info = system.dl_phdr_info;

pub const empty_sigset = system.empty_sigset;

pub const filled_sigset = system.filled_sigset;

pub const fd_t = system.fd_t;

pub const gid_t = system.gid_t;

pub const ifreq = system.ifreq;

pub const ino_t = system.ino_t;

pub const mcontext_t = system.mcontext_t;

pub const mode_t = system.mode_t;

pub const msghdr = system.msghdr;

pub const msghdr_const = system.msghdr_const;

pub const nfds_t = system.nfds_t;

pub const nlink_t = system.nlink_t;

pub const off_t = system.off_t;

pub const pid_t = system.pid_t;

pub const pollfd = system.pollfd;

pub const port_t = system.port_t;

pub const port_event = system.port_event;

pub const port_notify = system.port_notify;

pub const file_obj = system.file_obj;

pub const rlim_t = system.rlim_t;

pub const rlimit = system.rlimit;

pub const rlimit_resource = system.rlimit_resource;

pub const rusage = system.rusage;

pub const sa_family_t = system.sa_family_t;

pub const siginfo_t = system.siginfo_t;

pub const sigset_t = system.sigset_t;

pub const sockaddr = system.sockaddr;

pub const socklen_t = system.socklen_t;

pub const stack_t = system.stack_t;

pub const time_t = system.time_t;

pub const timespec = system.timespec;

pub const timestamp_t = system.timestamp_t;

pub const timeval = system.timeval;

pub const timezone = system.timezone;

pub const ucontext_t = system.ucontext_t;

pub const uid_t = system.uid_t;

pub const user_desc = system.user_desc;

pub const utsname = system.utsname;

pub const winsize = system.winsize;

 

pub const termios = system.termios;

pub const CSIZE = system.CSIZE;

pub const NCCS = system.NCCS;

pub const cc_t = system.cc_t;

pub const V = system.V;

pub const speed_t = system.speed_t;

pub const tc_iflag_t = system.tc_iflag_t;

pub const tc_oflag_t = system.tc_oflag_t;

pub const tc_cflag_t = system.tc_cflag_t;

pub const tc_lflag_t = system.tc_lflag_t;

 

pub const F_OK = system.F_OK;

pub const R_OK = system.R_OK;

pub const W_OK = system.W_OK;

pub const X_OK = system.X_OK;

 

pub const iovec = extern struct {

iov_base: [*]u8,

iov_len: usize,

};

 

pub const iovec_const = extern struct {

iov_base: [*]const u8,

iov_len: usize,

};

 

pub const ACCMODE = enum(u2) {

RDONLY = 0,

WRONLY = 1,

RDWR = 2,

};

 

pub const LOG = struct {

/// system is unusable

pub const EMERG = 0;

/// action must be taken immediately

pub const ALERT = 1;

/// critical conditions

pub const CRIT = 2;

/// error conditions

pub const ERR = 3;

/// warning conditions

pub const WARNING = 4;

/// normal but significant condition

pub const NOTICE = 5;

/// informational

pub const INFO = 6;

/// debug-level messages

pub const DEBUG = 7;

};

 

/// An fd-relative file path

///

/// This is currently only used for WASI-specific functionality, but the concept

/// is the same as the dirfd/pathname pairs in the `*at(...)` POSIX functions.

pub const RelativePathWasi = struct {

/// Handle to directory

dir_fd: fd_t,

/// Path to resource within `dir_fd`.

relative_path: []const u8,

};

 

pub const socket_t = if (builtin.os.tag == .windows) windows.ws2_32.SOCKET else fd_t;

 

pub const have_sigpipe_support = @hasDecl(@This(), "SIG") and @hasDecl(SIG, "PIPE");

 

fn noopSigHandler(_: c_int) callconv(.C) void {}

 

/// On default executed by posix startup code before main(), if SIGPIPE is supported.

pub fn maybeIgnoreSigpipe() void {

if (have_sigpipe_support and !std.options.keep_sigpipe) {

const act = Sigaction{

// We set handler to a noop function instead of SIG.IGN so we don't leak our

// signal disposition to a child process

.handler = .{ .handler = noopSigHandler },

.mask = empty_sigset,

.flags = 0,

};

sigaction(SIG.PIPE, &act, null) catch |err|

std.debug.panic("failed to install noop SIGPIPE handler with '{s}'", .{@errorName(err)});

}

}

 

/// To obtain errno, call this function with the return value of the

/// system function call. For some systems this will obtain the value directly

/// from the return code; for others it will use a thread-local errno variable.

/// Therefore, this function only returns a well-defined value when it is called

/// directly after the system function call which one wants to learn the errno

/// value of.

pub const errno = system.getErrno;

 

/// Closes the file descriptor.

/// This function is not capable of returning any indication of failure. An

/// application which wants to ensure writes have succeeded before closing

/// must call `fsync` before `close`.

/// Note: The Zig standard library does not support POSIX thread cancellation.

pub fn close(fd: fd_t) void {

if (builtin.os.tag == .windows) {

return windows.CloseHandle(fd);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

_ = wasi.fd_close(fd);

return;

}

if (builtin.target.isDarwin()) {

// This avoids the EINTR problem.

switch (darwin.getErrno(darwin.@"close$NOCANCEL"(fd))) {

.BADF => unreachable, // Always a race condition.

else => return,

}

}

switch (errno(system.close(fd))) {

.BADF => unreachable, // Always a race condition.

.INTR => return, // This is still a success. See https://github.com/ziglang/zig/issues/2425

else => return,

}

}

 

pub const FChmodError = error{

AccessDenied,

InputOutput,

SymLinkLoop,

FileNotFound,

SystemResources,

ReadOnlyFileSystem,

} || UnexpectedError;

 

/// Changes the mode of the file referred to by the file descriptor.

/// The process must have the correct privileges in order to do this

/// successfully, or must have the effective user ID matching the owner

/// of the file.

pub fn fchmod(fd: fd_t, mode: mode_t) FChmodError!void {

if (!std.fs.has_executable_bit) @compileError("fchmod unsupported by target OS");

 

while (true) {

const res = system.fchmod(fd, mode);

 

switch (system.getErrno(res)) {

.SUCCESS => return,

.INTR => continue,

.BADF => unreachable,

.FAULT => unreachable,

.INVAL => unreachable,

.ACCES => return error.AccessDenied,

.IO => return error.InputOutput,

.LOOP => return error.SymLinkLoop,

.NOENT => return error.FileNotFound,

.NOMEM => return error.SystemResources,

.NOTDIR => return error.FileNotFound,

.PERM => return error.AccessDenied,

.ROFS => return error.ReadOnlyFileSystem,

else => |err| return unexpectedErrno(err),

}

}

}

 

const FChmodAtError = FChmodError || error{

/// A component of `path` exceeded `NAME_MAX`, or the entire path exceeded

/// `PATH_MAX`.

NameTooLong,

/// `path` resolves to a symbolic link, and `AT.SYMLINK_NOFOLLOW` was set

/// in `flags`. This error only occurs on Linux, where changing the mode of

/// a symbolic link has no meaning and can cause undefined behaviour on

/// certain filesystems.

///

/// The procfs fallback was used but procfs was not mounted.

OperationNotSupported,

/// The procfs fallback was used but the process exceeded its open file

/// limit.

ProcessFdQuotaExceeded,

/// The procfs fallback was used but the system exceeded it open file limit.

SystemFdQuotaExceeded,

};

 

var has_fchmodat2_syscall = std.atomic.Value(bool).init(true);

 

/// Changes the `mode` of `path` relative to the directory referred to by

/// `dirfd`. The process must have the correct privileges in order to do this

/// successfully, or must have the effective user ID matching the owner of the

/// file.

///

/// On Linux the `fchmodat2` syscall will be used if available, otherwise a

/// workaround using procfs will be employed. Changing the mode of a symbolic

/// link with `AT.SYMLINK_NOFOLLOW` set will also return

/// `OperationNotSupported`, as:

///

/// 1. Permissions on the link are ignored when resolving its target.

/// 2. This operation has been known to invoke undefined behaviour across

/// different filesystems[1].

///

/// [1]: https://sourceware.org/legacy-ml/libc-alpha/2020-02/msg00467.html.

pub inline fn fchmodat(dirfd: fd_t, path: []const u8, mode: mode_t, flags: u32) FChmodAtError!void {

if (!std.fs.has_executable_bit) @compileError("fchmodat unsupported by target OS");

 

// No special handling for linux is needed if we can use the libc fallback

// or `flags` is empty. Glibc only added the fallback in 2.32.

const skip_fchmodat_fallback = builtin.os.tag != .linux or

std.c.versionCheck(.{ .major = 2, .minor = 32, .patch = 0 }) or

flags == 0;

 

// This function is marked inline so that when flags is comptime-known,

// skip_fchmodat_fallback will be comptime-known true.

if (skip_fchmodat_fallback)

return fchmodat1(dirfd, path, mode, flags);

 

return fchmodat2(dirfd, path, mode, flags);

}

 

fn fchmodat1(dirfd: fd_t, path: []const u8, mode: mode_t, flags: u32) FChmodAtError!void {

const path_c = try toPosixPath(path);

while (true) {

const res = system.fchmodat(dirfd, &path_c, mode, flags);

switch (system.getErrno(res)) {

.SUCCESS => return,

.INTR => continue,

.BADF => unreachable,

.FAULT => unreachable,

.INVAL => unreachable,

.ACCES => return error.AccessDenied,

.IO => return error.InputOutput,

.LOOP => return error.SymLinkLoop,

.MFILE => return error.ProcessFdQuotaExceeded,

.NAMETOOLONG => return error.NameTooLong,

.NFILE => return error.SystemFdQuotaExceeded,

.NOENT => return error.FileNotFound,

.NOTDIR => return error.FileNotFound,

.NOMEM => return error.SystemResources,

.OPNOTSUPP => return error.OperationNotSupported,

.PERM => return error.AccessDenied,

.ROFS => return error.ReadOnlyFileSystem,

else => |err| return unexpectedErrno(err),

}

}

}

 

fn fchmodat2(dirfd: fd_t, path: []const u8, mode: mode_t, flags: u32) FChmodAtError!void {

const path_c = try toPosixPath(path);

const use_fchmodat2 = (builtin.os.isAtLeast(.linux, .{ .major = 6, .minor = 6, .patch = 0 }) orelse false) and

has_fchmodat2_syscall.load(.monotonic);

while (use_fchmodat2) {

// Later on this should be changed to `system.fchmodat2`

// when the musl/glibc add a wrapper.

const res = linux.fchmodat2(dirfd, &path_c, mode, flags);

switch (linux.getErrno(res)) {

.SUCCESS => return,

.INTR => continue,

.BADF => unreachable,

.FAULT => unreachable,

.INVAL => unreachable,

.ACCES => return error.AccessDenied,

.IO => return error.InputOutput,

.LOOP => return error.SymLinkLoop,

.NOENT => return error.FileNotFound,

.NOMEM => return error.SystemResources,

.NOTDIR => return error.FileNotFound,

.OPNOTSUPP => return error.OperationNotSupported,

.PERM => return error.AccessDenied,

.ROFS => return error.ReadOnlyFileSystem,

 

.NOSYS => { // Use fallback.

has_fchmodat2_syscall.store(false, .monotonic);

break;

},

else => |err| return unexpectedErrno(err),

}

}

 

// Fallback to changing permissions using procfs:

//

// 1. Open `path` as a `PATH` descriptor.

// 2. Stat the fd and check if it isn't a symbolic link.

// 3. Generate the procfs reference to the fd via `/proc/self/fd/{fd}`.

// 4. Pass the procfs path to `chmod` with the `mode`.

var pathfd: fd_t = undefined;

while (true) {

const rc = system.openat(dirfd, &path_c, .{ .PATH = true, .NOFOLLOW = true, .CLOEXEC = true }, @as(mode_t, 0));

switch (system.getErrno(rc)) {

.SUCCESS => {

pathfd = @intCast(rc);

break;

},

.INTR => continue,

.FAULT => unreachable,

.INVAL => unreachable,

.ACCES => return error.AccessDenied,

.PERM => return error.AccessDenied,

.LOOP => return error.SymLinkLoop,

.MFILE => return error.ProcessFdQuotaExceeded,

.NAMETOOLONG => return error.NameTooLong,

.NFILE => return error.SystemFdQuotaExceeded,

.NOENT => return error.FileNotFound,

.NOMEM => return error.SystemResources,

else => |err| return unexpectedErrno(err),

}

}

defer close(pathfd);

 

const stat = fstatatZ(pathfd, "", AT.EMPTY_PATH) catch |err| switch (err) {

error.NameTooLong => unreachable,

error.FileNotFound => unreachable,

error.InvalidUtf8 => unreachable,

else => |e| return e,

};

if ((stat.mode & S.IFMT) == S.IFLNK)

return error.OperationNotSupported;

 

var procfs_buf: ["/proc/self/fd/-2147483648\x00".len]u8 = undefined;

const proc_path = std.fmt.bufPrintZ(procfs_buf[0..], "/proc/self/fd/{d}", .{pathfd}) catch unreachable;

while (true) {

const res = system.chmod(proc_path, mode);

switch (system.getErrno(res)) {

// Getting NOENT here means that procfs isn't mounted.

.NOENT => return error.OperationNotSupported,

 

.SUCCESS => return,

.INTR => continue,

.BADF => unreachable,

.FAULT => unreachable,

.INVAL => unreachable,

.ACCES => return error.AccessDenied,

.IO => return error.InputOutput,

.LOOP => return error.SymLinkLoop,

.NOMEM => return error.SystemResources,

.NOTDIR => return error.FileNotFound,

.PERM => return error.AccessDenied,

.ROFS => return error.ReadOnlyFileSystem,

else => |err| return unexpectedErrno(err),

}

}

}

 

pub const FChownError = error{

AccessDenied,

InputOutput,

SymLinkLoop,

FileNotFound,

SystemResources,

ReadOnlyFileSystem,

} || UnexpectedError;

 

/// Changes the owner and group of the file referred to by the file descriptor.

/// The process must have the correct privileges in order to do this

/// successfully. The group may be changed by the owner of the directory to

/// any group of which the owner is a member. If the owner or group is

/// specified as `null`, the ID is not changed.

pub fn fchown(fd: fd_t, owner: ?uid_t, group: ?gid_t) FChownError!void {

switch (builtin.os.tag) {

.windows, .wasi => @compileError("Unsupported OS"),

else => {},

}

 

while (true) {

const res = system.fchown(fd, owner orelse ~@as(uid_t, 0), group orelse ~@as(gid_t, 0));

 

switch (system.getErrno(res)) {

.SUCCESS => return,

.INTR => continue,

.BADF => unreachable, // Can be reached if the fd refers to a directory opened without `OpenDirOptions{ .iterate = true }`

 

.FAULT => unreachable,

.INVAL => unreachable,

.ACCES => return error.AccessDenied,

.IO => return error.InputOutput,

.LOOP => return error.SymLinkLoop,

.NOENT => return error.FileNotFound,

.NOMEM => return error.SystemResources,

.NOTDIR => return error.FileNotFound,

.PERM => return error.AccessDenied,

.ROFS => return error.ReadOnlyFileSystem,

else => |err| return unexpectedErrno(err),

}

}

}

 

pub const RebootError = error{

PermissionDenied,

} || UnexpectedError;

 

pub const RebootCommand = switch (builtin.os.tag) {

.linux => union(linux.LINUX_REBOOT.CMD) {

RESTART: void,

HALT: void,

CAD_ON: void,

CAD_OFF: void,

POWER_OFF: void,

RESTART2: [*:0]const u8,

SW_SUSPEND: void,

KEXEC: void,

},

else => @compileError("Unsupported OS"),

};

 

pub fn reboot(cmd: RebootCommand) RebootError!void {

switch (builtin.os.tag) {

.linux => {

switch (system.getErrno(linux.reboot(

.MAGIC1,

.MAGIC2,

cmd,

switch (cmd) {

.RESTART2 => |s| s,

else => null,

},

))) {

.SUCCESS => {},

.PERM => return error.PermissionDenied,

else => |err| return std.os.unexpectedErrno(err),

}

switch (cmd) {

.CAD_OFF => {},

.CAD_ON => {},

.SW_SUSPEND => {},

 

.HALT => unreachable,

.KEXEC => unreachable,

.POWER_OFF => unreachable,

.RESTART => unreachable,

.RESTART2 => unreachable,

}

},

else => @compileError("Unsupported OS"),

}

}

 

pub const GetRandomError = OpenError;

 

/// Obtain a series of random bytes. These bytes can be used to seed user-space

/// random number generators or for cryptographic purposes.

/// When linking against libc, this calls the

/// appropriate OS-specific library call. Otherwise it uses the zig standard

/// library implementation.

pub fn getrandom(buffer: []u8) GetRandomError!void {

if (builtin.os.tag == .windows) {

return windows.RtlGenRandom(buffer);

}

if (builtin.os.tag == .linux or builtin.os.tag == .freebsd) {

var buf = buffer;

const use_c = builtin.os.tag != .linux or

std.c.versionCheck(std.SemanticVersion{ .major = 2, .minor = 25, .patch = 0 });

 

while (buf.len != 0) {

const num_read: usize, const err = if (use_c) res: {

const rc = std.c.getrandom(buf.ptr, buf.len, 0);

break :res .{

@bitCast(rc),

std.c.getErrno(rc),

};

} else res: {

const rc = linux.getrandom(buf.ptr, buf.len, 0);

break :res .{

rc,

linux.getErrno(rc),

};

};

 

switch (err) {

.SUCCESS => buf = buf[num_read..],

.INVAL => unreachable,

.FAULT => unreachable,

.INTR => continue,

.NOSYS => return getRandomBytesDevURandom(buf),

else => return unexpectedErrno(err),

}

}

return;

}

if (builtin.os.tag == .emscripten) {

const err = std.c.getErrno(std.c.getentropy(buffer.ptr, buffer.len));

switch (err) {

.SUCCESS => return,

else => return unexpectedErrno(err),

}

}

switch (builtin.os.tag) {

.netbsd, .openbsd, .macos, .ios, .tvos, .watchos => {

system.arc4random_buf(buffer.ptr, buffer.len);

return;

},

.wasi => switch (wasi.random_get(buffer.ptr, buffer.len)) {

.SUCCESS => return,

else => |err| return unexpectedErrno(err),

},

else => return getRandomBytesDevURandom(buffer),

}

}

 

fn getRandomBytesDevURandom(buf: []u8) !void {

const fd = try openZ("/dev/urandom", .{ .ACCMODE = .RDONLY, .CLOEXEC = true }, 0);

defer close(fd);

 

const st = try fstat(fd);

if (!S.ISCHR(st.mode)) {

return error.NoDevice;

}

 

const file = std.fs.File{ .handle = fd };

const stream = file.reader();

stream.readNoEof(buf) catch return error.Unexpected;

}

 

/// Causes abnormal process termination.

/// If linking against libc, this calls the abort() libc function. Otherwise

/// it raises SIGABRT followed by SIGKILL and finally lo

/// Invokes the current signal handler for SIGABRT, if any.

pub fn abort() noreturn {

@setCold(true);

// MSVCRT abort() sometimes opens a popup window which is undesirable, so

// even when linking libc on Windows we use our own abort implementation.

// See https://github.com/ziglang/zig/issues/2071 for more details.

if (builtin.os.tag == .windows) {

if (builtin.mode == .Debug) {

@breakpoint();

}

windows.kernel32.ExitProcess(3);

}

if (!builtin.link_libc and builtin.os.tag == .linux) {

// The Linux man page says that the libc abort() function

// "first unblocks the SIGABRT signal", but this is a footgun

// for user-defined signal handlers that want to restore some state in

// some program sections and crash in others.

// So, the user-installed SIGABRT handler is run, if present.

raise(SIG.ABRT) catch {};

 

// Disable all signal handlers.

sigprocmask(SIG.BLOCK, &linux.all_mask, null);

 

// Only one thread may proceed to the rest of abort().

if (!builtin.single_threaded) {

const global = struct {

var abort_entered: bool = false;

};

while (@cmpxchgWeak(bool, &global.abort_entered, false, true, .seq_cst, .seq_cst)) |_| {}

}

 

// Install default handler so that the tkill below will terminate.

const sigact = Sigaction{

.handler = .{ .handler = SIG.DFL },

.mask = empty_sigset,

.flags = 0,

};

sigaction(SIG.ABRT, &sigact, null) catch |err| switch (err) {

error.OperationNotSupported => unreachable,

};

 

_ = linux.tkill(linux.gettid(), SIG.ABRT);

 

const sigabrtmask: linux.sigset_t = [_]u32{0} ** 31 ++ [_]u32{1 << (SIG.ABRT - 1)};

sigprocmask(SIG.UNBLOCK, &sigabrtmask, null);

 

// Beyond this point should be unreachable.

@as(*allowzero volatile u8, @ptrFromInt(0)).* = 0;

raise(SIG.KILL) catch {};

exit(127); // Pid 1 might not be signalled in some containers.

}

switch (builtin.os.tag) {

.uefi, .wasi, .emscripten, .cuda, .amdhsa => @trap(),

else => system.abort(),

}

}

 

pub const RaiseError = UnexpectedError;

 

pub fn raise(sig: u8) RaiseError!void {

if (builtin.link_libc) {

switch (errno(system.raise(sig))) {

.SUCCESS => return,

else => |err| return unexpectedErrno(err),

}

}

 

if (builtin.os.tag == .linux) {

var set: sigset_t = undefined;

// block application signals

sigprocmask(SIG.BLOCK, &linux.app_mask, &set);

 

const tid = linux.gettid();

const rc = linux.tkill(tid, sig);

 

// restore signal mask

sigprocmask(SIG.SETMASK, &set, null);

 

switch (errno(rc)) {

.SUCCESS => return,

else => |err| return unexpectedErrno(err),

}

}

 

@compileError("std.os.raise unimplemented for this target");

}

 

pub const KillError = error{ ProcessNotFound, PermissionDenied } || UnexpectedError;

 

pub fn kill(pid: pid_t, sig: u8) KillError!void {

switch (errno(system.kill(pid, sig))) {

.SUCCESS => return,

.INVAL => unreachable, // invalid signal

.PERM => return error.PermissionDenied,

.SRCH => return error.ProcessNotFound,

else => |err| return unexpectedErrno(err),

}

}

 

/// Exits the program cleanly with the specified status code.

pub fn exit(status: u8) noreturn {

if (builtin.link_libc) {

system.exit(status);

}

if (builtin.os.tag == .windows) {

windows.kernel32.ExitProcess(status);

}

if (builtin.os.tag == .wasi) {

wasi.proc_exit(status);

}

if (builtin.os.tag == .linux and !builtin.single_threaded) {

linux.exit_group(status);

}

if (builtin.os.tag == .uefi) {

// exit() is only available if exitBootServices() has not been called yet.

// This call to exit should not fail, so we don't care about its return value.

if (uefi.system_table.boot_services) |bs| {

_ = bs.exit(uefi.handle, @enumFromInt(status), 0, null);

}

// If we can't exit, reboot the system instead.

uefi.system_table.runtime_services.resetSystem(.ResetCold, @enumFromInt(status), 0, null);

}

system.exit(status);

}

 

pub const ReadError = error{

InputOutput,

SystemResources,

IsDir,

OperationAborted,

BrokenPipe,

ConnectionResetByPeer,

ConnectionTimedOut,

NotOpenForReading,

SocketNotConnected,

 

/// This error occurs when no global event loop is configured,

/// and reading from the file descriptor would block.

WouldBlock,

 

/// In WASI, this error occurs when the file descriptor does

/// not hold the required rights to read from it.

AccessDenied,

} || UnexpectedError;

 

/// Returns the number of bytes that were read, which can be less than

/// buf.len. If 0 bytes were read, that means EOF.

/// If `fd` is opened in non blocking mode, the function will return error.WouldBlock

/// when EAGAIN is received.

///

/// Linux has a limit on how many bytes may be transferred in one `read` call, which is `0x7ffff000`

/// on both 64-bit and 32-bit systems. This is due to using a signed C int as the return value, as

/// well as stuffing the errno codes into the last `4096` values. This is noted on the `read` man page.

/// The limit on Darwin is `0x7fffffff`, trying to read more than that returns EINVAL.

/// The corresponding POSIX limit is `math.maxInt(isize)`.

pub fn read(fd: fd_t, buf: []u8) ReadError!usize {

if (buf.len == 0) return 0;

if (builtin.os.tag == .windows) {

return windows.ReadFile(fd, buf, null);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

const iovs = [1]iovec{iovec{

.iov_base = buf.ptr,

.iov_len = buf.len,

}};

 

var nread: usize = undefined;

switch (wasi.fd_read(fd, &iovs, iovs.len, &nread)) {

.SUCCESS => return nread,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable,

.BADF => return error.NotOpenForReading, // Can be a race condition.

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

// Prevents EINVAL.

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

};

while (true) {

const rc = system.read(fd, buf.ptr, @min(buf.len, max_count));

switch (errno(rc)) {

.SUCCESS => return @intCast(rc),

.INTR => continue,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForReading, // Can be a race condition.

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

else => |err| return unexpectedErrno(err),

}

}

}

 

/// Number of bytes read is returned. Upon reading end-of-file, zero is returned.

///

/// For POSIX systems, if `fd` is opened in non blocking mode, the function will

/// return error.WouldBlock when EAGAIN is received.

/// On Windows, if the application has a global event loop enabled, I/O Completion Ports are

/// used to perform the I/O. `error.WouldBlock` is not possible on Windows.

///

/// This operation is non-atomic on the following systems:

/// * Windows

/// On these systems, the read races with concurrent writes to the same file descriptor.

///

/// This function assumes that all vectors, including zero-length vectors, have

/// a pointer within the address space of the application.

pub fn readv(fd: fd_t, iov: []const iovec) ReadError!usize {

if (builtin.os.tag == .windows) {

// TODO improve this to use ReadFileScatter

if (iov.len == 0) return 0;

const first = iov[0];

return read(fd, first.iov_base[0..first.iov_len]);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

var nread: usize = undefined;

switch (wasi.fd_read(fd, iov.ptr, iov.len, &nread)) {

.SUCCESS => return nread,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable, // currently not support in WASI

.BADF => return error.NotOpenForReading, // can be a race condition

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

while (true) {

const rc = system.readv(fd, iov.ptr, @min(iov.len, IOV_MAX));

switch (errno(rc)) {

.SUCCESS => return @intCast(rc),

.INTR => continue,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForReading, // can be a race condition

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

else => |err| return unexpectedErrno(err),

}

}

}

 

pub const PReadError = ReadError || error{Unseekable};

 

/// Number of bytes read is returned. Upon reading end-of-file, zero is returned.

///

/// Retries when interrupted by a signal.

///

/// For POSIX systems, if `fd` is opened in non blocking mode, the function will

/// return error.WouldBlock when EAGAIN is received.

/// On Windows, if the application has a global event loop enabled, I/O Completion Ports are

/// used to perform the I/O. `error.WouldBlock` is not possible on Windows.

///

/// Linux has a limit on how many bytes may be transferred in one `pread` call, which is `0x7ffff000`

/// on both 64-bit and 32-bit systems. This is due to using a signed C int as the return value, as

/// well as stuffing the errno codes into the last `4096` values. This is noted on the `read` man page.

/// The limit on Darwin is `0x7fffffff`, trying to read more than that returns EINVAL.

/// The corresponding POSIX limit is `math.maxInt(isize)`.

pub fn pread(fd: fd_t, buf: []u8, offset: u64) PReadError!usize {

if (buf.len == 0) return 0;

if (builtin.os.tag == .windows) {

return windows.ReadFile(fd, buf, offset);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

const iovs = [1]iovec{iovec{

.iov_base = buf.ptr,

.iov_len = buf.len,

}};

 

var nread: usize = undefined;

switch (wasi.fd_pread(fd, &iovs, iovs.len, offset, &nread)) {

.SUCCESS => return nread,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable,

.BADF => return error.NotOpenForReading, // Can be a race condition.

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

// Prevent EINVAL.

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

};

 

const pread_sym = if (lfs64_abi) system.pread64 else system.pread;

while (true) {

const rc = pread_sym(fd, buf.ptr, @min(buf.len, max_count), @bitCast(offset));

switch (errno(rc)) {

.SUCCESS => return @intCast(rc),

.INTR => continue,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForReading, // Can be a race condition.

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

else => |err| return unexpectedErrno(err),

}

}

}

 

pub const TruncateError = error{

FileTooBig,

InputOutput,

FileBusy,

 

/// In WASI, this error occurs when the file descriptor does

/// not hold the required rights to call `ftruncate` on it.

AccessDenied,

} || UnexpectedError;

 

pub fn ftruncate(fd: fd_t, length: u64) TruncateError!void {

if (builtin.os.tag == .windows) {

var io_status_block: windows.IO_STATUS_BLOCK = undefined;

var eof_info = windows.FILE_END_OF_FILE_INFORMATION{

.EndOfFile = @bitCast(length),

};

 

const rc = windows.ntdll.NtSetInformationFile(

fd,

&io_status_block,

&eof_info,

@sizeOf(windows.FILE_END_OF_FILE_INFORMATION),

.FileEndOfFileInformation,

);

 

switch (rc) {

.SUCCESS => return,

.INVALID_HANDLE => unreachable, // Handle not open for writing

.ACCESS_DENIED => return error.AccessDenied,

else => return windows.unexpectedStatus(rc),

}

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

switch (wasi.fd_filestat_set_size(fd, length)) {

.SUCCESS => return,

.INTR => unreachable,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.PERM => return error.AccessDenied,

.TXTBSY => return error.FileBusy,

.BADF => unreachable, // Handle not open for writing

.INVAL => unreachable, // Handle not open for writing

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

const ftruncate_sym = if (lfs64_abi) system.ftruncate64 else system.ftruncate;

while (true) {

switch (errno(ftruncate_sym(fd, @bitCast(length)))) {

.SUCCESS => return,

.INTR => continue,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.PERM => return error.AccessDenied,

.TXTBSY => return error.FileBusy,

.BADF => unreachable, // Handle not open for writing

.INVAL => unreachable, // Handle not open for writing

else => |err| return unexpectedErrno(err),

}

}

}

 

/// Number of bytes read is returned. Upon reading end-of-file, zero is returned.

///

/// Retries when interrupted by a signal.

///

/// For POSIX systems, if `fd` is opened in non blocking mode, the function will

/// return error.WouldBlock when EAGAIN is received.

/// On Windows, if the application has a global event loop enabled, I/O Completion Ports are

/// used to perform the I/O. `error.WouldBlock` is not possible on Windows.

///

/// This operation is non-atomic on the following systems:

/// * Darwin

/// * Windows

/// On these systems, the read races with concurrent writes to the same file descriptor.

pub fn preadv(fd: fd_t, iov: []const iovec, offset: u64) PReadError!usize {

const have_pread_but_not_preadv = switch (builtin.os.tag) {

.windows, .macos, .ios, .watchos, .tvos, .haiku => true,

else => false,

};

if (have_pread_but_not_preadv) {

// We could loop here; but proper usage of `preadv` must handle partial reads anyway.

// So we simply read into the first vector only.

if (iov.len == 0) return 0;

const first = iov[0];

return pread(fd, first.iov_base[0..first.iov_len], offset);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

var nread: usize = undefined;

switch (wasi.fd_pread(fd, iov.ptr, iov.len, offset, &nread)) {

.SUCCESS => return nread,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable,

.BADF => return error.NotOpenForReading, // can be a race condition

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

const preadv_sym = if (lfs64_abi) system.preadv64 else system.preadv;

while (true) {

const rc = preadv_sym(fd, iov.ptr, @min(iov.len, IOV_MAX), @bitCast(offset));

switch (errno(rc)) {

.SUCCESS => return @bitCast(rc),

.INTR => continue,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForReading, // can be a race condition

.IO => return error.InputOutput,

.ISDIR => return error.IsDir,

.NOBUFS => return error.SystemResources,

.NOMEM => return error.SystemResources,

.NOTCONN => return error.SocketNotConnected,

.CONNRESET => return error.ConnectionResetByPeer,

.TIMEDOUT => return error.ConnectionTimedOut,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

else => |err| return unexpectedErrno(err),

}

}

}

 

pub const WriteError = error{

DiskQuota,

FileTooBig,

InputOutput,

NoSpaceLeft,

DeviceBusy,

InvalidArgument,

 

/// In WASI, this error may occur when the file descriptor does

/// not hold the required rights to write to it.

AccessDenied,

BrokenPipe,

SystemResources,

OperationAborted,

NotOpenForWriting,

 

/// The process cannot access the file because another process has locked

/// a portion of the file. Windows-only.

LockViolation,

 

/// This error occurs when no global event loop is configured,

/// and reading from the file descriptor would block.

WouldBlock,

 

/// Connection reset by peer.

ConnectionResetByPeer,

} || UnexpectedError;

 

/// Write to a file descriptor.

/// Retries when interrupted by a signal.

/// Returns the number of bytes written. If nonzero bytes were supplied, this will be nonzero.

///

/// Note that a successful write() may transfer fewer than count bytes. Such partial writes can

/// occur for various reasons; for example, because there was insufficient space on the disk

/// device to write all of the requested bytes, or because a blocked write() to a socket, pipe, or

/// similar was interrupted by a signal handler after it had transferred some, but before it had

/// transferred all of the requested bytes. In the event of a partial write, the caller can make

/// another write() call to transfer the remaining bytes. The subsequent call will either

/// transfer further bytes or may result in an error (e.g., if the disk is now full).

///

/// For POSIX systems, if `fd` is opened in non blocking mode, the function will

/// return error.WouldBlock when EAGAIN is received.

/// On Windows, if the application has a global event loop enabled, I/O Completion Ports are

/// used to perform the I/O. `error.WouldBlock` is not possible on Windows.

///

/// Linux has a limit on how many bytes may be transferred in one `write` call, which is `0x7ffff000`

/// on both 64-bit and 32-bit systems. This is due to using a signed C int as the return value, as

/// well as stuffing the errno codes into the last `4096` values. This is noted on the `write` man page.

/// The limit on Darwin is `0x7fffffff`, trying to read more than that returns EINVAL.

/// The corresponding POSIX limit is `math.maxInt(isize)`.

pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {

if (bytes.len == 0) return 0;

if (builtin.os.tag == .windows) {

return windows.WriteFile(fd, bytes, null);

}

 

if (builtin.os.tag == .wasi and !builtin.link_libc) {

const ciovs = [_]iovec_const{iovec_const{

.iov_base = bytes.ptr,

.iov_len = bytes.len,

}};

var nwritten: usize = undefined;

switch (wasi.fd_write(fd, &ciovs, ciovs.len, &nwritten)) {

.SUCCESS => return nwritten,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable,

.BADF => return error.NotOpenForWriting, // can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

};

while (true) {

const rc = system.write(fd, bytes.ptr, @min(bytes.len, max_count));

switch (errno(rc)) {

.SUCCESS => return @intCast(rc),

.INTR => continue,

.INVAL => return error.InvalidArgument,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForWriting, // can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.CONNRESET => return error.ConnectionResetByPeer,

.BUSY => return error.DeviceBusy,

else => |err| return unexpectedErrno(err),

}

}

}

 

/// Write multiple buffers to a file descriptor.

/// Retries when interrupted by a signal.

/// Returns the number of bytes written. If nonzero bytes were supplied, this will be nonzero.

///

/// Note that a successful write() may transfer fewer bytes than supplied. Such partial writes can

/// occur for various reasons; for example, because there was insufficient space on the disk

/// device to write all of the requested bytes, or because a blocked write() to a socket, pipe, or

/// similar was interrupted by a signal handler after it had transferred some, but before it had

/// transferred all of the requested bytes. In the event of a partial write, the caller can make

/// another write() call to transfer the remaining bytes. The subsequent call will either

/// transfer further bytes or may result in an error (e.g., if the disk is now full).

///

/// For POSIX systems, if `fd` is opened in non blocking mode, the function will

/// return error.WouldBlock when EAGAIN is received.

/// On Windows, if the application has a global event loop enabled, I/O Completion Ports are

/// used to perform the I/O. `error.WouldBlock` is not possible on Windows.

///

/// If `iov.len` is larger than `IOV_MAX`, a partial write will occur.

///

/// This function assumes that all vectors, including zero-length vectors, have

/// a pointer within the address space of the application.

pub fn writev(fd: fd_t, iov: []const iovec_const) WriteError!usize {

if (builtin.os.tag == .windows) {

// TODO improve this to use WriteFileScatter

if (iov.len == 0) return 0;

const first = iov[0];

return write(fd, first.iov_base[0..first.iov_len]);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

var nwritten: usize = undefined;

switch (wasi.fd_write(fd, iov.ptr, iov.len, &nwritten)) {

.SUCCESS => return nwritten,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable,

.BADF => return error.NotOpenForWriting, // can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

while (true) {

const rc = system.writev(fd, iov.ptr, @min(iov.len, IOV_MAX));

switch (errno(rc)) {

.SUCCESS => return @intCast(rc),

.INTR => continue,

.INVAL => return error.InvalidArgument,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForWriting, // Can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.CONNRESET => return error.ConnectionResetByPeer,

.BUSY => return error.DeviceBusy,

else => |err| return unexpectedErrno(err),

}

}

}

 

pub const PWriteError = WriteError || error{Unseekable};

 

/// Write to a file descriptor, with a position offset.

/// Retries when interrupted by a signal.

/// Returns the number of bytes written. If nonzero bytes were supplied, this will be nonzero.

///

/// Note that a successful write() may transfer fewer bytes than supplied. Such partial writes can

/// occur for various reasons; for example, because there was insufficient space on the disk

/// device to write all of the requested bytes, or because a blocked write() to a socket, pipe, or

/// similar was interrupted by a signal handler after it had transferred some, but before it had

/// transferred all of the requested bytes. In the event of a partial write, the caller can make

/// another write() call to transfer the remaining bytes. The subsequent call will either

/// transfer further bytes or may result in an error (e.g., if the disk is now full).

///

/// For POSIX systems, if `fd` is opened in non blocking mode, the function will

/// return error.WouldBlock when EAGAIN is received.

/// On Windows, if the application has a global event loop enabled, I/O Completion Ports are

/// used to perform the I/O. `error.WouldBlock` is not possible on Windows.

///

/// Linux has a limit on how many bytes may be transferred in one `pwrite` call, which is `0x7ffff000`

/// on both 64-bit and 32-bit systems. This is due to using a signed C int as the return value, as

/// well as stuffing the errno codes into the last `4096` values. This is noted on the `write` man page.

/// The limit on Darwin is `0x7fffffff`, trying to write more than that returns EINVAL.

/// The corresponding POSIX limit is `math.maxInt(isize)`.

pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {

if (bytes.len == 0) return 0;

if (builtin.os.tag == .windows) {

return windows.WriteFile(fd, bytes, offset);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

const ciovs = [1]iovec_const{iovec_const{

.iov_base = bytes.ptr,

.iov_len = bytes.len,

}};

 

var nwritten: usize = undefined;

switch (wasi.fd_pwrite(fd, &ciovs, ciovs.len, offset, &nwritten)) {

.SUCCESS => return nwritten,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable,

.BADF => return error.NotOpenForWriting, // can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

// Prevent EINVAL.

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

};

 

const pwrite_sym = if (lfs64_abi) system.pwrite64 else system.pwrite;

while (true) {

const rc = pwrite_sym(fd, bytes.ptr, @min(bytes.len, max_count), @bitCast(offset));

switch (errno(rc)) {

.SUCCESS => return @intCast(rc),

.INTR => continue,

.INVAL => return error.InvalidArgument,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForWriting, // Can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

.BUSY => return error.DeviceBusy,

else => |err| return unexpectedErrno(err),

}

}

}

 

/// Write multiple buffers to a file descriptor, with a position offset.

/// Retries when interrupted by a signal.

/// Returns the number of bytes written. If nonzero bytes were supplied, this will be nonzero.

///

/// Note that a successful write() may transfer fewer than count bytes. Such partial writes can

/// occur for various reasons; for example, because there was insufficient space on the disk

/// device to write all of the requested bytes, or because a blocked write() to a socket, pipe, or

/// similar was interrupted by a signal handler after it had transferred some, but before it had

/// transferred all of the requested bytes. In the event of a partial write, the caller can make

/// another write() call to transfer the remaining bytes. The subsequent call will either

/// transfer further bytes or may result in an error (e.g., if the disk is now full).

///

/// If `fd` is opened in non blocking mode, the function will

/// return error.WouldBlock when EAGAIN is received.

///

/// The following systems do not have this syscall, and will return partial writes if more than one

/// vector is provided:

/// * Darwin

/// * Windows

///

/// If `iov.len` is larger than `IOV_MAX`, a partial write will occur.

pub fn pwritev(fd: fd_t, iov: []const iovec_const, offset: u64) PWriteError!usize {

const have_pwrite_but_not_pwritev = switch (builtin.os.tag) {

.windows, .macos, .ios, .watchos, .tvos, .haiku => true,

else => false,

};

 

if (have_pwrite_but_not_pwritev) {

// We could loop here; but proper usage of `pwritev` must handle partial writes anyway.

// So we simply write the first vector only.

if (iov.len == 0) return 0;

const first = iov[0];

return pwrite(fd, first.iov_base[0..first.iov_len], offset);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

var nwritten: usize = undefined;

switch (wasi.fd_pwrite(fd, iov.ptr, iov.len, offset, &nwritten)) {

.SUCCESS => return nwritten,

.INTR => unreachable,

.INVAL => unreachable,

.FAULT => unreachable,

.AGAIN => unreachable,

.BADF => return error.NotOpenForWriting, // Can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

.NOTCAPABLE => return error.AccessDenied,

else => |err| return unexpectedErrno(err),

}

}

 

const pwritev_sym = if (lfs64_abi) system.pwritev64 else system.pwritev;

while (true) {

const rc = pwritev_sym(fd, iov.ptr, @min(iov.len, IOV_MAX), @bitCast(offset));

switch (errno(rc)) {

.SUCCESS => return @intCast(rc),

.INTR => continue,

.INVAL => return error.InvalidArgument,

.FAULT => unreachable,

.AGAIN => return error.WouldBlock,

.BADF => return error.NotOpenForWriting, // Can be a race condition.

.DESTADDRREQ => unreachable, // `connect` was never called.

.DQUOT => return error.DiskQuota,

.FBIG => return error.FileTooBig,

.IO => return error.InputOutput,

.NOSPC => return error.NoSpaceLeft,

.PERM => return error.AccessDenied,

.PIPE => return error.BrokenPipe,

.NXIO => return error.Unseekable,

.SPIPE => return error.Unseekable,

.OVERFLOW => return error.Unseekable,

.BUSY => return error.DeviceBusy,

else => |err| return unexpectedErrno(err),

}

}

}

 

pub const OpenError = error{

/// In WASI, this error may occur when the file descriptor does

/// not hold the required rights to open a new resource relative to it.

AccessDenied,

SymLinkLoop,

ProcessFdQuotaExceeded,

SystemFdQuotaExceeded,

NoDevice,

FileNotFound,

 

/// The path exceeded `MAX_PATH_BYTES` bytes.

NameTooLong,

 

/// Insufficient kernel memory was available, or

/// the named file is a FIFO and per-user hard limit on

/// memory allocation for pipes has been reached.

SystemResources,

 

/// The file is too large to be opened. This error is unreachable

/// for 64-bit targets, as well as when opening directories.

FileTooBig,

 

/// The path refers to directory but the `DIRECTORY` flag was not provided.

IsDir,

 

/// A new path cannot be created because the device has no room for the new file.

/// This error is only reachable when the `CREAT` flag is provided.

NoSpaceLeft,

 

/// A component used as a directory in the path was not, in fact, a directory, or

/// `DIRECTORY` was specified and the path was not a directory.

NotDir,

 

/// The path already exists and the `CREAT` and `EXCL` flags were provided.

PathAlreadyExists,

DeviceBusy,

 

/// The underlying filesystem does not support file locks

FileLocksNotSupported,

 

/// Path contains characters that are disallowed by the underlying filesystem.

BadPathName,

 

/// WASI-only; file paths must be valid UTF-8.

InvalidUtf8,

 

/// Windows-only; file paths provided by the user must be valid WTF-8.

/// https://simonsapin.github.io/wtf-8/

InvalidWtf8,

 

/// On Windows, `\\server` or `\\server\share` was not found.

NetworkNotFound,