字段
backing_allocator_needs_mutex: bool
backing_allocator_mutex: Io.Mutex
backing_allocator: Allocator若未在其他地方使用,则无需线程安全。
main_fiber_buffer: [
std.mem.alignForward(usize, @sizeOf(Fiber), @alignOf(Completion)) + @sizeOf(Completion)
]u8 align(@max(@alignOf(Fiber), @alignOf(Completion)))
log2_ring_entries: u4
threads: Thread.List
sync_limit: ?Io.Semaphore
stderr_writer_initialized: bool = false
stderr_mutex: Io.Mutex
stderr_writer: File.Writer = .{
.io = undefined,
.interface = Io.File.Writer.initInterface(&.{}),
.file = .stderr(),
.mode = .streaming,
}
stderr_mode: Io.Terminal.Mode = .no_color
environ_mutex: Io.Mutex
environ_initialized: bool
environ: Environ
null_fd: CachedFd
random_fd: CachedFd
csprng_mutex: Io.Mutex
csprng: Csprng
addressFromPosixaddressToPosixAlignmentAllocatorArgv0assertbuiltinChdirErrorclockToPosixCsprngdefault_PATHDirEnvironerrnoBugEventedfallbackSeedfd_tFileIoIoUringioveciovec_constlinuxlinux_statx_requestLOCKlogmax_iovecs_lennanosecondsFromPosixnetPATH_MAXpathToPosixpid_tPosixAddressposixAddressFamilyposixSocketModeProtocolprocessrecoverableOsBugDetectedsetTimestampToPosixsplat_buffer_sizestatFromLinuxstatxKindstdtimestampFromPosixunexpectedErrnowinsizetracyidle_stack_sizemax_idle_searchmax_steal_ready_searchmax_steal_free_searchThreadFiberCancelRegionCachedFdallocatorallocresizeremapfreeioInitOptionsinitdeinitfindReadyFiberyieldschedulethreadEntryCompletionmainIdleEntrymainIdleidleSwitchMessagecontextSwitchcrashHandlerAsyncClosureasyncconcurrentawaitcancelGroupgroupAsyncgroupConcurrentgroupAwaitgroupCancelrecancelswapCancelProtectioncheckCancelfutexWaitfutexWaitUncancelablefutexWakeoperatefileReadStreamingfileWriteStreamingdeviceIoControlbatchAwaitAsyncbatchAwaitConcurrentbatchDrainSubmittedbatchDrainReadybatchCanceldirCreateDirdirCreateDirPathfilePathKinddirCreateDirPathOpendirOpenDirdirStatdirStatFiledirAccessdirCreateFiledirCreateFileAtomicatomicFileInitdirOpenFiledirClosedirReaddirRealPathdirRealPathFiledirDeleteFiledirDeleteDirdirRenamedirRenamePreservedirSymLinkdirReadLinkdirSetOwnerdirSetFileOwnerdirSetPermissionsdirSetFilePermissionsdirSetTimestampsdirHardLinkfileStatfileLengthfileClosefileWritePositionaliovlen_taddBuffileWriteFileStreamingfileWriteFilePositionalfileReadPositionalfileSeekByfileSeekTofileSyncfileIsTtyfileEnableAnsiEscapeCodesfileSetLengthfileSetOwnerfileSetPermissionsfileSetTimestampsfileLockfileTryLockfileUnlockfileDowngradeLockfileRealPathfileHardLinkfileMemoryMapCreatefileMemoryMapDestroyfileMemoryMapSetLengthfileMemoryMapReadfileMemoryMapWriteprocessExecutableOpenprocessExecutablePathlockStderrtryLockStderrinitLockedStderrunlockStderrprocessCurrentPathprocessSetCurrentDirprocessSetCurrentPathprocessReplaceprocessSpawnprog_filenoSpawnedspawnPipeErrorpipe2destroyPipeForkBailErrorsetUpChildsetUpChildIosetFdFlagsDupErrordup2processExecprocessExecveatchildWaitchildKillchildCleanupprogressParentFileinheritParentHandleinheritParentDirinheritParentFilescanEnvironclockResolutionnowsleeprandomrandomSecurenetListenIpUnavailablenetAcceptUnavailablenetBindIpnetConnectIpUnavailablenetListenUnixUnavailablenetConnectUnixUnavailablenetSocketCreatePairUnavailablenetReceivenetWriteFileUnavailablenetClosenetShutdownnetInterfaceNameResolveUnavailablenetInterfaceNameUnavailablenetLookupUnavailablebindchdirclosecloseAsyncfchdirfchmodatfchownatflockgetsocknamelinkatlseekopenatpreadvpwritevreadAllrealPathrenameatsetsockoptsocketstatstatxurandomReadAllutimensatwriteAllSyncwriteSync
std.Io.Uring.addBuf
函数
fn addBuf(v: []iovec_const, i: *iovlen_t, bytes: []const u8) void
参数
std.Io.Uring.addressFromPosix
别名
std.Io.Uring.addressToPosix
别名
std.Io.Uring.Alignment
别名
别名目标 std.mem.Alignment
std.Io.Uring.alloc
函数
fn alloc(userdata: *anyopaque, len: usize, alignment: std.mem.Alignment, ret_addr: usize) ?[*]u8
参数
std.Io.Uring.allocator
函数
pub fn allocator(ev: *Evented) std.mem.Allocator
参数
ev: *Evented
std.Io.Uring.Allocator
别名
别名目标 std.mem.Allocator
std.Io.Uring.Argv0
别名
std.Io.Uring.assert
别名
别名目标 std.debug.assert
std.Io.Uring.async
函数
fn async( userdata: ?*anyopaque, result: []u8, result_alignment: Alignment, context: []const u8, context_alignment: Alignment, start: *const fn (context: *const anyopaque, result: *anyopaque) void, ) ?*std.Io.AnyFuture
参数
std.Io.Uring.AsyncClosure
容器
字段
std.Io.Uring.AsyncClosure.call
函数
fn call( closure: *AsyncClosure, contexts: *const Io.fiber.Switch, ) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn
参数
closure: *AsyncClosure
contexts: *const Io.fiber.Switch
std.Io.Uring.AsyncClosure.contextPointer
函数
fn contextPointer(closure: *AsyncClosure) [*]align(Fiber.max_context_align.toByteUnits()) u8
参数
closure: *AsyncClosure
std.Io.Uring.AsyncClosure.entry
函数
fn entry() callconv(.naked) void
std.Io.Uring.AsyncClosure.fromFiber
函数
fn fromFiber(fiber: *Fiber) *AsyncClosure
参数
fiber: *Fiber
std.Io.Uring.atomicFileInit
函数
fn atomicFileInit( ev: *Evented, dest_basename: []const u8, permissions: File.Permissions, dir: Dir, close_dir_on_deinit: bool, ) Dir.CreateFileAtomicError!File.Atomic
参数
ev: *Evented
dest_basename: []const u8
permissions: File.Permissions
dir: Dir
close_dir_on_deinit: bool
错误
- AccessDenied
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileBusy
尝试创建的文件是正在运行的可执行文件。
- FileNotFound
以下情况之一:
- 某个路径分量不存在。
- 使用了 Cwd,但当前工作目录已被删除。
- 与已打开目录句柄关联的路径已被删除。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
设备没有空间容纳新文件,无法创建新路径。
- NotDir
路径中作为目录使用的某个组成部分实际上不是目录。
- PermissionDenied
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
可用内核内存不足。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock
std.Io.Uring.await
函数
fn await( userdata: ?*anyopaque, future: *std.Io.AnyFuture, result: []u8, result_alignment: Alignment, ) void
参数
std.Io.Uring.batchAwaitAsync
函数
fn batchAwaitAsync(userdata: ?*anyopaque, batch: *Io.Batch) Io.Cancelable!void
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.batchAwaitConcurrent
函数
fn batchAwaitConcurrent( userdata: ?*anyopaque, batch: *Io.Batch, timeout: Io.Timeout, ) Io.Batch.AwaitConcurrentError!void
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- ConcurrencyUnavailable ConcurrentError
可能由资源耗尽等临时情况引起,也可能因为 Io 实现不支持并发。
- Timeout Error
std.Io.Uring.batchCancel
函数
fn batchCancel(userdata: ?*anyopaque, batch: *Io.Batch) void
参数
std.Io.Uring.batchDrainReady
函数
fn batchDrainReady(batch: *Io.Batch) Io.Timeout.Error!void
参数
错误
- Timeout
std.Io.Uring.batchDrainSubmitted
函数
若 concurrency 为 false,则 error.ConcurrencyUnavailable 不可达。
fn batchDrainSubmitted( ev: *Evented, maybe_sync: *CancelRegion.Sync.Maybe, batch: *Io.Batch, concurrency: bool, ) (Io.ConcurrentError || Io.Cancelable)!void
参数
std.Io.Uring.bind
函数
fn bind( ev: *Evented, cancel_region: *CancelRegion, socket_fd: fd_t, addr: *const linux.sockaddr, addr_len: linux.socklen_t, ) !void
参数
std.Io.Uring.builtin
常量
std.Io.Uring.CachedFd
容器
字段
once: Once
std.Io.Uring.CachedFd.close
函数
fn close(cached_fd: *CachedFd) void
参数
cached_fd: *CachedFd
std.Io.Uring.CachedFd.init
常量
CachedFd
std.Io.Uring.CachedFd.Once
容器
字段
uninitialized = -1
initializing = -2
_fd
std.Io.Uring.CachedFd.Once.fromFd
函数
fn fromFd(fd: fd_t) Once
参数
fd: fd_t
std.Io.Uring.CachedFd.Once.toFd
函数
fn toFd(once: Once) fd_t
参数
once: Once
std.Io.Uring.CachedFd.open
函数
fn open( cached_fd: *CachedFd, ev: *Evented, cancel_region: *CancelRegion, path: [*:0]const u8, flags: linux.O, ) File.OpenError!fd_t
参数
错误
- AccessDenied
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy
- FileBusy
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported
- FileNotFound
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileTooBig
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- IsDir
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- PathAlreadyExists
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied
- PipeBusy
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.cancel
函数
fn cancel( userdata: ?*anyopaque, future: *std.Io.AnyFuture, result: []u8, result_alignment: Alignment, ) void
参数
std.Io.Uring.CancelRegion
容器
字段
fiber: *Fiber
status: Fiber.CancelStatus
std.Io.Uring.CancelRegion.await
函数
fn await(cancel_region: *CancelRegion, awaiting: Fiber.CancelStatus.Awaiting) Io.Cancelable!void
参数
cancel_region: *CancelRegion
awaiting: Fiber.CancelStatus.Awaiting
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.CancelRegion.awaitIoUring
函数
fn awaitIoUring(cancel_region: *CancelRegion) Io.Cancelable!*Thread
参数
cancel_region: *CancelRegion
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.CancelRegion.completion
函数
fn completion(cancel_region: *const CancelRegion) Completion
参数
cancel_region: *const CancelRegion
std.Io.Uring.CancelRegion.deinit
函数
fn deinit(cancel_region: *CancelRegion) void
参数
cancel_region: *CancelRegion
std.Io.Uring.CancelRegion.errno
函数
fn errno(cancel_region: *const CancelRegion) linux.E
参数
cancel_region: *const CancelRegion
std.Io.Uring.CancelRegion.init
函数
fn init() CancelRegion
std.Io.Uring.CancelRegion.initBlocked
函数
fn initBlocked() CancelRegion
std.Io.Uring.CancelRegion.Sync
容器
字段
cancel_region: CancelRegion
std.Io.Uring.CancelRegion.Sync.deinit
函数
fn deinit(sync: *Sync, ev: *Evented) void
参数
std.Io.Uring.CancelRegion.Sync.init
函数
fn init(ev: *Evented) Io.Cancelable!Sync
参数
ev: *Evented
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.CancelRegion.Sync.initBlocked
函数
fn initBlocked(ev: *Evented) Sync
参数
ev: *Evented
std.Io.Uring.CancelRegion.Sync.Maybe
容器
字段
cancel_region: CancelRegion
sync: Sync
std.Io.Uring.CancelRegion.Sync.Maybe.cancelRegion
函数
fn cancelRegion(maybe: *Maybe) *CancelRegion
参数
maybe: *Maybe
std.Io.Uring.CancelRegion.Sync.Maybe.deinit
函数
fn deinit(maybe: *Maybe, ev: *Evented) void
参数
std.Io.Uring.CancelRegion.Sync.Maybe.enterSync
函数
fn enterSync(maybe: *Maybe, ev: *Evented) Io.Cancelable!*Sync
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.CancelRegion.Sync.Maybe.leaveSync
函数
fn leaveSync(maybe: *Maybe, ev: *Evented) void
参数
std.Io.Uring.chdir
函数
fn chdir(sync: *CancelRegion.Sync, path: [*:0]const u8) ChdirError!void
参数
sync: *CancelRegion.Sync
path: [*:0]const u8
错误
- AccessDenied ChdirError
- BadPathName ChdirError
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound ChdirError
- FileSystem ChdirError
- NameTooLong ChdirError
- NotDir ChdirError
- SymLinkLoop ChdirError
- SystemResources ChdirError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.ChdirError
别名
std.Io.Uring.checkCancel
函数
fn checkCancel(userdata: ?*anyopaque) Io.Cancelable!void
参数
userdata: ?*anyopaque
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.childCleanup
函数
fn childCleanup(ev: *Evented, child: *process.Child) void
参数
std.Io.Uring.childKill
函数
fn childKill(userdata: ?*anyopaque, child: *process.Child) void
参数
std.Io.Uring.childWait
函数
fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitError!process.Child.Term
参数
错误
- AccessDenied
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.clockResolution
函数
fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration
参数
错误
- ClockUnavailable
- Unexpected
std.Io.Uring.clockToPosix
别名
std.Io.Uring.close
函数
fn close(ev: *Evented, fd: fd_t) void
参数
std.Io.Uring.closeAsync
函数
fn closeAsync(ev: *Evented, fd: fd_t) void
参数
std.Io.Uring.Completion
容器
字段
result: i32
flags: u32
std.Io.Uring.Completion.errno
函数
fn errno(completion: Completion) linux.E
参数
completion: Completion
std.Io.Uring.Completion.Userdata
容器
字段
unused
wakeup
futex_wake
close
cleanup
exit
_若位 0 为 1,则是指向 Io.Batch.Storage.Pending 的 context 字段的指针。
若位 0 和位 1 均为 0,则是 *Fiber。
std.Io.Uring.concurrent
函数
fn concurrent( userdata: ?*anyopaque, result_len: usize, result_alignment: Alignment, context: []const u8, context_alignment: Alignment, start: *const fn (context: *const anyopaque, result: *anyopaque) void, ) Io.ConcurrentError!*std.Io.AnyFuture
参数
userdata: ?*anyopaque
result_len: usize
result_alignment: Alignment
context: []const u8
context_alignment: Alignment
start: *const fn (context: *const anyopaque, result: *anyopaque) void
错误
- ConcurrencyUnavailable
可能由资源耗尽等临时情况引起,也可能因为 Io 实现不支持并发。
std.Io.Uring.contextSwitch
函数
inline fn contextSwitch(message: *const SwitchMessage) *const SwitchMessage
参数
message: *const SwitchMessage
std.Io.Uring.crashHandler
函数
fn crashHandler(userdata: ?*anyopaque) void
参数
userdata: ?*anyopaque
std.Io.Uring.Csprng
别名
std.Io.Uring.default_PATH
别名
std.Io.Uring.deinit
函数
pub fn deinit(ev: *Evented) void
参数
ev: *Evented
std.Io.Uring.destroyPipe
函数
fn destroyPipe(ev: *Evented, pipe: [2]fd_t) void
参数
std.Io.Uring.deviceIoControl
函数
fn deviceIoControl( ev: *Evented, sync: *CancelRegion.Sync, o: Io.Operation.DeviceIoControl, ) Io.Cancelable!i32
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.Dir
别名
别名目标 std.Io.Dir
std.Io.Uring.dirAccess
函数
fn dirAccess( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.AccessOptions, ) Dir.AccessError!void
参数
错误
- AccessDenied
文件不允许请求的
AccessOptions,或路径前缀中的 某个目录不允许搜索。- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileBusy
- FileNotFound
- InputOutput
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- PermissionDenied
请求了写入权限,但文件不可变。
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirClose
函数
fn dirClose(userdata: ?*anyopaque, dirs: []const Dir) void
参数
userdata: ?*anyopaque
dirs: []const Dir
std.Io.Uring.dirCreateDir
函数
fn dirCreateDir( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions, ) Dir.CreateDirError!void
参数
错误
- AccessDenied
在 WASI 中,当文件描述符不具备相对于自身 创建新目录所需的权限时,可能发生此错误。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DiskQuota
- FileNotFound
- LinkQuotaExceeded
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
- NotDir
- PathAlreadyExists
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirCreateDirPath
函数
fn dirCreateDirPath( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions, ) Dir.CreateDirPathError!Dir.CreatePathStatus
参数
错误
- AccessDenied CreateDirError
在 WASI 中,当文件描述符不具备相对于自身 创建新目录所需的权限时,可能发生此错误。
- AntivirusInterference OpenError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy OpenError
- DiskQuota CreateDirError
- FileBusy OpenError
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported OpenError
- FileNotFound OpenError
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileTooBig OpenError
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- IsDir OpenError
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- LinkQuotaExceeded CreateDirError
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound CreateDirError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice CreateDirError
- NoSpaceLeft OpenError
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir OpenError
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- PathAlreadyExists OpenError
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied CreateDirError
- PipeBusy OpenError
- ProcessFdQuotaExceeded OpenError
- ReadOnlyFileSystem CreateDirError
- Streaming StatError
尝试对非文件流调用 stat。
- SymLinkLoop CreateDirError
- SystemFdQuotaExceeded OpenError
- SystemResources OpenError
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock OpenError
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.dirCreateDirPathOpen
函数
fn dirCreateDirPathOpen( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions, options: Dir.OpenOptions, ) Dir.CreateDirPathOpenError!Dir
参数
userdata: ?*anyopaque
dir: Dir
sub_path: []const u8
permissions: Dir.Permissions
options: Dir.OpenOptions
错误
- AccessDenied CreateDirError
在 WASI 中,当文件描述符不具备相对于自身 创建新目录所需的权限时,可能发生此错误。
- AntivirusInterference OpenError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy OpenError
- DiskQuota CreateDirError
- FileBusy OpenError
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported OpenError
- FileNotFound OpenError
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileTooBig OpenError
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- IsDir OpenError
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- LinkQuotaExceeded CreateDirError
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound CreateDirError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice CreateDirError
- NoSpaceLeft OpenError
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir OpenError
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- PathAlreadyExists OpenError
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied CreateDirError
- PipeBusy OpenError
- ProcessFdQuotaExceeded OpenError
- ReadOnlyFileSystem CreateDirError
- Streaming StatError
尝试对非文件流调用 stat。
- SymLinkLoop CreateDirError
- SystemFdQuotaExceeded OpenError
- SystemResources OpenError
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock OpenError
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.dirCreateFile
函数
fn dirCreateFile( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.CreateFileOptions, ) File.OpenError!File
参数
错误
- AccessDenied
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy
- FileBusy
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported
- FileNotFound
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileTooBig
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- IsDir
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- PathAlreadyExists
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied
- PipeBusy
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.dirCreateFileAtomic
函数
fn dirCreateFileAtomic( userdata: ?*anyopaque, dir: Dir, dest_path: []const u8, options: Dir.CreateFileAtomicOptions, ) Dir.CreateFileAtomicError!File.Atomic
参数
错误
- AccessDenied
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileBusy
尝试创建的文件是正在运行的可执行文件。
- FileNotFound
以下情况之一:
- 某个路径分量不存在。
- 使用了 Cwd,但当前工作目录已被删除。
- 与已打开目录句柄关联的路径已被删除。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
设备没有空间容纳新文件,无法创建新路径。
- NotDir
路径中作为目录使用的某个组成部分实际上不是目录。
- PermissionDenied
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
可用内核内存不足。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock
std.Io.Uring.dirDeleteDir
函数
fn dirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void
参数
错误
- AccessDenied
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DirNotEmpty
- FileBusy
- FileNotFound
- FileSystem
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NotDir
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirDeleteFile
函数
fn dirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void
参数
错误
- AccessDenied
在 WASI 中,若文件描述符不具有通过相对于它的路径 解除资源链接所需的权限,可能发生此错误。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileBusy
- FileNotFound
- FileSystem
- IsDir
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NotDir
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirHardLink
函数
fn dirHardLink( userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, options: Dir.HardLinkOptions, ) Dir.HardLinkError!void
参数
userdata: ?*anyopaque
old_dir: Dir
old_sub_path: []const u8
new_dir: Dir
new_sub_path: []const u8
options: Dir.HardLinkOptions
错误
- AccessDenied HardLinkError
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- CrossDevice HardLinkError
- DiskQuota HardLinkError
- FileNotFound HardLinkError
- HardwareFailure HardLinkError
- LinkQuotaExceeded HardLinkError
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NoSpaceLeft HardLinkError
- NotDir HardLinkError
- OperationUnsupported HardLinkError
操作系统或文件系统不支持硬链接。
- PathAlreadyExists HardLinkError
- PermissionDenied HardLinkError
- ReadOnlyFileSystem HardLinkError
- SymLinkLoop HardLinkError
- SystemResources HardLinkError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirOpenDir
函数
fn dirOpenDir( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.OpenOptions, ) Dir.OpenError!Dir
参数
错误
- AccessDenied
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NotDir
- PermissionDenied
- ProcessFdQuotaExceeded
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirOpenFile
函数
fn dirOpenFile( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, flags: Dir.OpenFileOptions, ) File.OpenError!File
参数
错误
- AccessDenied
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy
- FileBusy
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported
- FileNotFound
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileTooBig
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- IsDir
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- PathAlreadyExists
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied
- PipeBusy
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.dirRead
函数
fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize
参数
错误
- AccessDenied
- Canceled Cancelable
调用方请求停止异步操作。
- PermissionDenied
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirReadLink
函数
fn dirReadLink( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, buffer: []u8, ) Dir.ReadLinkError!usize
参数
错误
- AccessDenied
在 WASI 中,若文件描述符不具有相对于该描述符读取符号链接值所需的权限,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileBusy
尝试打开的文件是正在运行的可执行文件。
- FileNotFound
- FileSystem
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NotDir
- NotLink
- PermissionDenied
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnsupportedReparsePointType
仅限 Windows。如果打开的重解析点类型不受支持, 可能发生此错误。
std.Io.Uring.dirRealPath
函数
fn dirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize
参数
错误
- AccessDenied RealPathError
- AntivirusInterference RealPathError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy RealPathError
- FileBusy RealPathError
- FileNotFound RealPathError
- FileSystem RealPathError
- FileTooBig RealPathError
- InputOutput RealPathError
- IsDir RealPathError
- NameTooLong RealPathError
完整文件系统路径无法放入所提供的缓冲区,或 由于路径过长,无论提供多大的缓冲区, 均无法通过 realpath 函数获取。
- NetworkNotFound RealPathError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice RealPathError
- NoSpaceLeft RealPathError
- NotDir RealPathError
- OperationUnsupported RealPathError
此操作系统、文件系统或
Io实现 不支持 realpath 操作。- PathAlreadyExists RealPathError
- PermissionDenied RealPathError
- PipeBusy RealPathError
- ProcessFdQuotaExceeded RealPathError
- SymLinkLoop RealPathError
- SystemFdQuotaExceeded RealPathError
- SystemResources RealPathError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume RealPathError
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
std.Io.Uring.dirRealPathFile
函数
fn dirRealPathFile( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, out_buffer: []u8, ) Dir.RealPathFileError!usize
参数
错误
- AccessDenied RealPathError
- AntivirusInterference RealPathError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy RealPathError
- FileBusy RealPathError
- FileNotFound RealPathError
- FileSystem RealPathError
- FileTooBig RealPathError
- InputOutput RealPathError
- IsDir RealPathError
- NameTooLong RealPathError
完整文件系统路径无法放入所提供的缓冲区,或 由于路径过长,无论提供多大的缓冲区, 均无法通过 realpath 函数获取。
- NetworkNotFound RealPathError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice RealPathError
- NoSpaceLeft RealPathError
- NotDir RealPathError
- OperationUnsupported RealPathError
此操作系统、文件系统或
Io实现 不支持 realpath 操作。- PathAlreadyExists RealPathError
- PermissionDenied RealPathError
- PipeBusy RealPathError
- ProcessFdQuotaExceeded RealPathError
- SymLinkLoop RealPathError
- SystemFdQuotaExceeded RealPathError
- SystemResources RealPathError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume RealPathError
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
std.Io.Uring.dirRename
函数
fn dirRename( userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, ) Dir.RenameError!void
参数
错误
- AccessDenied
在 WASI 中,当文件描述符不具备相对于自身 按路径重命名资源所需的权限时,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- CrossDevice
- DirNotEmpty
试图替换非空目录。
- DiskQuota
- FileBusy
尝试移动或替换的文件是正在运行的可执行文件。
- FileNotFound
- HardwareFailure
- IsDir
- LinkQuotaExceeded
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
- NotDir
- PermissionDenied
- PipeBusy
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirRenamePreserve
函数
fn dirRenamePreserve( userdata: ?*anyopaque, old_dir: Dir, old_sub_path: []const u8, new_dir: Dir, new_sub_path: []const u8, ) Dir.RenamePreserveError!void
参数
错误
- AccessDenied
在 WASI 中,当文件描述符不具有 按相对于该描述符的路径重命名资源所需的权限时,可能发生此错误。
在 Windows 上,将目录重命名并覆盖已有目录时, 可能返回此错误,而不是 PathAlreadyExists。
在 Darwin 上,如果任一路径中的分量指向需要实体化的 “无数据”目录,而当前线程或进程的 I/O 策略不允许无数据目录实体化,则可能返回此错误。
- AntivirusInterference RenameError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- CrossDevice RenameError
- DirNotEmpty RenameError
试图替换非空目录。
- DiskQuota RenameError
- FileBusy RenameError
尝试移动或替换的文件是正在运行的可执行文件。
- FileNotFound RenameError
- HardwareFailure RenameError
- IsDir RenameError
- LinkQuotaExceeded RenameError
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound RenameError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice RenameError
- NoSpaceLeft RenameError
- NotDir RenameError
- OperationUnsupported
操作系统或文件系统不支持原子地执行不替换目标的重命名。
- PathAlreadyExists
- PermissionDenied RenameError
- PipeBusy RenameError
- ReadOnlyFileSystem RenameError
- SymLinkLoop RenameError
- SystemResources RenameError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirSetFileOwner
函数
fn dirSetFileOwner( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, owner: ?File.Uid, group: ?File.Gid, options: Dir.SetFileOwnerOptions, ) Dir.SetFileOwnerError!void
参数
userdata: ?*anyopaque
dir: Dir
sub_path: []const u8
owner: ?File.Uid
group: ?File.Gid
options: Dir.SetFileOwnerOptions
错误
- AccessDenied SetOwnerError
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound SetOwnerError
- InputOutput SetOwnerError
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- PermissionDenied SetOwnerError
- ReadOnlyFileSystem SetOwnerError
- SymLinkLoop SetOwnerError
- SystemResources SetOwnerError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirSetFilePermissions
函数
fn dirSetFilePermissions( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, permissions: Dir.Permissions, options: Dir.SetFilePermissionsOptions, ) Dir.SetFilePermissionsError!void
参数
userdata: ?*anyopaque
dir: Dir
sub_path: []const u8
permissions: Dir.Permissions
options: Dir.SetFilePermissionsOptions
错误
- AccessDenied SetPermissionsError
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound SetPermissionsError
- InputOutput SetPermissionsError
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- OperationUnsupported
SetFilePermissionsOptions.follow_symlinks被设为 false,但文件系统或操作系统不允许。- PermissionDenied SetPermissionsError
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem SetPermissionsError
- SymLinkLoop SetPermissionsError
- SystemFdQuotaExceeded
- SystemResources SetPermissionsError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirSetOwner
函数
fn dirSetOwner( userdata: ?*anyopaque, dir: Dir, owner: ?File.Uid, group: ?File.Gid, ) Dir.SetOwnerError!void
参数
错误
- AccessDenied SetOwnerError
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound SetOwnerError
- InputOutput SetOwnerError
- PermissionDenied SetOwnerError
- ReadOnlyFileSystem SetOwnerError
- SymLinkLoop SetOwnerError
- SystemResources SetOwnerError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirSetPermissions
函数
fn dirSetPermissions( userdata: ?*anyopaque, dir: Dir, permissions: Dir.Permissions, ) Dir.SetPermissionsError!void
参数
错误
- AccessDenied SetPermissionsError
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound SetPermissionsError
- InputOutput SetPermissionsError
- PermissionDenied SetPermissionsError
- ReadOnlyFileSystem SetPermissionsError
- SymLinkLoop SetPermissionsError
- SystemResources SetPermissionsError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirSetTimestamps
函数
fn dirSetTimestamps( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.SetTimestampsOptions, ) Dir.SetTimestampsError!void
参数
错误
- AccessDenied SetTimestampsError
times 为 NULL,或两个 nsec 值均为 UTIME_NOW,且满足以下之一:
- 调用方的有效用户标识符与文件 所有者不匹配,调用方不具有该文件的 写入权限,且调用方不具有特权;Linux 上即不具备 CAP_FOWNER 或 CAP_DAC_OVERRIDE 任一能力; 或者,
- 文件被标记为不可变,参见 chattr(1)。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- PermissionDenied SetTimestampsError
调用方尝试将一个或两个时间戳设置为当前时间 以外的值,或将一个时间戳 设为当前时间而保持另一个不变, 即 times 非 NULL,两个 nsec 字段均非 UTIME_NOW, 且两个 nsec 字段均非 UTIME_OMIT,同时满足以下任一条件:
- 调用方的有效用户 ID 不等于文件 所有者,且调用方无特权;Linux 上 指不具备 CAP_FOWNER 能力。
- 文件被标记为仅追加或不可变,参见 chattr(1)。
- ReadOnlyFileSystem SetTimestampsError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirStat
函数
fn dirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat
参数
userdata: ?*anyopaque
dir: Dir
错误
- AccessDenied StatError
在 WASI 中,当文件描述符不具备获取自身 filestat 信息所需的权限时,可能发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- PermissionDenied StatError
- Streaming StatError
尝试对非文件流调用 stat。
- SystemResources StatError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dirStatFile
函数
fn dirStatFile( userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, options: Dir.StatFileOptions, ) Dir.StatFileError!File.Stat
参数
错误
- AccessDenied OpenError
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference OpenError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy OpenError
- FileBusy OpenError
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported OpenError
- FileNotFound OpenError
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileTooBig OpenError
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- IsDir OpenError
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound OpenError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice OpenError
- NoSpaceLeft OpenError
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir OpenError
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- PathAlreadyExists OpenError
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied OpenError
- PipeBusy OpenError
- ProcessFdQuotaExceeded OpenError
- ReadOnlyFileSystem OpenError
- Streaming StatError
尝试对非文件流调用 stat。
- SymLinkLoop OpenError
- SystemFdQuotaExceeded OpenError
- SystemResources OpenError
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock OpenError
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.dirSymLink
函数
fn dirSymLink( userdata: ?*anyopaque, dir: Dir, target_path: []const u8, sym_link_path: []const u8, flags: Dir.SymLinkFlags, ) Dir.SymLinkError!void
参数
userdata: ?*anyopaque
dir: Dir
target_path: []const u8
sym_link_path: []const u8
flags: Dir.SymLinkFlags
错误
- AccessDenied
在 WASI 中,当文件描述符不具备相对于自身 创建新符号链接所需的权限时,可能发生此错误。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DiskQuota
- FileNotFound
- FileSystem
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoSpaceLeft
- NotDir
- PathAlreadyExists
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.dup2
函数
pub fn dup2(sync: *CancelRegion.Sync, old_fd: fd_t, new_fd: fd_t) DupError!void
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- ProcessFdQuotaExceeded
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.DupError
错误集合
错误
- Canceled Cancelable
调用方请求停止异步操作。
- ProcessFdQuotaExceeded
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.Environ
别名
std.Io.Uring.errnoBug
别名
std.Io.Uring.Evented
别名
别名目标 std.Io.Uring
std.Io.Uring.fallbackSeed
别名
std.Io.Uring.fchdir
函数
fn fchdir(sync: *CancelRegion.Sync, dir: fd_t) process.SetCurrentDirError!void
参数
sync: *CancelRegion.Sync
dir: fd_t
错误
- AccessDenied
- BadPathName
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound
- FileSystem
- NameTooLong
- NoDevice
- NotDir
- OperationUnsupported
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume
std.Io.Uring.fchmodat
函数
fn fchmodat( ev: *Evented, sync: *CancelRegion.Sync, dir: fd_t, path: [*:0]const u8, mode: linux.mode_t, flags: u32, ) Dir.SetFilePermissionsError!void
参数
错误
- AccessDenied SetPermissionsError
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound SetPermissionsError
- InputOutput SetPermissionsError
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- OperationUnsupported
SetFilePermissionsOptions.follow_symlinks被设为 false,但文件系统或操作系统不允许。- PermissionDenied SetPermissionsError
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem SetPermissionsError
- SymLinkLoop SetPermissionsError
- SystemFdQuotaExceeded
- SystemResources SetPermissionsError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fchownat
函数
fn fchownat( ev: *Evented, sync: *CancelRegion.Sync, dir: fd_t, path: [*:0]const u8, owner: linux.uid_t, group: linux.gid_t, flags: u32, ) File.SetOwnerError!void
参数
ev: *Evented
sync: *CancelRegion.Sync
dir: fd_t
path: [*:0]const u8
owner: linux.uid_t
group: linux.gid_t
flags: u32
错误
- AccessDenied
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound
- InputOutput
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fd_t
别名
别名目标 std.os.linux.fd_t
std.Io.Uring.Fiber
容器
字段
required_align: void align(4)
context: Io.fiber.Context
link: union {
awaiter: ?*Fiber,
group: struct { prev: ?*Fiber, next: ?*Fiber },
}
status: union(enum) {
queue_next: ?*Fiber,
awaiting_group: Group,
free_next: ?*Fiber,
}
cancel_status: CancelStatus
cancel_protection: CancelProtection
name: if (tracy.enable) [*:0]const u8 else void
std.Io.Uring.Fiber.allocatedEnd
函数
fn allocatedEnd(f: *Fiber) [*]u8
参数
f: *Fiber
std.Io.Uring.Fiber.allocatedSlice
函数
fn allocatedSlice(f: *Fiber) []align(@alignOf(Fiber)) u8
参数
f: *Fiber
std.Io.Uring.Fiber.allocation_size
常量
std.Io.Uring.Fiber.CancelProtection
容器
字段
user: Io.CancelProtection
acknowledged: bool
std.Io.Uring.Fiber.CancelProtection.acknowledge
函数
fn acknowledge(cancel_protection: *CancelProtection) void
参数
cancel_protection: *CancelProtection
std.Io.Uring.Fiber.CancelProtection.check
函数
fn check(cancel_protection: CancelProtection) Io.CancelProtection
参数
cancel_protection: CancelProtection
用法示例
test check {
try std.testing.expectEqual(Io.CancelProtection.unblocked, check(.unblocked));
try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
.user = .unblocked,
.acknowledged = true,
}));
try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
.user = .blocked,
.acknowledged = false,
}));
try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
.user = .blocked,
.acknowledged = true,
}));
}
std.Io.Uring.Fiber.CancelProtection.recancel
函数
fn recancel(cancel_protection: *CancelProtection) void
参数
cancel_protection: *CancelProtection
std.Io.Uring.Fiber.CancelProtection.unblocked
常量
CancelProtection
std.Io.Uring.Fiber.CancelStatus
容器
字段
requested: bool
awaiting: Awaiting
std.Io.Uring.Fiber.CancelStatus.Awaiting
容器
字段
std.Io.Uring.Fiber.CancelStatus.Awaiting.fromIoUringFd
函数
fn fromIoUringFd(fd: fd_t) Awaiting
参数
fd: fd_t
std.Io.Uring.Fiber.CancelStatus.Awaiting.subWrap
函数
fn subWrap(lhs: Awaiting, rhs: Awaiting) Awaiting
参数
std.Io.Uring.Fiber.CancelStatus.Awaiting.toIoUringFd
函数
fn toIoUringFd(awaiting: Awaiting) fd_t
参数
awaiting: Awaiting
std.Io.Uring.Fiber.CancelStatus.changeAwaiting
函数
fn changeAwaiting( cancel_status: *CancelStatus, old_awaiting: Awaiting, new_awaiting: Awaiting, ) bool
参数
std.Io.Uring.Fiber.CancelStatus.unrequested
常量
CancelStatus
std.Io.Uring.Fiber.create
函数
fn create(ev: *Evented) error{OutOfMemory}!*Fiber
参数
ev: *Evented
错误
- OutOfMemory
std.Io.Uring.Fiber.destroy
函数
fn destroy(fiber: *Fiber) void
参数
fiber: *Fiber
std.Io.Uring.Fiber.finished
常量
?*Fiber
std.Io.Uring.Fiber.max_closure_align
常量
Alignment
std.Io.Uring.Fiber.max_closure_size
常量
usize
std.Io.Uring.Fiber.max_context_align
常量
Alignment
std.Io.Uring.Fiber.max_context_size
常量
std.Io.Uring.Fiber.max_result_align
常量
Alignment
std.Io.Uring.Fiber.max_result_size
常量
std.Io.Uring.Fiber.min_stack_size
常量
包含所需的全部栈重新对齐,以及初始帧返回地址槽和参数帧,具体取决于目标。
std.Io.Uring.Fiber.next_name
变量
u64
std.Io.Uring.Fiber.PackedPtr
容器
类似 *Fiber,但比指针少 2 位(由于对齐,最低有效位始终为 0),
以便将这两位用于 packed struct。
字段
std.Io.Uring.Fiber.PackedPtr.pack
函数
fn pack(ptr: ?*Fiber) PackedPtr
参数
ptr: ?*Fiber
std.Io.Uring.Fiber.PackedPtr.Split
容器
字段
low: u2
high: PackedPtr
std.Io.Uring.Fiber.PackedPtr.unpack
函数
fn unpack(ptr: PackedPtr) ?*Fiber
参数
ptr: PackedPtr
std.Io.Uring.Fiber.Queue
容器
字段
std.Io.Uring.Fiber.requestCancel
函数
fn requestCancel(fiber: *Fiber, ev: *Evented) void
参数
std.Io.Uring.Fiber.resultBytes
函数
fn resultBytes(f: *Fiber, alignment: Alignment) [*]u8
参数
std.Io.Uring.Fiber.resultPointer
函数
fn resultPointer(f: *Fiber, comptime Result: type) *Result
参数
f: *Fiber
Result: type
std.Io.Uring.File
别名
别名目标 std.Io.File
std.Io.Uring.fileClose
函数
fn fileClose(userdata: ?*anyopaque, files: []const File) void
参数
userdata: ?*anyopaque
files: []const File
std.Io.Uring.fileDowngradeLock
函数
fn fileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void
参数
userdata: ?*anyopaque
file: File
错误
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileEnableAnsiEscapeCodes
函数
fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void
参数
userdata: ?*anyopaque
file: File
错误
- Canceled Cancelable
调用方请求停止异步操作。
- NotTerminalDevice
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileHardLink
函数
fn fileHardLink( userdata: ?*anyopaque, file: File, new_dir: Dir, new_sub_path: []const u8, options: File.HardLinkOptions, ) File.HardLinkError!void
参数
userdata: ?*anyopaque
file: File
new_dir: Dir
new_sub_path: []const u8
options: File.HardLinkOptions
错误
- AccessDenied
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- CrossDevice
- DiskQuota
- FileNotFound
- HardwareFailure
- LinkQuotaExceeded
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NoSpaceLeft
- NotDir
- OperationUnsupported
操作系统或文件系统不支持硬链接。
- PathAlreadyExists
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileIsTty
函数
fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool
参数
userdata: ?*anyopaque
file: File
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.fileLength
函数
fn fileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64
参数
userdata: ?*anyopaque
file: File
错误
- AccessDenied StatError
在 WASI 中,当文件描述符不具备获取自身 filestat 信息所需的权限时,可能发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- PermissionDenied StatError
- Streaming StatError
尝试对非文件流调用 stat。
- SystemResources StatError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileLock
函数
fn fileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- FileLocksUnsupported
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileMemoryMapCreate
函数
fn fileMemoryMapCreate( userdata: ?*anyopaque, file: File, options: File.MemoryMap.CreateOptions, ) File.MemoryMap.CreateError!File.MemoryMap
参数
错误
- AccessDenied
以下任一情况:
File.Kind不是file。- 文件未以读取方式打开,且启用了读取访问保护。
- 文件未以写入方式打开,且启用了写入访问保护。
- Canceled Cancelable
调用方请求停止异步操作。
- InputOutput ReadPositionalError
- IsDir ReadPositionalError
尝试将目录文件描述符当作普通文件读取。
- LockViolation ReadPositionalError
由于锁定而无法读取文件。根据
Io实现的不同,读取已锁定文件可能返回此错误,也可能忽略锁。- LockedMemoryLimitExceeded
- NotOpenForReading ReadPositionalError
打开文件时未授予读取能力。
- OutOfMemory Error
- PermissionDenied
prot参数请求PROT_EXEC,但映射区域属于 挂载为禁止执行的文件系统中的文件。- ProcessFdQuotaExceeded
- SystemFdQuotaExceeded
- SystemResources ReadPositionalError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable ReadPositionalError
此文件不支持按位置读取。
- WouldBlock ReadPositionalError
已启用非阻塞模式,且从该文件描述符读取会阻塞。
std.Io.Uring.fileMemoryMapDestroy
函数
fn fileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void
参数
std.Io.Uring.fileMemoryMapRead
函数
fn fileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void
参数
错误
- AccessDenied
在 WASI 中,当文件描述符不具有读取 所需的权限时发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- InputOutput
- IsDir
尝试将目录文件描述符当作普通文件读取。
- LockViolation
由于锁定而无法读取文件。根据
Io实现的不同,读取已锁定文件可能返回此错误,也可能忽略锁。- NotOpenForReading
打开文件时未授予读取能力。
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable
此文件不支持按位置读取。
- WouldBlock
已启用非阻塞模式,且从该文件描述符读取会阻塞。
std.Io.Uring.fileMemoryMapSetLength
函数
fn fileMemoryMapSetLength( userdata: ?*anyopaque, mm: *File.MemoryMap, new_len: usize, ) File.MemoryMap.SetLengthError!void
参数
错误
- AccessDenied
以下任一情况:
File.Kind不是file。- 文件未以读取方式打开,且启用了读取访问保护。
- 文件未以写入方式打开,且启用了写入访问保护。
- Canceled Cancelable
调用方请求停止异步操作。
- FileBusy SetLengthError
- FileTooBig SetLengthError
- InputOutput SetLengthError
- LockedMemoryLimitExceeded
- NonResizable SetLengthError
- OperationUnsupported
- OutOfMemory Error
- PermissionDenied
prot参数请求PROT_EXEC,但映射区域属于 挂载为禁止执行的文件系统中的文件。- ProcessFdQuotaExceeded
- SystemFdQuotaExceeded
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileMemoryMapWrite
函数
fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void
参数
错误
- AccessDenied
文件描述符没有写入所需的权限。
- BrokenPipe
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy
- DiskQuota
- FileBusy
- FileTooBig
- InputOutput
- LockViolation
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft
- NotOpenForWriting
文件打开时没有写入能力。
- PermissionDenied
- SystemResources
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable
无法对该文件按指定位置写入。
- WouldBlock
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.filePathKind
函数
fn filePathKind(ev: *Evented, dir: Dir, sub_path: []const u8) !File.Kind
参数
std.Io.Uring.fileReadPositional
函数
fn fileReadPositional( userdata: ?*anyopaque, file: File, data: []const []u8, offset: u64, ) File.ReadPositionalError!usize
参数
错误
- AccessDenied
在 WASI 中,当文件描述符不具有读取 所需的权限时发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- InputOutput
- IsDir
尝试将目录文件描述符当作普通文件读取。
- LockViolation
由于锁定而无法读取文件。根据
Io实现的不同,读取已锁定文件可能返回此错误,也可能忽略锁。- NotOpenForReading
打开文件时未授予读取能力。
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable
此文件不支持按位置读取。
- WouldBlock
已启用非阻塞模式,且从该文件描述符读取会阻塞。
std.Io.Uring.fileReadStreaming
函数
fn fileReadStreaming( ev: *Evented, cancel_region: *CancelRegion, file: File, data: []const []u8, ) File.ReadStreamingError!usize
参数
错误
- AccessDenied UnendingError
在 WASI 中,当文件描述符不具有读取 所需的权限时发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- ConnectionResetByPeer UnendingError
- EndOfStream
- InputOutput UnendingError
- IsDir UnendingError
尝试将目录文件描述符当作普通文件读取。
- LockViolation UnendingError
由于锁定而无法读取文件。根据
Io实现的不同,读取已锁定文件可能返回此错误,也可能忽略锁。- NotOpenForReading UnendingError
打开文件时未授予读取能力。
- SocketUnconnected UnendingError
- SystemResources UnendingError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock UnendingError
已启用非阻塞模式,且从该文件描述符读取会阻塞。
std.Io.Uring.fileRealPath
函数
fn fileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize
参数
错误
- AccessDenied
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy
- FileBusy
- FileNotFound
- FileSystem
- FileTooBig
- InputOutput
- IsDir
- NameTooLong
完整文件系统路径无法放入所提供的缓冲区,或 由于路径过长,无论提供多大的缓冲区, 均无法通过 realpath 函数获取。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
- NotDir
- OperationUnsupported
此操作系统、文件系统或
Io实现 不支持 realpath 操作。- PathAlreadyExists
- PermissionDenied
- PipeBusy
- ProcessFdQuotaExceeded
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
std.Io.Uring.fileSeekBy
函数
fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!void
参数
错误
- AccessDenied
文件描述符不具备执行定位所需的权限。
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable
std.Io.Uring.fileSeekTo
函数
fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!void
参数
错误
- AccessDenied
文件描述符不具备执行定位所需的权限。
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable
std.Io.Uring.fileSetLength
函数
fn fileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthError!void
参数
错误
- AccessDenied
- Canceled Cancelable
调用方请求停止异步操作。
- FileBusy
- FileTooBig
- InputOutput
- NonResizable
- PermissionDenied
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileSetOwner
函数
fn fileSetOwner( userdata: ?*anyopaque, file: File, owner: ?File.Uid, group: ?File.Gid, ) File.SetOwnerError!void
参数
错误
- AccessDenied
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound
- InputOutput
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileSetPermissions
函数
fn fileSetPermissions( userdata: ?*anyopaque, file: File, permissions: File.Permissions, ) File.SetPermissionsError!void
参数
错误
- AccessDenied
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound
- InputOutput
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileSetTimestamps
函数
fn fileSetTimestamps( userdata: ?*anyopaque, file: File, options: File.SetTimestampsOptions, ) File.SetTimestampsError!void
参数
错误
- AccessDenied
times 为 NULL,或两个 nsec 值均为 UTIME_NOW,且满足以下之一:
- 调用方的有效用户标识符与文件 所有者不匹配,调用方不具有该文件的 写入权限,且调用方不具有特权;Linux 上即不具备 CAP_FOWNER 或 CAP_DAC_OVERRIDE 任一能力; 或者,
- 文件被标记为不可变,参见 chattr(1)。
- Canceled Cancelable
调用方请求停止异步操作。
- PermissionDenied
调用方尝试将一个或两个时间戳设置为当前时间 以外的值,或将一个时间戳 设为当前时间而保持另一个不变, 即 times 非 NULL,两个 nsec 字段均非 UTIME_NOW, 且两个 nsec 字段均非 UTIME_OMIT,同时满足以下任一条件:
- 调用方的有效用户 ID 不等于文件 所有者,且调用方无特权;Linux 上 指不具备 CAP_FOWNER 能力。
- 文件被标记为仅追加或不可变,参见 chattr(1)。
- ReadOnlyFileSystem
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileStat
函数
fn fileStat(userdata: ?*anyopaque, file: File) File.StatError!File.Stat
参数
userdata: ?*anyopaque
file: File
错误
- AccessDenied
在 WASI 中,当文件描述符不具备获取自身 filestat 信息所需的权限时,可能发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- PermissionDenied
- Streaming
尝试对非文件流调用 stat。
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileSync
函数
fn fileSync(userdata: ?*anyopaque, file: File) File.SyncError!void
参数
userdata: ?*anyopaque
file: File
错误
- AccessDenied
- Canceled Cancelable
调用方请求停止异步操作。
- DiskQuota
- InputOutput
- NoSpaceLeft
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileTryLock
函数
fn fileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- FileLocksUnsupported
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.fileUnlock
函数
fn fileUnlock(userdata: ?*anyopaque, file: File) void
参数
userdata: ?*anyopaque
file: File
std.Io.Uring.fileWriteFilePositional
函数
fn fileWriteFilePositional( userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *File.Reader, limit: Io.Limit, offset: u64, ) File.WriteFilePositionalError!usize
参数
userdata: ?*anyopaque
file: File
header: []const u8
file_reader: *File.Reader
limit: Io.Limit
offset: u64
错误
- AccessDenied Error
文件描述符没有写入所需的权限。
- BrokenPipe Error
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- CorruptedData WriteFileError
在 FreeBSD 上使用 copy_file_range 时可能发生。
- DeviceBusy Error
- DiskQuota Error
- EndOfStream WriteFileError
- FileBusy Error
- FileTooBig Error
- InputOutput Error
- LockViolation Error
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice Error
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft Error
- NotOpenForWriting Error
- PermissionDenied Error
- ReadFailed WriteFileError
- SystemResources Error
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unimplemented WriteFileError
描述符无效或已锁定,或 in_fd 不支持类似 mmap(2) 的操作。
- Unseekable
- WouldBlock Error
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.fileWriteFileStreaming
函数
fn fileWriteFileStreaming( userdata: ?*anyopaque, file: File, header: []const u8, file_reader: *File.Reader, limit: Io.Limit, ) File.Writer.WriteFileError!usize
参数
错误
- AccessDenied Error
文件描述符没有写入所需的权限。
- BrokenPipe Error
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- CorruptedData
在 FreeBSD 上使用 copy_file_range 时可能发生。
- DeviceBusy Error
- DiskQuota Error
- EndOfStream
- FileBusy Error
- FileTooBig Error
- InputOutput Error
- LockViolation Error
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice Error
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft Error
- NotOpenForWriting Error
- PermissionDenied Error
- ReadFailed
- SystemResources Error
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unimplemented
描述符无效或已锁定,或 in_fd 不支持类似 mmap(2) 的操作。
- WouldBlock Error
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.fileWritePositional
函数
fn fileWritePositional( userdata: ?*anyopaque, file: File, header: []const u8, data: []const []const u8, splat: usize, offset: u64, ) File.WritePositionalError!usize
参数
userdata: ?*anyopaque
file: File
header: []const u8
data: []const []const u8
splat: usize
offset: u64
错误
- AccessDenied
文件描述符没有写入所需的权限。
- BrokenPipe
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy
- DiskQuota
- FileBusy
- FileTooBig
- InputOutput
- LockViolation
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft
- NotOpenForWriting
文件打开时没有写入能力。
- PermissionDenied
- SystemResources
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable
无法对该文件按指定位置写入。
- WouldBlock
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.fileWriteStreaming
函数
fn fileWriteStreaming( ev: *Evented, cancel_region: *CancelRegion, file: File, header: []const u8, data: []const []const u8, splat: usize, ) File.Writer.Error!usize
参数
ev: *Evented
cancel_region: *CancelRegion
file: File
header: []const u8
data: []const []const u8
splat: usize
错误
- AccessDenied Error
文件描述符没有写入所需的权限。
- BrokenPipe Error
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy Error
- DiskQuota Error
- FileBusy Error
- FileTooBig Error
- InputOutput Error
- LockViolation Error
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice Error
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft Error
- NotOpenForWriting Error
- PermissionDenied Error
- SystemResources Error
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock Error
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.findReadyFiber
函数
fn findReadyFiber(ev: *Evented, thread: *Thread) ?*Fiber
参数
std.Io.Uring.flock
函数
fn flock( ev: *Evented, sync: *CancelRegion.Sync, fd: fd_t, op: File.Lock, blocking: enum { blocking, nonblocking }, ) (File.LockError || error{WouldBlock})!void
参数
std.Io.Uring.ForkBailError
错误集合
fork() 与 execv() 之间可能发生的错误。
错误
- AccessDenied OpenError
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference OpenError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy OpenError
- FileBusy OpenError
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported OpenError
- FileNotFound OpenError
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileSystem SetCurrentDirError
- FileTooBig OpenError
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- InvalidBatchScriptArg SpawnError
仅限 Windows。执行
.bat或.cmd脚本时,参数中不允许 NUL(U+0000)、LF(U+000A)和 CR(U+000D)。- NUL 与 LF 表示参数结束,其后的内容在执行后会丢失。
- CR 会被
cmd.exe移除,因此执行后所有 CR 码点都会丢失。
- InvalidExe SpawnError
- InvalidName SpawnError
- InvalidProcessGroupId SpawnError
- InvalidUserId SpawnError
- InvalidWtf8 SpawnError
仅限 Windows。提供的
cwd或argv为无效 WTF-8。 https://wtf-8.codeberg.page/- IsDir OpenError
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound OpenError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice SpawnError
仅限 POSIX。选择了
StdIo.ignore,且打开/dev/null时返回 ENODEV。- NoSpaceLeft OpenError
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir OpenError
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- OperationUnsupported SpawnError
操作系统不支持创建子进程。
- OutOfMemory SpawnError
- PathAlreadyExists OpenError
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied SpawnError
- PipeBusy OpenError
- ProcessAlreadyExec SpawnError
尝试更改调用进程某个子进程的 进程组 ID,但该子进程已经执行 映像替换。
- ProcessFdQuotaExceeded SpawnError
- ReadOnlyFileSystem OpenError
- ResourceLimitReached SpawnError
- SymLinkLoop ChdirError
- SystemFdQuotaExceeded SpawnError
- SystemResources OpenError
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume SpawnError
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
- WouldBlock OpenError
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.free
函数
fn free(userdata: *anyopaque, memory: []u8, alignment: std.mem.Alignment, ret_addr: usize) void
参数
std.Io.Uring.futexWait
函数
fn futexWait( userdata: ?*anyopaque, ptr: *const u32, expected: u32, timeout: Io.Timeout, ) Io.Cancelable!void
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.futexWaitUncancelable
函数
fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void
参数
userdata: ?*anyopaque
ptr: *const u32
expected: u32
std.Io.Uring.futexWake
函数
fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void
参数
userdata: ?*anyopaque
ptr: *const u32
max_waiters: u32
std.Io.Uring.getsockname
函数
fn getsockname( ev: *Evented, sync: *CancelRegion.Sync, socket_fd: fd_t, addr: *linux.sockaddr, addr_len: *linux.socklen_t, ) !void
参数
std.Io.Uring.Group
容器
字段
std.Io.Uring.Group.addFiber
函数
fn addFiber(group: Group, ev: *Evented, fiber: *Fiber) void
参数
std.Io.Uring.Group.AsyncClosure
容器
字段
std.Io.Uring.Group.AsyncClosure.call
函数
fn call( closure: *Group.AsyncClosure, contexts: *const Io.fiber.Switch, ) callconv(.withStackAlign(.c, @alignOf(Group.AsyncClosure))) noreturn
参数
closure: *Group.AsyncClosure
contexts: *const Io.fiber.Switch
std.Io.Uring.Group.AsyncClosure.contextPointer
函数
fn contextPointer( closure: *Group.AsyncClosure, ) [*]align(Fiber.max_context_align.toByteUnits()) u8
参数
closure: *Group.AsyncClosure
std.Io.Uring.Group.AsyncClosure.entry
函数
fn entry() callconv(.naked) void
std.Io.Uring.Group.AsyncClosure.fromFiber
函数
fn fromFiber(fiber: *Fiber) *Group.AsyncClosure
参数
fiber: *Fiber
std.Io.Uring.Group.await
函数
fn await(group: Group, ev: *Evented, awaiter: *Fiber) bool
参数
std.Io.Uring.Group.Awaiter
容器
字段
std.Io.Uring.Group.awaiterPtr
函数
fn awaiterPtr(group: Group) *Awaiter
参数
group: Group
std.Io.Uring.Group.cancel
函数
fn cancel(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool
参数
std.Io.Uring.Group.cancelLocked
函数
假定互斥锁已被持有。
fn cancelLocked(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool
参数
std.Io.Uring.Group.List
容器
字段
std.Io.Uring.Group.listPtr
函数
fn listPtr(group: Group) *List
参数
group: Group
std.Io.Uring.Group.lock
函数
fn lock(group: Group, ev: *Evented) void
参数
std.Io.Uring.Group.Mutex
容器
字段
locked: bool
contended: bool
shared2: u30
std.Io.Uring.Group.mutexPtr
函数
fn mutexPtr(group: Group) *Mutex
参数
group: Group
std.Io.Uring.Group.registerAwaiter
函数
假定互斥锁已被持有。
fn registerAwaiter(group: Group, awaiter: *Fiber) bool
参数
std.Io.Uring.Group.removeFiber
函数
fn removeFiber(group: Group, ev: *Evented, fiber: *Fiber) ?*Fiber
参数
std.Io.Uring.Group.unlock
函数
fn unlock(group: Group, ev: *Evented) void
参数
std.Io.Uring.groupAsync
函数
fn groupAsync( userdata: ?*anyopaque, type_erased: *Io.Group, context: []const u8, context_alignment: Alignment, start: *const fn (context: *const anyopaque) void, ) void
参数
std.Io.Uring.groupAwait
函数
fn groupAwait( userdata: ?*anyopaque, type_erased: *Io.Group, initial_token: *anyopaque, ) Io.Cancelable!void
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.groupCancel
函数
fn groupCancel(userdata: ?*anyopaque, type_erased: *Io.Group, initial_token: *anyopaque) void
参数
std.Io.Uring.groupConcurrent
函数
fn groupConcurrent( userdata: ?*anyopaque, type_erased: *Io.Group, context: []const u8, context_alignment: Alignment, start: *const fn (context: *const anyopaque) void, ) Io.ConcurrentError!void
参数
userdata: ?*anyopaque
type_erased: *Io.Group
context: []const u8
context_alignment: Alignment
start: *const fn (context: *const anyopaque) void
错误
- ConcurrencyUnavailable
可能由资源耗尽等临时情况引起,也可能因为 Io 实现不支持并发。
std.Io.Uring.idle
函数
fn idle(ev: *Evented, thread: *Thread) void
参数
std.Io.Uring.idle_stack_size
常量
经验上观察到,自托管后端在 panic 时使用超过 128KB。 经验上观察到,glibc 会对 256KB 发出警告。
std.Io.Uring.inheritParentDir
函数
fn inheritParentDir(userdata: ?*anyopaque, handle: Dir.Handle) Io.InheritParentHandleError!Dir
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnsupportedOperation
std.Io.Uring.inheritParentFile
函数
fn inheritParentFile( userdata: ?*anyopaque, handle: File.Handle, flags: File.Flags, ) Io.InheritParentHandleError!File
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnsupportedOperation
std.Io.Uring.inheritParentHandle
函数
fn inheritParentHandle(ev: *Evented, handle: fd_t) Io.InheritParentHandleError!void
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnsupportedOperation
std.Io.Uring.init
函数
pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !void
参数
std.Io.Uring.initLockedStderr
函数
fn initLockedStderr(ev: *Evented, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.InitOptions
容器
字段
std.Io.Uring.io
函数
pub fn io(ev: *Evented) Io
参数
ev: *Evented
std.Io.Uring.Io
别名
别名目标 std.Io
std.Io.Uring.IoUring
别名
别名目标 std.os.linux.IoUring
std.Io.Uring.iovec
别名
别名目标 std.posix.iovec
std.Io.Uring.iovec_const
别名
std.Io.Uring.iovlen_t
常量
此处为 usize 或 u32,二者均可。因此对写入文件
和发送网络消息均使用同一个 addBuf 函数。
std.Io.Uring.linkat
函数
fn linkat( ev: *Evented, cancel_region: *CancelRegion, old_dir: fd_t, old_path: [*:0]const u8, new_dir: fd_t, new_path: [*:0]const u8, flags: u32, ) File.HardLinkError!void
参数
ev: *Evented
cancel_region: *CancelRegion
old_dir: fd_t
old_path: [*:0]const u8
new_dir: fd_t
new_path: [*:0]const u8
flags: u32
错误
- AccessDenied
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- CrossDevice
- DiskQuota
- FileNotFound
- HardwareFailure
- LinkQuotaExceeded
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NoSpaceLeft
- NotDir
- OperationUnsupported
操作系统或文件系统不支持硬链接。
- PathAlreadyExists
- PermissionDenied
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.linux
别名
别名目标 std.os.linux
std.Io.Uring.linux_statx_request
别名
std.Io.Uring.LOCK
别名
别名目标 std.posix.LOCK
std.Io.Uring.lockStderr
函数
fn lockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.log
类型
std.Io.Uring.lseek
函数
fn lseek( ev: *Evented, sync: *CancelRegion.Sync, fd: fd_t, offset: u64, whence: u32, ) File.SeekError!void
参数
错误
- AccessDenied
文件描述符不具备执行定位所需的权限。
- Canceled Cancelable
调用方请求停止异步操作。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- Unseekable
std.Io.Uring.mainIdle
函数
fn mainIdle( ev: *Evented, contexts: *const Io.fiber.Switch, ) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Io.fiber.Context)))) noreturn
参数
std.Io.Uring.mainIdleEntry
函数
fn mainIdleEntry() callconv(.naked) void
std.Io.Uring.max_idle_search
常量
std.Io.Uring.max_iovecs_len
别名
std.Io.Uring.max_steal_free_search
常量
std.Io.Uring.max_steal_ready_search
常量
std.Io.Uring.nanosecondsFromPosix
别名
std.Io.Uring.net
别名
别名目标 std.Io.net
std.Io.Uring.netBindIp
函数
fn netBindIp( userdata: ?*anyopaque, address: *const net.IpAddress, options: net.IpAddress.BindOptions, ) net.IpAddress.BindError!net.Socket
参数
错误
- AccessDenied
该地址受到保护,当前用户没有绑定它的权限。
- AddressFamilyUnsupported
该地址对于套接字的地址族无效。
- AddressInUse
地址已被占用。当绑定端口为 0, 但所有临时端口均已使用时,可能发生此情况。
- AddressUnavailable
请求了不存在的接口,或请求的地址不是本地地址。
- Canceled Cancelable
调用方请求停止异步操作。
- NetworkDown
用于到达目标的本地网络接口已离线。
- OptionUnsupported
Io 实现不支持某个
BindOptions。- ProcessFdQuotaExceeded
已达到每进程可打开文件描述符数量上限。
- ProtocolUnsupportedByAddressFamily
- ProtocolUnsupportedBySystem
- SocketModeUnsupported
- SystemFdQuotaExceeded
已达到系统范围内已打开文件的总数上限。
- SystemResources
操作系统内部内存或其他资源不足。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.netClose
函数
fn netClose(userdata: ?*anyopaque, sockets: []const net.Socket) void
参数
std.Io.Uring.netReceive
类型函数
fn netReceive( ev: *Evented, cancel_region: *CancelRegion, handle: net.Socket.Handle, message_buffer: []net.IncomingMessage, data_buffer: []u8, flags: net.ReceiveFlags, ) struct { ?net.Socket.ReceiveError, usize }
参数
ev: *Evented
cancel_region: *CancelRegion
handle: net.Socket.Handle
message_buffer: []net.IncomingMessage
data_buffer: []u8
flags: net.ReceiveFlags
std.Io.Uring.netShutdown
函数
fn netShutdown( userdata: ?*anyopaque, handle: net.Socket.Handle, how: net.ShutdownHow, ) net.ShutdownError!void
参数
错误
- Canceled Cancelable
调用方请求停止异步操作。
- ConnectionAborted
- ConnectionResetByPeer
- NetworkDown
- SocketUnconnected
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.now
函数
fn now(userdata: ?*anyopaque, clock: Io.Clock) Io.Timestamp
参数
std.Io.Uring.openat
函数
fn openat( ev: *Evented, cancel_region: *CancelRegion, dir: fd_t, path: [*:0]const u8, flags: linux.O, mode: linux.mode_t, ) !fd_t
参数
std.Io.Uring.operate
函数
fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Operation.Result
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.PATH_MAX
别名
std.Io.Uring.pathToPosix
别名
std.Io.Uring.pid_t
别名
别名目标 std.os.linux.pid_t
std.Io.Uring.pipe2
函数
pub fn pipe2(flags: linux.O) PipeError![2]fd_t
参数
错误
- ProcessFdQuotaExceeded
- SystemFdQuotaExceeded
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.PipeError
错误集合
错误
- ProcessFdQuotaExceeded
- SystemFdQuotaExceeded
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.PosixAddress
别名
std.Io.Uring.posixAddressFamily
别名
std.Io.Uring.posixSocketModeProtocol
别名
std.Io.Uring.preadv
函数
fn preadv( ev: *Evented, cancel_region: *CancelRegion, fd: fd_t, iov: []const iovec, offset: ?u64, ) File.Reader.Error!usize
参数
错误
- AccessDenied UnendingError
在 WASI 中,当文件描述符不具有读取 所需的权限时发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- ConnectionResetByPeer UnendingError
- InputOutput UnendingError
- IsDir UnendingError
尝试将目录文件描述符当作普通文件读取。
- LockViolation UnendingError
由于锁定而无法读取文件。根据
Io实现的不同,读取已锁定文件可能返回此错误,也可能忽略锁。- NotOpenForReading UnendingError
打开文件时未授予读取能力。
- SocketUnconnected UnendingError
- SystemResources UnendingError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock UnendingError
已启用非阻塞模式,且从该文件描述符读取会阻塞。
std.Io.Uring.process
别名
别名目标 std.process
std.Io.Uring.processCurrentPath
函数
fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize
参数
userdata: ?*anyopaque
buffer: []u8
错误
- Canceled Cancelable
调用方请求停止异步操作。
- CurrentDirUnlinked
在 Windows 上不可能发生。在 WASI 上始终返回。
- NameTooLong
缓冲区过小,无法容纳当前路径。
- PathExceedsLimit
受底层 libc 或系统调用实现限制,无法获取当前路径。换用更大缓冲区重试也不会成功。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.processExec
函数
fn processExec( sync: *CancelRegion.Sync, exe: process.ReplaceOptions.Exe, argv: [*:null]?[*:0]const u8, expand_arg0: process.ArgExpansion, env_block: process.Environ.PosixBlock, PATH: []const u8, ) process.ReplaceError
参数
sync: *CancelRegion.Sync
exe: process.ReplaceOptions.Exe
argv: [*:null]?[*:0]const u8
expand_arg0: process.ArgExpansion
env_block: process.Environ.PosixBlock
PATH: []const u8
std.Io.Uring.processExecutableOpen
函数
fn processExecutableOpen( userdata: ?*anyopaque, flags: Dir.OpenFileOptions, ) process.OpenExecutableError!File
参数
userdata: ?*anyopaque
flags: Dir.OpenFileOptions
错误
- AccessDenied OpenError
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference OpenError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy OpenError
- FileBusy OpenError
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported OpenError
- FileNotFound OpenError
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileSystem ExecutablePathBaseError
- FileTooBig OpenError
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- InputOutput ExecutablePathBaseError
- IsDir OpenError
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound OpenError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice OpenError
- NoSpaceLeft OpenError
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir OpenError
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- NotLink ExecutablePathBaseError
- OperationUnsupported ExecutablePathBaseError
操作系统不支持可执行文件获取自身 路径。
- PathAlreadyExists OpenError
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied OpenError
- PipeBusy OpenError
- ProcessFdQuotaExceeded OpenError
- ProcessNotFound ExecutablePathBaseError
- ReadOnlyFileSystem OpenError
- SymLinkLoop OpenError
- SystemFdQuotaExceeded OpenError
- SystemResources OpenError
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume ExecutablePathBaseError
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
- WouldBlock OpenError
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.processExecutablePath
函数
fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.ExecutablePathError!usize
参数
userdata: ?*anyopaque
out_buffer: []u8
错误
- AccessDenied ExecutablePathBaseError
- AntivirusInterference ExecutablePathBaseError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName ExecutablePathBaseError
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy ExecutablePathBaseError
- FileNotFound ExecutablePathBaseError
- FileSystem ExecutablePathBaseError
- FileTooBig ExecutablePathBaseError
- InputOutput ExecutablePathBaseError
- IsDir ExecutablePathBaseError
- NameTooLong
- NetworkNotFound ExecutablePathBaseError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice ExecutablePathBaseError
- NoSpaceLeft ExecutablePathBaseError
- NotDir ExecutablePathBaseError
- NotLink ExecutablePathBaseError
- OperationUnsupported ExecutablePathBaseError
操作系统不支持可执行文件获取自身 路径。
- PathAlreadyExists ExecutablePathBaseError
- PermissionDenied ExecutablePathBaseError
- PipeBusy ExecutablePathBaseError
- ProcessFdQuotaExceeded ExecutablePathBaseError
- ProcessNotFound ExecutablePathBaseError
- SymLinkLoop ExecutablePathBaseError
- SystemFdQuotaExceeded ExecutablePathBaseError
- SystemResources ExecutablePathBaseError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume ExecutablePathBaseError
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
std.Io.Uring.processExecveat
函数
fn processExecveat( sync: *CancelRegion.Sync, dir: fd_t, path: ?[*:0]const u8, argv: [*:null]const ?[*:0]const u8, env_block: process.Environ.PosixBlock, ) process.ReplaceError
参数
sync: *CancelRegion.Sync
dir: fd_t
path: ?[*:0]const u8
argv: [*:null]const ?[*:0]const u8
env_block: process.Environ.PosixBlock
std.Io.Uring.processReplace
函数
fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) process.ReplaceError
参数
userdata: ?*anyopaque
options: process.ReplaceOptions
std.Io.Uring.processSetCurrentDir
函数
fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void
参数
userdata: ?*anyopaque
dir: Dir
错误
- AccessDenied
- BadPathName
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound
- FileSystem
- NameTooLong
- NoDevice
- NotDir
- OperationUnsupported
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume
std.Io.Uring.processSetCurrentPath
函数
fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) process.SetCurrentPathError!void
参数
userdata: ?*anyopaque
dir_path: []const u8
错误
- AccessDenied
- BadPathName
- Canceled Cancelable
调用方请求停止异步操作。
- FileNotFound
- FileSystem
- InvalidWtf8
仅限 Windows。路径不是有效的 WTF-8。 https://wtf-8.codeberg.page/
- NameTooLong
- NoDevice
- NotDir
- OperationUnsupported
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.processSpawn
函数
fn processSpawn(userdata: ?*anyopaque, options: process.SpawnOptions) process.SpawnError!process.Child
参数
userdata: ?*anyopaque
options: process.SpawnOptions
错误
- AccessDenied OpenError
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference OpenError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy OpenError
- FileBusy OpenError
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported OpenError
- FileNotFound OpenError
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileSystem
- FileTooBig OpenError
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- InvalidBatchScriptArg
仅限 Windows。执行
.bat或.cmd脚本时,参数中不允许 NUL(U+0000)、LF(U+000A)和 CR(U+000D)。- NUL 与 LF 表示参数结束,其后的内容在执行后会丢失。
- CR 会被
cmd.exe移除,因此执行后所有 CR 码点都会丢失。
- InvalidExe
- InvalidName
- InvalidProcessGroupId
- InvalidUserId
- InvalidWtf8
仅限 Windows。提供的
cwd或argv为无效 WTF-8。 https://wtf-8.codeberg.page/- IsDir OpenError
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound OpenError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
仅限 POSIX。选择了
StdIo.ignore,且打开/dev/null时返回 ENODEV。- NoSpaceLeft OpenError
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir OpenError
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- OperationUnsupported
操作系统不支持创建子进程。
- OutOfMemory
- PathAlreadyExists OpenError
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied
- PipeBusy OpenError
- ProcessAlreadyExec
尝试更改调用进程某个子进程的 进程组 ID,但该子进程已经执行 映像替换。
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem OpenError
- ResourceLimitReached
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources OpenError
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
- WouldBlock OpenError
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.prog_fileno
常量
std.Io.Uring.progressParentFile
函数
fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File
参数
userdata: ?*anyopaque
错误
- EnvironmentVariableMissing
- UnrecognizedFormat
- UnsupportedOperation
std.Io.Uring.pwritev
函数
fn pwritev( ev: *Evented, cancel_region: *CancelRegion, fd: fd_t, iov: []const iovec_const, offset: ?u64, ) File.Writer.Error!usize
参数
错误
- AccessDenied Error
文件描述符没有写入所需的权限。
- BrokenPipe Error
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy Error
- DiskQuota Error
- FileBusy Error
- FileTooBig Error
- InputOutput Error
- LockViolation Error
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice Error
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft Error
- NotOpenForWriting Error
- PermissionDenied Error
- SystemResources Error
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock Error
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.random
函数
fn random(userdata: ?*anyopaque, buffer: []u8) void
参数
userdata: ?*anyopaque
buffer: []u8
std.Io.Uring.randomSecure
函数
fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void
参数
userdata: ?*anyopaque
buffer: []u8
错误
- Canceled Cancelable
调用方请求停止异步操作。
- EntropyUnavailable
std.Io.Uring.readAll
函数
fn readAll( ev: *Evented, cancel_region: *CancelRegion, fd: fd_t, buffer: []u8, ) (File.Reader.Error || error{EndOfStream})!void
参数
std.Io.Uring.realPath
函数
fn realPath( ev: *Evented, sync: *CancelRegion.Sync, fd: fd_t, out_buffer: []u8, ) File.RealPathError!usize
参数
错误
- AccessDenied
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy
- FileBusy
- FileNotFound
- FileSystem
- FileTooBig
- InputOutput
- IsDir
- NameTooLong
完整文件系统路径无法放入所提供的缓冲区,或 由于路径过长,无论提供多大的缓冲区, 均无法通过 realpath 函数获取。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
- NotDir
- OperationUnsupported
此操作系统、文件系统或
Io实现 不支持 realpath 操作。- PathAlreadyExists
- PermissionDenied
- PipeBusy
- ProcessFdQuotaExceeded
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
std.Io.Uring.recancel
函数
fn recancel(userdata: ?*anyopaque) void
参数
userdata: ?*anyopaque
std.Io.Uring.recoverableOsBugDetected
别名
std.Io.Uring.remap
函数
fn remap( userdata: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, ret_addr: usize, ) ?[*]u8
参数
std.Io.Uring.renameat
函数
fn renameat( ev: *Evented, cancel_region: *CancelRegion, old_dir: fd_t, old_path: [*:0]const u8, new_dir: fd_t, new_path: [*:0]const u8, flags: linux.RENAME, ) Dir.RenameError!void
参数
ev: *Evented
cancel_region: *CancelRegion
old_dir: fd_t
old_path: [*:0]const u8
new_dir: fd_t
new_path: [*:0]const u8
flags: linux.RENAME
错误
- AccessDenied
在 WASI 中,当文件描述符不具备相对于自身 按路径重命名资源所需的权限时,可能发生此错误。
- AntivirusInterference
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- CrossDevice
- DirNotEmpty
试图替换非空目录。
- DiskQuota
- FileBusy
尝试移动或替换的文件是正在运行的可执行文件。
- FileNotFound
- HardwareFailure
- IsDir
- LinkQuotaExceeded
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
- NoSpaceLeft
- NotDir
- PermissionDenied
- PipeBusy
- ReadOnlyFileSystem
- SymLinkLoop
- SystemResources
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.resize
函数
fn resize( userdata: *anyopaque, memory: []u8, alignment: std.mem.Alignment, new_len: usize, ret_addr: usize, ) bool
参数
std.Io.Uring.scanEnviron
函数
fn scanEnviron(ev: *Evented) Io.Cancelable!void
参数
ev: *Evented
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.schedule
函数
fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool
参数
std.Io.Uring.setFdFlags
函数
fn setFdFlags(sync: *CancelRegion.Sync, fd: fd_t, flags: usize) (Io.Cancelable || Io.UnexpectedError)!void
参数
std.Io.Uring.setsockopt
函数
fn setsockopt( ev: *Evented, cancel_region: *CancelRegion, fd: fd_t, level: i32, opt_name: u32, option: u32, ) !void
参数
std.Io.Uring.setTimestampToPosix
别名
std.Io.Uring.setUpChild
函数
fn setUpChild(sync: *CancelRegion.Sync, options: struct { stdin_pipe: fd_t, stdout_pipe: fd_t, stderr_pipe: fd_t, dev_null_fd: fd_t, prog_pipe: fd_t, argv_buf: [:null]?[*:0]const u8, env_block: process.Environ.Block, PATH: []const u8, spawn: process.SpawnOptions, }) ForkBailError
参数
std.Io.Uring.setUpChildIo
函数
fn setUpChildIo( sync: *CancelRegion.Sync, stdio: process.SpawnOptions.StdIo, pipe_fd: fd_t, std_fileno: i32, dev_null_fd: fd_t, ) !void
参数
sync: *CancelRegion.Sync
stdio: process.SpawnOptions.StdIo
pipe_fd: fd_t
std_fileno: i32
dev_null_fd: fd_t
std.Io.Uring.sleep
函数
fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.socket
函数
fn socket( ev: *Evented, cancel_region: *CancelRegion, family: linux.sa_family_t, options: net.IpAddress.BindOptions, ) error{ AddressFamilyUnsupported, ProtocolUnsupportedBySystem, ProcessFdQuotaExceeded, SystemFdQuotaExceeded, SystemResources, ProtocolUnsupportedByAddressFamily, SocketModeUnsupported, OptionUnsupported, Unexpected, Canceled, }!fd_t
参数
ev: *Evented
cancel_region: *CancelRegion
family: linux.sa_family_t
options: net.IpAddress.BindOptions
错误
- AddressFamilyUnsupported
- Canceled
- OptionUnsupported
- ProcessFdQuotaExceeded
- ProtocolUnsupportedByAddressFamily
- ProtocolUnsupportedBySystem
- SocketModeUnsupported
- SystemFdQuotaExceeded
- SystemResources
- Unexpected
std.Io.Uring.spawn
函数
fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned
参数
ev: *Evented
options: process.SpawnOptions
错误
- AccessDenied OpenError
在 WASI 中,若文件描述符不具有相对于它 打开新资源所需的权限,可能发生此错误。
- AntivirusInterference OpenError
Windows 默认启用杀毒软件。虽然可以禁用,但 Windows Update 有时会忽略用户偏好并重新启用。 启用时,Windows 上的杀毒软件会拦截文件系统操作,使其显著变慢,也可能导致操作因该错误码失败。
- BadPathName PathNameError
文件系统无法编码请求的文件名字节。 原因可能是 Windows 上无效的 WTF-8、WASI 上无效的 UTF-8、 Windows 上的无效字符等,具体取决于文件系统与操作系统。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy OpenError
- FileBusy OpenError
以下三种情况之一:
- pathname 指向正在执行的可执行映像, 且请求写访问。
- pathname 指向当前用作交换 文件的文件,且指定了 O_TRUNC 标志。
- pathname 指向内核正在读取的文件, 例如用于加载模块或固件,且请求 写访问。
- FileLocksUnsupported OpenError
- FileNotFound OpenError
以下任一情况:
- 某个路径分量不存在。
- 使用了当前工作目录,但该目录已被删除。
- 已打开目录句柄所关联的路径已被删除。
- macOS 上,多个进程或线程将
O.EXCL设为false,并发争相创建同一文件。
- FileSystem
- FileTooBig OpenError
文件过大,无法打开。对于 64 位目标及打开目录的情况,此错误不可达。
- InvalidBatchScriptArg
仅限 Windows。执行
.bat或.cmd脚本时,参数中不允许 NUL(U+0000)、LF(U+000A)和 CR(U+000D)。- NUL 与 LF 表示参数结束,其后的内容在执行后会丢失。
- CR 会被
cmd.exe移除,因此执行后所有 CR 码点都会丢失。
- InvalidExe
- InvalidName
- InvalidProcessGroupId
- InvalidUserId
- InvalidWtf8
仅限 Windows。提供的
cwd或argv为无效 WTF-8。 https://wtf-8.codeberg.page/- IsDir OpenError
以下任一情况:
- 路径指向目录,但请求了写权限。
- 路径指向目录,但
allow_directory被设为 false。
- NameTooLong PathNameError
提供的缓冲区过小, 无法容纳路径名时返回。
- NetworkNotFound OpenError
在 Windows 上,未找到
\\server或\\server\share。- NoDevice
仅限 POSIX。选择了
StdIo.ignore,且打开/dev/null时返回 ENODEV。- NoSpaceLeft OpenError
设备没有空间容纳新文件,无法创建新路径。 仅在提供
CREAT标志时才可能出现此错误。- NotDir OpenError
路径中用作目录的某个部分实际上不是目录, 或者指定了
DIRECTORY,但路径不是目录。- OperationUnsupported
操作系统不支持创建子进程。
- OutOfMemory
- PathAlreadyExists OpenError
路径已存在,且提供了
CREAT和EXCL标志。- PermissionDenied
- PipeBusy OpenError
- ProcessAlreadyExec
尝试更改调用进程某个子进程的 进程组 ID,但该子进程已经执行 映像替换。
- ProcessFdQuotaExceeded
- ReadOnlyFileSystem OpenError
- ResourceLimitReached
- SymLinkLoop
- SystemFdQuotaExceeded
- SystemResources OpenError
路径超过
max_path_bytes字节。 可用内核内存不足;或者 指定文件为 FIFO,且达到每用户 管道内存分配的硬限制。- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- UnrecognizedVolume
在 Windows 上,卷不包含可识别的文件系统。文件 系统驱动可能未加载,或卷可能已损坏。
- WouldBlock OpenError
已请求非阻塞模式,但该操作无法立即返回。
std.Io.Uring.Spawned
容器
字段
std.Io.Uring.splat_buffer_size
别名
std.Io.Uring.stat
函数
fn stat(ev: *Evented, cancel_region: *CancelRegion, fd: fd_t) Dir.StatError!Dir.Stat
参数
错误
- AccessDenied StatError
在 WASI 中,当文件描述符不具备获取自身 filestat 信息所需的权限时,可能发生此错误。
- Canceled Cancelable
调用方请求停止异步操作。
- PermissionDenied StatError
- Streaming StatError
尝试对非文件流调用 stat。
- SystemResources StatError
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.statFromLinux
别名
std.Io.Uring.statx
函数
fn statx( ev: *Evented, cancel_region: *CancelRegion, dir: fd_t, path: [*:0]const u8, flags: u32, ) (Dir.StatError || Dir.PathNameError || error{ FileNotFound, NotDir, SymLinkLoop })!Dir.Stat
参数
std.Io.Uring.statxKind
别名
std.Io.Uring.std
别名
别名目标 std
std.Io.Uring.swapCancelProtection
函数
fn swapCancelProtection(userdata: ?*anyopaque, new: Io.CancelProtection) Io.CancelProtection
参数
userdata: ?*anyopaque
new: Io.CancelProtection
std.Io.Uring.SwitchMessage
容器
字段
contexts: Io.fiber.Switch
pending_task: PendingTask
std.Io.Uring.SwitchMessage.handle
函数
fn handle(message: *const SwitchMessage, ev: *Evented) void
参数
message: *const SwitchMessage
ev: *Evented
std.Io.Uring.SwitchMessage.PendingTask
容器
字段
std.Io.Uring.Thread
容器
字段
required_align: void align(4)
thread: std.Thread
idle_context: Io.fiber.Context
current_context: *Io.fiber.Context
ready_queue: ?*Fiber
free_queue: ?*Fiber
io_uring: IoUring
idle_search_index: u32
steal_ready_search_index: u32
steal_free_search_index: u32
name_arena: if (tracy.enable) std.heap.ArenaAllocator.State else struct {}
csprng: Csprng
std.Io.Uring.Thread.current
函数
noinline fn current() *Thread
std.Io.Uring.Thread.currentFiber
函数
fn currentFiber(thread: *Thread) *Fiber
参数
thread: *Thread
std.Io.Uring.Thread.deinit
函数
fn deinit(thread: *Thread, gpa: Allocator) void
参数
std.Io.Uring.Thread.enqueue
函数
fn enqueue(thread: *Thread) *linux.io_uring_sqe
参数
thread: *Thread
std.Io.Uring.Thread.List
容器
字段
std.Io.Uring.Thread.self
变量
?*Thread
std.Io.Uring.Thread.submit
函数
fn submit(thread: *Thread) void
参数
thread: *Thread
std.Io.Uring.threadEntry
函数
fn threadEntry(ev: *Evented, index: u32) void
参数
ev: *Evented
index: u32
std.Io.Uring.timestampFromPosix
别名
std.Io.Uring.tracy
类型
std.Io.Uring.tracy.enable
原始类型
std.Io.Uring.tracy.fiberEnter
函数
inline fn fiberEnter(fiber: [*:0]const u8) void
参数
fiber: [*:0]const u8
std.Io.Uring.tracy.fiberLeave
函数
inline fn fiberLeave() void
std.Io.Uring.tryLockStderr
函数
fn tryLockStderr( userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode, ) Io.Cancelable!?Io.LockedStderr
参数
错误
- Canceled
调用方请求停止异步操作。
std.Io.Uring.unexpectedErrno
别名
std.Io.Uring.unlockStderr
函数
fn unlockStderr(userdata: ?*anyopaque) void
参数
userdata: ?*anyopaque
std.Io.Uring.urandomReadAll
函数
fn urandomReadAll( ev: *Evented, cancel_region: *CancelRegion, buffer: []u8, ) (File.OpenError || File.Reader.Error || error{EndOfStream})!void
参数
std.Io.Uring.utimensat
函数
fn utimensat( ev: *Evented, sync: *CancelRegion.Sync, dir: fd_t, path: [*:0]const u8, times: ?*const [2]linux.timespec, flags: u32, ) File.SetTimestampsError!void
参数
ev: *Evented
sync: *CancelRegion.Sync
dir: fd_t
path: [*:0]const u8
times: ?*const [2]linux.timespec
flags: u32
错误
- AccessDenied
times 为 NULL,或两个 nsec 值均为 UTIME_NOW,且满足以下之一:
- 调用方的有效用户标识符与文件 所有者不匹配,调用方不具有该文件的 写入权限,且调用方不具有特权;Linux 上即不具备 CAP_FOWNER 或 CAP_DAC_OVERRIDE 任一能力; 或者,
- 文件被标记为不可变,参见 chattr(1)。
- Canceled Cancelable
调用方请求停止异步操作。
- PermissionDenied
调用方尝试将一个或两个时间戳设置为当前时间 以外的值,或将一个时间戳 设为当前时间而保持另一个不变, 即 times 非 NULL,两个 nsec 字段均非 UTIME_NOW, 且两个 nsec 字段均非 UTIME_OMIT,同时满足以下任一条件:
- 调用方的有效用户 ID 不等于文件 所有者,且调用方无特权;Linux 上 指不具备 CAP_FOWNER 能力。
- 文件被标记为仅追加或不可变,参见 chattr(1)。
- ReadOnlyFileSystem
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
std.Io.Uring.winsize
别名
别名目标 std.posix.winsize
std.Io.Uring.writeAllSync
函数
fn writeAllSync(sync: *CancelRegion.Sync, fd: fd_t, buffer: []const u8) File.Writer.Error!void
参数
错误
- AccessDenied Error
文件描述符没有写入所需的权限。
- BrokenPipe Error
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy Error
- DiskQuota Error
- FileBusy Error
- FileTooBig Error
- InputOutput Error
- LockViolation Error
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice Error
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft Error
- NotOpenForWriting Error
- PermissionDenied Error
- SystemResources Error
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock Error
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.writeSync
函数
fn writeSync(sync: *CancelRegion.Sync, fd: fd_t, buffer: []const u8) File.Writer.Error!usize
参数
错误
- AccessDenied Error
文件描述符没有写入所需的权限。
- BrokenPipe Error
文件为未连接的套接字,或其读取端已关闭。
- Canceled Cancelable
调用方请求停止异步操作。
- DeviceBusy Error
- DiskQuota Error
- FileBusy Error
- FileTooBig Error
- InputOutput Error
- LockViolation Error
进程无法访问文件,因为另一进程已锁定 文件的一部分。仅限 Windows。
- NoDevice Error
写入设备期间,若设备在刷新之前或刷新途中断开,就会发生此错误:errno(6),没有此设备或地址。
- NoSpaceLeft Error
- NotOpenForWriting Error
- PermissionDenied Error
- SystemResources Error
内核内存不足,无法从 in_fd 读取。
- Unexpected UnexpectedError
操作系统返回了未记录在文档中的错误码。
理论上不可能出现此错误,但处理 此错误优于触发未定义行为。
观察到此错误码时,通常意味着 Zig 标准 库需要小幅修补,将该错误码加入 相应函数的错误集合。
- WouldBlock Error
已启用非阻塞模式,而此操作将阻塞。
std.Io.Uring.yield
函数
fn yield(ev: *Evented, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage.PendingTask) void
参数
源码
std/Io/Uring.zig
const addressFromPosix = Io.Threaded.addressFromPosix;
const addressToPosix = Io.Threaded.addressToPosix;
const Alignment = std.mem.Alignment;
const Allocator = std.mem.Allocator;
const Argv0 = Io.Threaded.Argv0;
const assert = std.debug.assert;
const builtin = @import("builtin");
const ChdirError = Io.Threaded.ChdirError;
const clockToPosix = Io.Threaded.clockToPosix;
const Csprng = Io.Threaded.Csprng;
const default_PATH = Io.Threaded.default_PATH;
const Dir = Io.Dir;
const Environ = Io.Threaded.Environ;
const errnoBug = Io.Threaded.errnoBug;
const Evented = @This();
const fallbackSeed = Io.Threaded.fallbackSeed;
const fd_t = linux.fd_t;
const File = Io.File;
const Io = std.Io;
const IoUring = linux.IoUring;
const iovec = std.posix.iovec;
const iovec_const = std.posix.iovec_const;
const linux = std.os.linux;
const linux_statx_request = Io.Threaded.linux_statx_request;
const LOCK = std.posix.LOCK;
const log = std.log.scoped(.@"io-uring");
const max_iovecs_len = Io.Threaded.max_iovecs_len;
const nanosecondsFromPosix = Io.Threaded.nanosecondsFromPosix;
const net = Io.net;
const PATH_MAX = linux.PATH_MAX;
const pathToPosix = Io.Threaded.pathToPosix;
const pid_t = linux.pid_t;
const PosixAddress = Io.Threaded.PosixAddress;
const posixAddressFamily = Io.Threaded.posixAddressFamily;
const posixSocketModeProtocol = Io.Threaded.posixSocketModeProtocol;
const process = std.process;
const recoverableOsBugDetected = Io.Threaded.recoverableOsBugDetected;
const setTimestampToPosix = Io.Threaded.setTimestampToPosix;
const splat_buffer_size = Io.Threaded.splat_buffer_size;
const statFromLinux = Io.Threaded.statFromLinux;
const statxKind = Io.Threaded.statxKind;
const std = @import("../std.zig");
const timestampFromPosix = Io.Threaded.timestampFromPosix;
const unexpectedErrno = std.posix.unexpectedErrno;
const winsize = std.posix.winsize;
const tracy = if (@hasDecl(@import("root"), "tracy")) @import("root").tracy else struct {
const enable = false;
inline fn fiberEnter(fiber: [*:0]const u8) void {
_ = fiber;
}
inline fn fiberLeave() void {}
};
/// 经验上观察到,自托管后端在 panic 时使用超过 128KB。
/// 经验上观察到,glibc 会对 256KB 发出警告。
const idle_stack_size = 512 * 1024;
const max_idle_search = 1;
const max_steal_ready_search = 2;
const max_steal_free_search = 4;
backing_allocator_needs_mutex: bool,
backing_allocator_mutex: Io.Mutex,
/// 若未在其他地方使用,则无需线程安全。
backing_allocator: Allocator,
main_fiber_buffer: [
std.mem.alignForward(usize, @sizeOf(Fiber), @alignOf(Completion)) + @sizeOf(Completion)
]u8 align(@max(@alignOf(Fiber), @alignOf(Completion))),
log2_ring_entries: u4,
threads: Thread.List,
sync_limit: ?Io.Semaphore,
stderr_writer_initialized: bool = false,
stderr_mutex: Io.Mutex,
stderr_writer: File.Writer = .{
.io = undefined,
.interface = Io.File.Writer.initInterface(&.{}),
.file = .stderr(),
.mode = .streaming,
},
stderr_mode: Io.Terminal.Mode = .no_color,
environ_mutex: Io.Mutex,
environ_initialized: bool,
environ: Environ,
null_fd: CachedFd,
random_fd: CachedFd,
csprng_mutex: Io.Mutex,
csprng: Csprng,
const Thread = struct {
required_align: void align(4),
thread: std.Thread,
idle_context: Io.fiber.Context,
current_context: *Io.fiber.Context,
ready_queue: ?*Fiber,
free_queue: ?*Fiber,
io_uring: IoUring,
idle_search_index: u32,
steal_ready_search_index: u32,
steal_free_search_index: u32,
name_arena: if (tracy.enable) std.heap.ArenaAllocator.State else struct {},
csprng: Csprng,
threadlocal var self: ?*Thread = null;
noinline fn current() *Thread {
return self.?;
}
fn deinit(thread: *Thread, gpa: Allocator) void {
var next_fiber = thread.free_queue;
while (next_fiber) |free_fiber| {
next_fiber = free_fiber.status.free_next;
gpa.free(free_fiber.allocatedSlice());
}
thread.io_uring.deinit();
}
fn currentFiber(thread: *Thread) *Fiber {
assert(thread.current_context != &thread.idle_context);
return @fieldParentPtr("context", thread.current_context);
}
fn enqueue(thread: *Thread) *linux.io_uring_sqe {
while (true) return thread.io_uring.get_sqe() catch {
thread.submit();
continue;
};
}
fn submit(thread: *Thread) void {
_ = thread.io_uring.submit() catch |err| switch (err) {
error.SignalInterrupt => {},
else => |e| @panic(@errorName(e)),
};
}
const List = struct {
allocated: []Thread,
reserved: u32,
active: u32,
};
};
const Fiber = struct {
required_align: void align(4),
context: Io.fiber.Context,
link: union {
awaiter: ?*Fiber,
group: struct { prev: ?*Fiber, next: ?*Fiber },
},
status: union(enum) {
queue_next: ?*Fiber,
awaiting_group: Group,
free_next: ?*Fiber,
},
cancel_status: CancelStatus,
cancel_protection: CancelProtection,
name: if (tracy.enable) [*:0]const u8 else void,
var next_name: u64 = 0;
const CancelStatus = packed struct(u32) {
requested: bool,
awaiting: Awaiting,
const unrequested: CancelStatus = .{ .requested = false, .awaiting = .nothing };
const Awaiting = enum(u31) {
nothing = std.math.maxInt(u31),
group = std.math.maxInt(u31) - 1,
/// io_uring 文件描述符。
_,
fn subWrap(lhs: Awaiting, rhs: Awaiting) Awaiting {
return @fromBackingInt(@intCast(@backingInt(lhs) -% @backingInt(rhs)));
}
fn fromIoUringFd(fd: fd_t) Awaiting {
const awaiting: Awaiting = @fromBackingInt(@intCast(fd));
switch (awaiting) {
.nothing, .group => unreachable,
_ => return awaiting,
}
}
fn toIoUringFd(awaiting: Awaiting) fd_t {
switch (awaiting) {
.nothing, .group => unreachable,
_ => return @backingInt(awaiting),
}
}
};
fn changeAwaiting(
cancel_status: *CancelStatus,
old_awaiting: Awaiting,
new_awaiting: Awaiting,
) bool {
const old_cancel_status = @atomicRmw(CancelStatus, cancel_status, .Add, .{
.requested = false,
.awaiting = new_awaiting.subWrap(old_awaiting),
}, .monotonic);
assert(old_cancel_status.awaiting == old_awaiting);
return old_cancel_status.requested;
}
};
const CancelProtection = packed struct {
user: Io.CancelProtection,
acknowledged: bool,
const unblocked: CancelProtection = .{ .user = .unblocked, .acknowledged = false };
fn check(cancel_protection: CancelProtection) Io.CancelProtection {
return @fromBackingInt(@intCast(@intFromBool(cancel_protection != unblocked)));
}
fn acknowledge(cancel_protection: *CancelProtection) void {
assert(!cancel_protection.acknowledged);
cancel_protection.acknowledged = true;
}
fn recancel(cancel_protection: *CancelProtection) void {
assert(cancel_protection.acknowledged);
cancel_protection.acknowledged = false;
}
test check {
try std.testing.expectEqual(Io.CancelProtection.unblocked, check(.unblocked));
try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
.user = .unblocked,
.acknowledged = true,
}));
try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
.user = .blocked,
.acknowledged = false,
}));
try std.testing.expectEqual(Io.CancelProtection.blocked, check(.{
.user = .blocked,
.acknowledged = true,
}));
}
};
const finished: ?*Fiber = @ptrFromInt(@alignOf(Fiber));
const max_result_align: Alignment = .@"16";
const max_result_size = max_result_align.forward(512);
/// 包含所需的全部栈重新对齐,以及初始帧返回地址槽和参数帧,具体取决于目标。
///
const min_stack_size = 60 * 1024 * 1024;
const max_context_align: Alignment = .@"16";
const max_context_size = max_context_align.forward(1024);
const max_closure_size: usize = @sizeOf(AsyncClosure);
const max_closure_align: Alignment = .of(AsyncClosure);
const allocation_size = std.mem.alignForward(
usize,
max_closure_align.max(max_context_align).forward(
max_result_align.forward(@sizeOf(Fiber)) + max_result_size + min_stack_size,
) + max_closure_size + max_context_size,
std.heap.page_size_max,
);
comptime {
assert(max_result_align.compare(.gte, .of(Completion)));
assert(max_result_size >= @sizeOf(Completion));
}
fn create(ev: *Evented) error{OutOfMemory}!*Fiber {
const thread: *Thread = .current();
if (@atomicRmw(?*Fiber, &thread.free_queue, .Xchg, finished, .acquire)) |free_fiber| {
assert(free_fiber != finished);
@atomicStore(?*Fiber, &thread.free_queue, free_fiber.status.free_next, .release);
return free_fiber;
}
const active_threads = @atomicLoad(u32, &ev.threads.active, .acquire);
for (0..@min(max_steal_free_search, active_threads)) |_| {
defer thread.steal_free_search_index += 1;
if (thread.steal_free_search_index == active_threads) thread.steal_free_search_index = 0;
const steal_free_search_thread =
&ev.threads.allocated[0..active_threads][thread.steal_free_search_index];
if (steal_free_search_thread == thread) continue;
const free_fiber =
@atomicLoad(?*Fiber, &steal_free_search_thread.free_queue, .monotonic) orelse continue;
if (free_fiber == finished) continue;
if (@cmpxchgWeak(
?*Fiber,
&steal_free_search_thread.free_queue,
free_fiber,
null,
.acquire,
.monotonic,
)) |_| continue;
@atomicStore(?*Fiber, &thread.free_queue, free_fiber.status.free_next, .release);
return free_fiber;
}
@atomicStore(?*Fiber, &thread.free_queue, null, .monotonic);
return @ptrCast(try ev.allocator().alignedAlloc(u8, .of(Fiber), allocation_size));
}
fn destroy(fiber: *Fiber) void {
const thread: *Thread = .current();
assert(fiber.status.queue_next == null);
fiber.status = .{ .free_next = @atomicLoad(?*Fiber, &thread.free_queue, .acquire) };
while (true) fiber.status.free_next = @cmpxchgWeak(
?*Fiber,
&thread.free_queue,
fiber.status.free_next,
fiber,
.acq_rel,
.acquire,
) orelse break;
}
fn allocatedSlice(f: *Fiber) []align(@alignOf(Fiber)) u8 {
return @as([*]align(@alignOf(Fiber)) u8, @ptrCast(f))[0..allocation_size];
}
fn allocatedEnd(f: *Fiber) [*]u8 {
const allocated_slice = f.allocatedSlice();
return allocated_slice[allocated_slice.len..].ptr;
}
fn resultPointer(f: *Fiber, comptime Result: type) *Result {
return @ptrCast(@alignCast(f.resultBytes(.of(Result))));
}
fn resultBytes(f: *Fiber, alignment: Alignment) [*]u8 {
return @ptrFromInt(alignment.forward(@intFromPtr(f) + @sizeOf(Fiber)));
}
const Queue = struct { head: *Fiber, tail: *Fiber };
/// 类似 `*Fiber`,但比指针少 2 位(由于对齐,最低有效位始终为 0),
/// 以便将这两位用于 `packed struct`。
const PackedPtr = enum(@Int(.unsigned, @bitSizeOf(usize) - 2)) {
null = 0,
all_ones = std.math.maxInt(@Int(.unsigned, @bitSizeOf(usize) - 2)),
_,
const Split = packed struct(usize) { low: u2, high: PackedPtr };
fn pack(ptr: ?*Fiber) PackedPtr {
const split: Split = @bitCast(@intFromPtr(ptr));
assert(split.low == 0);
return split.high;
}
fn unpack(ptr: PackedPtr) ?*Fiber {
const split: Split = .{ .low = 0, .high = ptr };
return @ptrFromInt(@as(usize, @bitCast(split)));
}
};
fn requestCancel(fiber: *Fiber, ev: *Evented) void {
const cancel_status = @atomicRmw(
Fiber.CancelStatus,
&fiber.cancel_status,
.Or,
.{ .requested = true, .awaiting = @fromBackingInt(@intCast(0)) },
.acquire,
);
assert(!cancel_status.requested);
switch (cancel_status.awaiting) {
.nothing => {},
.group => {
// 等待方在等待组期间收到取消请求,
// 因此将取消传播到该组。
if (fiber.status.awaiting_group.cancel(ev, null)) {
fiber.status = .{ .queue_next = null };
_ = ev.schedule(.current(), .{ .head = fiber, .tail = fiber });
}
},
_ => |awaiting| {
const awaiting_io_uring_fd = awaiting.toIoUringFd();
const thread: *Thread = .current();
thread.enqueue().* = if (thread.io_uring.fd == awaiting_io_uring_fd) .{
.opcode = .ASYNC_CANCEL,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = @intFromPtr(fiber),
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.wakeup),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
} else .{
.opcode = .MSG_RING,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = awaiting_io_uring_fd,
.off = @intFromPtr(fiber) | 0b01,
.addr = @backingInt(linux.IORING_MSG_RING_COMMAND.DATA),
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.cleanup),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
},
}
}
};
const CancelRegion = struct {
fiber: *Fiber,
status: Fiber.CancelStatus,
fn init() CancelRegion {
const fiber = Thread.current().currentFiber();
return .{
.fiber = fiber,
.status = .{
.requested = fiber.cancel_protection.check() == .unblocked,
.awaiting = .nothing,
},
};
}
fn initBlocked() CancelRegion {
return .{
.fiber = Thread.current().currentFiber(),
.status = .{ .requested = false, .awaiting = .nothing },
};
}
fn deinit(cancel_region: *CancelRegion) void {
if (cancel_region.status.requested) {
@branchHint(.likely);
_ = cancel_region.fiber.cancel_status.changeAwaiting(
cancel_region.status.awaiting,
.nothing,
);
}
cancel_region.* = undefined;
}
fn await(cancel_region: *CancelRegion, awaiting: Fiber.CancelStatus.Awaiting) Io.Cancelable!void {
if (!cancel_region.status.requested) {
@branchHint(.unlikely);
return;
}
const status: Fiber.CancelStatus = .{ .requested = true, .awaiting = awaiting };
if (cancel_region.fiber.cancel_status.changeAwaiting(
cancel_region.status.awaiting,
status.awaiting,
)) {
@branchHint(.unlikely);
cancel_region.fiber.cancel_protection.acknowledge();
cancel_region.status = .unrequested;
return error.Canceled;
}
cancel_region.status = status;
}
fn awaitIoUring(cancel_region: *CancelRegion) Io.Cancelable!*Thread {
const thread: *Thread = .current();
try cancel_region.await(.fromIoUringFd(thread.io_uring.fd));
return thread;
}
fn completion(cancel_region: *const CancelRegion) Completion {
return cancel_region.fiber.resultPointer(Completion).*;
}
fn errno(cancel_region: *const CancelRegion) linux.E {
return cancel_region.completion().errno();
}
const Sync = struct {
cancel_region: CancelRegion,
fn init(ev: *Evented) Io.Cancelable!Sync {
if (ev.sync_limit) |*sync_limit| try sync_limit.wait(ev.io());
return .{ .cancel_region = .init() };
}
fn initBlocked(ev: *Evented) Sync {
if (ev.sync_limit) |*sync_limit| sync_limit.waitUncancelable(ev.io());
return .{ .cancel_region = .initBlocked() };
}
fn deinit(sync: *Sync, ev: *Evented) void {
sync.cancel_region.deinit();
if (ev.sync_limit) |*sync_limit| sync_limit.post(ev.io());
}
const Maybe = union(enum) {
cancel_region: CancelRegion,
sync: Sync,
fn deinit(maybe: *Maybe, ev: *Evented) void {
switch (maybe.*) {
.cancel_region => |*cancel_region| cancel_region.deinit(),
.sync => |*sync| sync.deinit(ev),
}
}
fn enterSync(maybe: *Maybe, ev: *Evented) Io.Cancelable!*Sync {
switch (maybe.*) {
.cancel_region => |cancel_region| {
if (ev.sync_limit) |*sync_limit| try sync_limit.wait(ev.io());
maybe.* = .{ .sync = .{ .cancel_region = cancel_region } };
},
.sync => {},
}
return &maybe.sync;
}
fn leaveSync(maybe: *Maybe, ev: *Evented) void {
switch (maybe.*) {
.cancel_region => {},
.sync => |sync| {
if (ev.sync_limit) |*sync_limit| sync_limit.post(ev.io());
maybe.* = .{ .cancel_region = sync.cancel_region };
},
}
}
fn cancelRegion(maybe: *Maybe) *CancelRegion {
return switch (maybe.*) {
.cancel_region => |*cancel_region| cancel_region,
.sync => |*sync| &sync.cancel_region,
};
}
};
};
};
const CachedFd = struct {
once: Once,
const Once = enum(fd_t) {
uninitialized = -1,
initializing = -2,
/// fd
_,
fn fromFd(fd: fd_t) Once {
return @fromBackingInt(@intCast(@as(u31, @intCast(fd))));
}
fn toFd(once: Once) fd_t {
return @as(u31, @intCast(@backingInt(once)));
}
};
const init: CachedFd = .{ .once = .uninitialized };
fn close(cached_fd: *CachedFd) void {
switch (cached_fd.once) {
.uninitialized => {},
.initializing => unreachable,
_ => |fd| {
assert(@backingInt(fd) >= 0);
_ = linux.close(@backingInt(fd));
cached_fd.* = .init;
},
}
}
fn open(
cached_fd: *CachedFd,
ev: *Evented,
cancel_region: *CancelRegion,
path: [*:0]const u8,
flags: linux.O,
) File.OpenError!fd_t {
var once = @atomicLoad(Once, &cached_fd.once, .monotonic);
while (true) {
switch (once) {
.uninitialized => {},
.initializing => try futexWait(
ev,
@ptrCast(&cached_fd.once),
@bitCast(@backingInt(once)),
.none,
),
_ => |fd| {
@branchHint(.likely);
return fd.toFd();
},
}
once = @cmpxchgWeak(
Once,
&cached_fd.once,
.uninitialized,
.initializing,
.monotonic,
.monotonic,
) orelse {
errdefer {
@atomicStore(Once, &cached_fd.once, .uninitialized, .monotonic);
futexWake(ev, @ptrCast(&cached_fd.once), 1);
}
const fd = ev.openat(cancel_region, linux.AT.FDCWD, path, flags, 0) catch |err| switch (err) {
error.OperationUnsupported => return error.Unexpected, // 未设置 TMPFILE。
else => |e| return e,
};
@atomicStore(Once, &cached_fd.once, .fromFd(fd), .monotonic);
futexWake(ev, @ptrCast(&cached_fd.once), std.math.maxInt(u32));
return fd;
};
}
}
};
pub fn allocator(ev: *Evented) std.mem.Allocator {
return if (ev.backing_allocator_needs_mutex) .{
.ptr = ev,
.vtable = &.{
.alloc = alloc,
.resize = resize,
.remap = remap,
.free = free,
},
} else ev.backing_allocator;
}
fn alloc(userdata: *anyopaque, len: usize, alignment: std.mem.Alignment, ret_addr: usize) ?[*]u8 {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const ev_io = ev.io();
ev.backing_allocator_mutex.lockUncancelable(ev_io);
defer ev.backing_allocator_mutex.unlock(ev_io);
return ev.backing_allocator.rawAlloc(len, alignment, ret_addr);
}
fn resize(
userdata: *anyopaque,
memory: []u8,
alignment: std.mem.Alignment,
new_len: usize,
ret_addr: usize,
) bool {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const ev_io = ev.io();
ev.backing_allocator_mutex.lockUncancelable(ev_io);
defer ev.backing_allocator_mutex.unlock(ev_io);
return ev.backing_allocator.rawResize(memory, alignment, new_len, ret_addr);
}
fn remap(
userdata: *anyopaque,
memory: []u8,
alignment: Alignment,
new_len: usize,
ret_addr: usize,
) ?[*]u8 {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const ev_io = ev.io();
ev.backing_allocator_mutex.lockUncancelable(ev_io);
defer ev.backing_allocator_mutex.unlock(ev_io);
return ev.backing_allocator.rawRemap(memory, alignment, new_len, ret_addr);
}
fn free(userdata: *anyopaque, memory: []u8, alignment: std.mem.Alignment, ret_addr: usize) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const ev_io = ev.io();
ev.backing_allocator_mutex.lockUncancelable(ev_io);
defer ev.backing_allocator_mutex.unlock(ev_io);
return ev.backing_allocator.rawFree(memory, alignment, ret_addr);
}
pub fn io(ev: *Evented) Io {
return .{
.userdata = ev,
.vtable = &.{
.crashHandler = crashHandler,
.async = async,
.concurrent = concurrent,
.await = await,
.cancel = cancel,
.groupAsync = groupAsync,
.groupConcurrent = groupConcurrent,
.groupAwait = groupAwait,
.groupCancel = groupCancel,
.recancel = recancel,
.swapCancelProtection = swapCancelProtection,
.checkCancel = checkCancel,
.futexWait = futexWait,
.futexWaitUncancelable = futexWaitUncancelable,
.futexWake = futexWake,
.operate = operate,
.batchAwaitAsync = batchAwaitAsync,
.batchAwaitConcurrent = batchAwaitConcurrent,
.batchCancel = batchCancel,
.dirCreateDir = dirCreateDir,
.dirCreateDirPath = dirCreateDirPath,
.dirCreateDirPathOpen = dirCreateDirPathOpen,
.dirOpenDir = dirOpenDir,
.dirStat = dirStat,
.dirStatFile = dirStatFile,
.dirAccess = dirAccess,
.dirCreateFile = dirCreateFile,
.dirCreateFileAtomic = dirCreateFileAtomic,
.dirOpenFile = dirOpenFile,
.dirClose = dirClose,
.dirRead = dirRead,
.dirRealPath = dirRealPath,
.dirRealPathFile = dirRealPathFile,
.dirDeleteFile = dirDeleteFile,
.dirDeleteDir = dirDeleteDir,
.dirRename = dirRename,
.dirRenamePreserve = dirRenamePreserve,
.dirSymLink = dirSymLink,
.dirReadLink = dirReadLink,
.dirSetOwner = dirSetOwner,
.dirSetFileOwner = dirSetFileOwner,
.dirSetPermissions = dirSetPermissions,
.dirSetFilePermissions = dirSetFilePermissions,
.dirSetTimestamps = dirSetTimestamps,
.dirHardLink = dirHardLink,
.fileStat = fileStat,
.fileLength = fileLength,
.fileClose = fileClose,
.fileWritePositional = fileWritePositional,
.fileWriteFileStreaming = fileWriteFileStreaming,
.fileWriteFilePositional = fileWriteFilePositional,
.fileReadPositional = fileReadPositional,
.fileSeekBy = fileSeekBy,
.fileSeekTo = fileSeekTo,
.fileSync = fileSync,
.fileIsTty = fileIsTty,
.fileEnableAnsiEscapeCodes = fileEnableAnsiEscapeCodes,
.fileSupportsAnsiEscapeCodes = fileIsTty,
.fileSetLength = fileSetLength,
.fileSetOwner = fileSetOwner,
.fileSetPermissions = fileSetPermissions,
.fileSetTimestamps = fileSetTimestamps,
.fileLock = fileLock,
.fileTryLock = fileTryLock,
.fileUnlock = fileUnlock,
.fileDowngradeLock = fileDowngradeLock,
.fileRealPath = fileRealPath,
.fileHardLink = fileHardLink,
.fileMemoryMapCreate = fileMemoryMapCreate,
.fileMemoryMapDestroy = fileMemoryMapDestroy,
.fileMemoryMapSetLength = fileMemoryMapSetLength,
.fileMemoryMapRead = fileMemoryMapRead,
.fileMemoryMapWrite = fileMemoryMapWrite,
.processExecutableOpen = processExecutableOpen,
.processExecutablePath = processExecutablePath,
.lockStderr = lockStderr,
.tryLockStderr = tryLockStderr,
.unlockStderr = unlockStderr,
.processCurrentPath = processCurrentPath,
.processSetCurrentDir = processSetCurrentDir,
.processSetCurrentPath = processSetCurrentPath,
.processReplace = processReplace,
.processSpawn = processSpawn,
.childWait = childWait,
.childKill = childKill,
.progressParentFile = progressParentFile,
.inheritParentDir = inheritParentDir,
.inheritParentFile = inheritParentFile,
.now = now,
.clockResolution = clockResolution,
.sleep = sleep,
.random = random,
.randomSecure = randomSecure,
.netListenIp = netListenIpUnavailable,
.netAccept = netAcceptUnavailable,
.netBindIp = netBindIp,
.netConnectIp = netConnectIpUnavailable,
.netListenUnix = netListenUnixUnavailable,
.netConnectUnix = netConnectUnixUnavailable,
.netSocketCreatePair = netSocketCreatePairUnavailable,
.netWriteFile = netWriteFileUnavailable,
.netClose = netClose,
.netShutdown = netShutdown,
.netInterfaceNameResolve = netInterfaceNameResolveUnavailable,
.netInterfaceName = netInterfaceNameUnavailable,
.netLookup = netLookupUnavailable,
},
};
}
pub const InitOptions = struct {
backing_allocator_needs_mutex: bool = true,
/// 线程池大小上限,不包括主线程。
/// 默认为逻辑 CPU 核心数减一。
thread_limit: ?usize = null,
/// 允许执行同步系统调用的最大线程数。
sync_limit: Io.Limit = .unlimited,
log2_ring_entries: u4 = 3,
/// 影响以下操作:
/// * OpenBSD 和 Haiku 上的 `processExecutablePath`。
argv0: Argv0 = .empty,
/// 影响以下操作:
/// * `fileIsTty`
/// * `processSpawn`、`processReplace`
environ: process.Environ = .empty,
};
pub fn init(ev: *Evented, backing_allocator: Allocator, options: InitOptions) !void {
const threads_size = @sizeOf(Thread) * if (options.thread_limit) |thread_limit|
1 + thread_limit
else
@max(std.Thread.getCpuCount() catch 1, 1);
const idle_stack_end_offset =
std.mem.alignForward(usize, threads_size + idle_stack_size, std.heap.pageSize());
const allocated_slice = try backing_allocator.alignedAlloc(u8, .of(Thread), idle_stack_end_offset);
errdefer backing_allocator.free(allocated_slice);
ev.* = .{
.backing_allocator_needs_mutex = options.backing_allocator_needs_mutex,
.backing_allocator_mutex = .init,
.backing_allocator = backing_allocator,
.main_fiber_buffer = undefined,
.log2_ring_entries = options.log2_ring_entries,
.threads = .{
.allocated = @ptrCast(allocated_slice[0..threads_size]),
.reserved = 1,
.active = 1,
},
.sync_limit = if (options.sync_limit.toInt()) |sync_limit| .{ .permits = sync_limit } else null,
.stderr_writer_initialized = false,
.stderr_mutex = .init,
.stderr_writer = .{
.io = ev.io(),
.interface = Io.File.Writer.initInterface(&.{}),
.file = .stderr(),
.mode = .streaming,
},
.stderr_mode = .no_color,
.environ_mutex = .init,
.environ_initialized = options.environ.block.isEmpty(),
.environ = .{ .process_environ = options.environ },
.null_fd = .init,
.random_fd = .init,
.csprng_mutex = .init,
.csprng = .uninitialized,
};
const main_fiber: *Fiber = @ptrCast(&ev.main_fiber_buffer);
main_fiber.* = .{
.required_align = {},
.context = undefined,
.link = .{ .awaiter = null },
.status = .{ .queue_next = null },
.cancel_status = .unrequested,
.cancel_protection = .unblocked,
.name = if (tracy.enable) "main task",
};
const main_thread = &ev.threads.allocated[0];
Thread.self = main_thread;
main_thread.* = .{
.required_align = {},
.thread = undefined,
.idle_context = switch (builtin.cpu.arch) {
.aarch64 => .{
.sp = @intFromPtr(allocated_slice[idle_stack_end_offset..].ptr),
.fp = @intFromPtr(ev),
.pc = @intFromPtr(&mainIdleEntry),
},
.riscv64 => .{
.sp = @intFromPtr(allocated_slice[idle_stack_end_offset..].ptr),
.fp = @intFromPtr(ev),
.pc = @intFromPtr(&mainIdleEntry),
},
.x86_64 => .{
.rsp = @intFromPtr(allocated_slice[idle_stack_end_offset..].ptr),
.rbp = @intFromPtr(ev),
.rip = @intFromPtr(&mainIdleEntry),
},
else => @compileError("unimplemented architecture"),
},
.current_context = &main_fiber.context,
.ready_queue = null,
.free_queue = null,
.io_uring = try .init(
@as(u16, 1) << ev.log2_ring_entries,
linux.IORING_SETUP_COOP_TASKRUN | linux.IORING_SETUP_SINGLE_ISSUER,
),
.idle_search_index = 1,
.steal_ready_search_index = 1,
.steal_free_search_index = 1,
.name_arena = .{},
.csprng = .uninitialized,
};
errdefer main_thread.io_uring.deinit();
if (tracy.enable) tracy.fiberEnter(main_fiber.name);
}
pub fn deinit(ev: *Evented) void {
const main_fiber: *Fiber = @ptrCast(&ev.main_fiber_buffer);
assert(Thread.current().currentFiber() == main_fiber);
const active_threads = @atomicLoad(u32, &ev.threads.active, .acquire);
for (ev.threads.allocated[0..active_threads]) |*thread| {
const ready_fiber = @atomicLoad(?*Fiber, &thread.ready_queue, .monotonic);
assert(ready_fiber == null or ready_fiber == Fiber.finished); // 待处理的异步操作
}
ev.yield(null, .exit);
ev.null_fd.close();
ev.random_fd.close();
const allocated_ptr: [*]align(@alignOf(Thread)) u8 = @ptrCast(@alignCast(ev.threads.allocated.ptr));
const idle_stack_end_offset = std.mem.alignForward(
usize,
ev.threads.allocated.len * @sizeOf(Thread) + idle_stack_size,
std.heap.pageSize(),
);
for (ev.threads.allocated[1..active_threads]) |*thread| thread.thread.join();
for (ev.threads.allocated[0..active_threads]) |*thread| thread.deinit(ev.backing_allocator);
assert(active_threads == ev.threads.active); // 没有待处理异步任务时创建了线程?
ev.backing_allocator.free(allocated_ptr[0..idle_stack_end_offset]);
ev.* = undefined;
}
fn findReadyFiber(ev: *Evented, thread: *Thread) ?*Fiber {
if (@atomicRmw(?*Fiber, &thread.ready_queue, .Xchg, Fiber.finished, .acquire)) |ready_fiber| {
assert(ready_fiber != Fiber.finished);
@atomicStore(?*Fiber, &thread.ready_queue, ready_fiber.status.queue_next, .release);
ready_fiber.status.queue_next = null;
return ready_fiber;
}
const active_threads = @atomicLoad(u32, &ev.threads.active, .acquire);
for (0..@min(max_steal_ready_search, active_threads)) |_| {
defer thread.steal_ready_search_index += 1;
if (thread.steal_ready_search_index == active_threads) thread.steal_ready_search_index = 0;
const steal_ready_search_thread =
&ev.threads.allocated[0..active_threads][thread.steal_ready_search_index];
if (steal_ready_search_thread == thread) continue;
const ready_fiber =
@atomicLoad(?*Fiber, &steal_ready_search_thread.ready_queue, .monotonic) orelse continue;
if (ready_fiber == Fiber.finished) continue;
if (@cmpxchgWeak(
?*Fiber,
&steal_ready_search_thread.ready_queue,
ready_fiber,
null,
.acquire,
.monotonic,
)) |_| continue;
@atomicStore(?*Fiber, &thread.ready_queue, ready_fiber.status.queue_next, .release);
ready_fiber.status.queue_next = null;
return ready_fiber;
}
// 未找到要做的工作,因此现在可以正常处理请求
@atomicStore(?*Fiber, &thread.ready_queue, null, .monotonic);
return null;
}
fn yield(ev: *Evented, maybe_ready_fiber: ?*Fiber, pending_task: SwitchMessage.PendingTask) void {
const thread: *Thread = .current();
const ready_context = if (maybe_ready_fiber orelse ev.findReadyFiber(thread)) |ready_fiber|
&ready_fiber.context
else
&thread.idle_context;
const message: SwitchMessage = .{
.contexts = .{
.old = thread.current_context,
.new = ready_context,
},
.pending_task = pending_task,
};
contextSwitch(&message).handle(ev);
}
fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool {
// 必须先初始化前一个 `Thread` 的共享字段,再将后续线程标记为活动。
const new_thread_index = @atomicLoad(u32, &ev.threads.active, .acquire);
for (0..@min(max_idle_search, new_thread_index)) |_| {
defer thread.idle_search_index += 1;
if (thread.idle_search_index == new_thread_index) thread.idle_search_index = 0;
const idle_search_thread = &ev.threads.allocated[0..new_thread_index][thread.idle_search_index];
if (idle_search_thread == thread) continue;
if (@cmpxchgWeak(
?*Fiber,
&idle_search_thread.ready_queue,
null,
ready_queue.head,
.release,
.monotonic,
)) |_| continue;
thread.enqueue().* = .{
.opcode = .MSG_RING,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = idle_search_thread.io_uring.fd,
.off = @backingInt(Completion.Userdata.wakeup),
.addr = @backingInt(linux.IORING_MSG_RING_COMMAND.DATA),
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.wakeup),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
return true;
}
spawn_thread: {
// 重试之前,先前失败的预留必须已经完成
if (new_thread_index == ev.threads.allocated.len or @cmpxchgWeak(
u32,
&ev.threads.reserved,
new_thread_index,
new_thread_index + 1,
.acquire,
.monotonic,
) != null) break :spawn_thread;
const new_thread = &ev.threads.allocated[new_thread_index];
const next_thread_index = new_thread_index + 1;
var params = std.mem.zeroInit(linux.io_uring_params, .{
.flags = linux.IORING_SETUP_ATTACH_WQ |
linux.IORING_SETUP_R_DISABLED |
linux.IORING_SETUP_COOP_TASKRUN |
linux.IORING_SETUP_SINGLE_ISSUER,
.wq_fd = @as(u32, @intCast(ev.threads.allocated[0].io_uring.fd)),
});
new_thread.* = .{
.required_align = {},
.thread = undefined,
.idle_context = undefined,
.current_context = &new_thread.idle_context,
.ready_queue = ready_queue.head,
.free_queue = null,
.io_uring = IoUring.init_params(@as(u16, 1) << ev.log2_ring_entries, ¶ms) catch |err| {
@atomicStore(u32, &ev.threads.reserved, new_thread_index, .release);
// 放弃保留资格后,不得再访问 `thread`
log.warn("unable to create worker thread due to io_uring init failure: {s}", .{
@errorName(err),
});
break :spawn_thread;
},
.idle_search_index = 0,
.steal_ready_search_index = 0,
.steal_free_search_index = 0,
.name_arena = .{},
.csprng = .uninitialized,
};
new_thread.thread = std.Thread.spawn(.{
.stack_size = idle_stack_size,
.allocator = ev.allocator(),
}, threadEntry, .{ ev, new_thread_index }) catch |err| {
new_thread.io_uring.deinit();
@atomicStore(u32, &ev.threads.reserved, new_thread_index, .release);
// 放弃保留资格后,不得再访问 `thread`
log.warn("unable to create worker thread due spawn failure: {s}", .{@errorName(err)});
break :spawn_thread;
};
// 必须在标记为活动前初始化 `Thread` 的共享字段
@atomicStore(u32, &ev.threads.active, next_thread_index, .release);
return false;
}
// 无人需要它,因此直接加入自身队列
while (true) ready_queue.tail.status.queue_next = @cmpxchgWeak(
?*Fiber,
&thread.ready_queue,
ready_queue.tail.status.queue_next,
ready_queue.head,
.acq_rel,
.acquire,
) orelse break;
return false;
}
fn threadEntry(ev: *Evented, index: u32) void {
const thread: *Thread = &ev.threads.allocated[index];
Thread.self = thread;
switch (linux.errno(linux.io_uring_register(thread.io_uring.fd, .REGISTER_ENABLE_RINGS, null, 0))) {
.SUCCESS => ev.idle(thread),
else => |err| @panic(@tagName(err)),
}
}
const Completion = struct {
result: i32,
flags: u32,
const Userdata = enum(usize) {
unused,
wakeup,
futex_wake,
close,
cleanup,
exit,
/// 若位 0 为 1,则是指向 `Io.Batch.Storage.Pending` 的 `context` 字段的指针。
/// 若位 0 和位 1 均为 0,则是 `*Fiber`。
_,
};
fn errno(completion: Completion) linux.E {
return linux.errno(completion.result);
}
};
fn mainIdleEntry() callconv(.naked) void {
switch (builtin.cpu.arch) {
.aarch64 => asm volatile (
\\ mov x0, fp
\\ mov fp, #0
\\ b %[mainIdle]
:
: [mainIdle] "X" (&mainIdle),
),
.riscv64 => asm volatile (
\\ mv a0, fp
\\ mv fp, zero
\\ tail %[mainIdle]@plt
:
: [mainIdle] "X" (&mainIdle),
),
.x86_64 => asm volatile (
\\ movq %%rbp, %%rdi
\\ xor %%ebp, %%ebp
\\ jmp %[mainIdle:P]
:
: [mainIdle] "X" (&mainIdle),
),
else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
}
}
fn mainIdle(
ev: *Evented,
contexts: *const Io.fiber.Switch,
) callconv(.withStackAlign(.c, @max(@alignOf(Thread), @alignOf(Io.fiber.Context)))) noreturn {
const message: *const SwitchMessage = @fieldParentPtr("contexts", contexts);
message.handle(ev);
ev.idle(&ev.threads.allocated[0]);
ev.yield(@ptrCast(&ev.main_fiber_buffer), .nothing);
unreachable; // 切换至已终止的纤程
}
fn idle(ev: *Evented, thread: *Thread) void {
var maybe_ready_fiber: ?*Fiber = null;
while (true) {
while (maybe_ready_fiber orelse ev.findReadyFiber(thread)) |ready_fiber| {
ev.yield(ready_fiber, .nothing);
maybe_ready_fiber = null;
}
_ = thread.io_uring.submit_and_wait(1) catch |err| switch (err) {
error.SignalInterrupt => {},
else => |e| @panic(@errorName(e)),
};
var maybe_ready_queue: ?Fiber.Queue = null;
while (true) {
var cqes_buffer: [1 << 8]linux.io_uring_cqe = undefined;
const cqes = cqes_buffer[0 .. thread.io_uring.copy_cqes(&cqes_buffer, 0) catch |err| switch (err) {
error.SignalInterrupt => 0,
else => |e| @panic(@errorName(e)),
}];
if (cqes.len == 0) break;
for (cqes) |cqe| if (cqe.flags & linux.IORING_CQE_F_SKIP == 0) switch (@as(
Completion.Userdata,
@fromBackingInt(@intCast(cqe.user_data)),
)) {
.unused => unreachable, // 是否有无效提交进入队列?
.wakeup => {},
.futex_wake => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
.SUCCESS => recoverableOsBugDetected(), // 跳过成功结果
.INVAL => {}, // 其他位置对 ptr 进行了无效 futex_wait()
.INTR, .CANCELED => recoverableOsBugDetected(), // `Completion.Userdata.futex_wake` 不可取消
.FAULT => {}, // 指针在执行唤醒时失效
else => recoverableOsBugDetected(), // 因操作系统缺陷而死锁
},
.close => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
.BADF => recoverableOsBugDetected(), // 始终存在竞态条件。
.INTR => {}, // 这仍然是成功。参见 https://github.com/ziglang/zig/issues/2425
else => {},
},
.cleanup => @panic("failed to notify other threads that we are exiting"),
.exit => {
assert(maybe_ready_fiber == null and maybe_ready_queue == null); // 待处理的异步操作
return;
},
_ => if (@as(?*Fiber, ready_fiber: switch (@as(u2, @truncate(cqe.user_data))) {
0b00 => {
const ready_fiber: *Fiber = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
ready_fiber.resultPointer(Completion).* = .{
.result = cqe.res,
.flags = cqe.flags,
};
break :ready_fiber ready_fiber;
},
0b01 => {
thread.enqueue().* = .{
.opcode = .ASYNC_CANCEL,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = cqe.user_data & ~@as(usize, 0b11),
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.wakeup),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
break :ready_fiber null;
},
0b10 => {
const batch_userdata: *Io.Operation.Storage.Pending.Userdata =
@ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
const batch: *Io.Batch = @ptrFromInt(batch_userdata[0]);
var next: usize = 0b00;
batch_userdata[0..3].* = .{ next, @as(u32, @bitCast(cqe.res)), cqe.flags };
while (true) {
next = @cmpxchgWeak(
usize,
@as(*usize, @ptrCast(&batch.userdata)),
next,
cqe.user_data,
.release,
.acquire,
) orelse break;
batch_userdata[0] = next;
}
break :ready_fiber switch (@as(u2, @truncate(next))) {
0b00 => @ptrFromInt(next),
0b01 => null, // 超时完成事件已唤醒此纤程
0b10, 0b11 => null,
};
},
0b11 => switch (Completion.errno(.{ .result = cqe.res, .flags = cqe.flags })) {
.SUCCESS => unreachable, // 未指定事件计数
.TIME => {
const context: *usize = @ptrFromInt(cqe.user_data & ~@as(usize, 0b11));
const fiber = @atomicRmw(usize, context, .Add, 0b01, .acquire);
break :ready_fiber switch (@as(u2, @truncate(fiber))) {
else => unreachable, // 多次完成了超时操作
0b00 => @ptrFromInt(fiber & ~@as(usize, 0b11)),
0b10 => null,
};
},
.CANCELED => null, // 用户数据可能已失效
else => |err| unexpectedErrno(err) catch null,
},
})) |ready_fiber| {
assert(ready_fiber.status.queue_next == null);
if (maybe_ready_fiber == null) {
maybe_ready_fiber = ready_fiber;
} else if (maybe_ready_queue) |*ready_queue| {
ready_queue.tail.status.queue_next = ready_fiber;
ready_queue.tail = ready_fiber;
} else maybe_ready_queue = .{ .head = ready_fiber, .tail = ready_fiber };
},
};
}
if (maybe_ready_queue) |ready_queue| _ = ev.schedule(thread, ready_queue);
}
}
const SwitchMessage = struct {
contexts: Io.fiber.Switch,
pending_task: PendingTask,
const PendingTask = union(enum) {
nothing,
reschedule,
await: *Fiber,
group_await: Group,
group_cancel: Group,
batch_await: *Io.Batch,
destroy,
exit,
};
fn handle(message: *const SwitchMessage, ev: *Evented) void {
const thread: *Thread = .current();
thread.current_context = message.contexts.new;
if (tracy.enable) {
if (message.contexts.new != &thread.idle_context) {
const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.new));
tracy.fiberEnter(fiber.name);
} else tracy.fiberLeave();
}
switch (message.pending_task) {
.nothing => {},
.reschedule => if (message.contexts.old != &thread.idle_context) {
const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
assert(fiber.status.queue_next == null);
_ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
},
.await => |awaiting| {
const awaiter: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
assert(awaiter.status.queue_next == null);
if (@atomicRmw(?*Fiber, &awaiting.link.awaiter, .Xchg, awaiter, .acq_rel) ==
Fiber.finished) _ = ev.schedule(thread, .{ .head = awaiter, .tail = awaiter });
},
.group_await => |group| {
const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
if (group.await(ev, fiber))
_ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
},
.group_cancel => |group| {
const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
if (group.cancel(ev, fiber))
_ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
},
.batch_await => |batch| {
const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
if (@cmpxchgStrong(
?*anyopaque,
&batch.userdata,
null,
fiber,
.release,
.monotonic,
)) |head| {
assert(@as(u2, @truncate(@intFromPtr(head))) != 0b00);
_ = ev.schedule(thread, .{ .head = fiber, .tail = fiber });
}
},
.destroy => {
const fiber: *Fiber = @alignCast(@fieldParentPtr("context", message.contexts.old));
fiber.destroy();
},
.exit => for (
ev.threads.allocated[0..@atomicLoad(u32, &ev.threads.active, .acquire)],
) |*each_thread| {
thread.enqueue().* = .{
.opcode = .MSG_RING,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = each_thread.io_uring.fd,
.off = @backingInt(Completion.Userdata.exit),
.addr = @backingInt(linux.IORING_MSG_RING_COMMAND.DATA),
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.cleanup),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
},
}
}
};
inline fn contextSwitch(message: *const SwitchMessage) *const SwitchMessage {
return @fieldParentPtr("contexts", Io.fiber.contextSwitch(&message.contexts));
}
fn crashHandler(userdata: ?*anyopaque) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
const thread = Thread.self orelse std.process.abort();
if (thread.current_context == &thread.idle_context) std.process.abort();
const fiber = thread.currentFiber();
@atomicStore(
Fiber.CancelStatus,
&fiber.cancel_status,
.{ .requested = true, .awaiting = .nothing },
.monotonic,
);
fiber.cancel_protection = .{ .user = .blocked, .acknowledged = true };
}
const AsyncClosure = struct {
evented: *Evented,
fiber: *Fiber,
start: *const fn (context: *const anyopaque, result: *anyopaque) void,
result_align: Alignment,
fn fromFiber(fiber: *Fiber) *AsyncClosure {
return @ptrFromInt(Fiber.max_context_align.max(.of(AsyncClosure)).backward(
@intFromPtr(fiber.allocatedEnd()) - Fiber.max_context_size,
) - @sizeOf(AsyncClosure));
}
fn contextPointer(closure: *AsyncClosure) [*]align(Fiber.max_context_align.toByteUnits()) u8 {
return @alignCast(@as([*]u8, @ptrCast(closure)) + @sizeOf(AsyncClosure));
}
fn entry() callconv(.naked) void {
switch (builtin.cpu.arch) {
.aarch64 => asm volatile (
\\ mov x0, sp
\\ b %[call]
:
: [call] "X" (&call),
),
.riscv64 => asm volatile (
\\ mv a0, sp
\\ tail %[call]@plt
:
: [call] "X" (&call),
),
.x86_64 => asm volatile (
\\ leaq 8(%%rsp), %%rdi
\\ jmp %[call:P]
:
: [call] "X" (&call),
),
else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
}
}
fn call(
closure: *AsyncClosure,
contexts: *const Io.fiber.Switch,
) callconv(.withStackAlign(.c, @alignOf(AsyncClosure))) noreturn {
const message: *const SwitchMessage = @fieldParentPtr("contexts", contexts);
const ev = closure.evented;
const fiber = closure.fiber;
message.handle(ev);
closure.start(closure.contextPointer(), fiber.resultBytes(closure.result_align));
ev.yield(@atomicRmw(?*Fiber, &fiber.link.awaiter, .Xchg, Fiber.finished, .acq_rel), .nothing);
unreachable; // 切换至已终止的纤程
}
};
fn async(
userdata: ?*anyopaque,
result: []u8,
result_alignment: Alignment,
context: []const u8,
context_alignment: Alignment,
start: *const fn (context: *const anyopaque, result: *anyopaque) void,
) ?*std.Io.AnyFuture {
const ev: *Evented = @ptrCast(@alignCast(userdata));
return concurrent(ev, result.len, result_alignment, context, context_alignment, start) catch {
start(context.ptr, result.ptr);
return null;
};
}
fn concurrent(
userdata: ?*anyopaque,
result_len: usize,
result_alignment: Alignment,
context: []const u8,
context_alignment: Alignment,
start: *const fn (context: *const anyopaque, result: *anyopaque) void,
) Io.ConcurrentError!*std.Io.AnyFuture {
assert(result_alignment.compare(.lte, Fiber.max_result_align)); // TODO
assert(context_alignment.compare(.lte, Fiber.max_context_align)); // TODO
assert(result_len <= Fiber.max_result_size); // TODO
assert(context.len <= Fiber.max_context_size); // TODO
const ev: *Evented = @ptrCast(@alignCast(userdata));
const fiber = Fiber.create(ev) catch |err| switch (err) {
error.OutOfMemory => return error.ConcurrencyUnavailable,
};
const closure: *AsyncClosure = .fromFiber(fiber);
fiber.* = .{
.required_align = {},
.context = switch (builtin.cpu.arch) {
.aarch64 => .{
.sp = @intFromPtr(closure),
.fp = 0,
.pc = @intFromPtr(&AsyncClosure.entry),
},
.riscv64 => .{
.sp = @intFromPtr(closure),
.fp = 0,
.pc = @intFromPtr(&AsyncClosure.entry),
},
.x86_64 => .{
.rsp = @intFromPtr(closure) - 8,
.rbp = 0,
.rip = @intFromPtr(&AsyncClosure.entry),
},
else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
},
.link = .{ .awaiter = null },
.status = .{ .queue_next = null },
.cancel_status = .unrequested,
.cancel_protection = .unblocked,
.name = if (tracy.enable) name: {
const thread: *Thread = .current();
var name_arena = thread.name_arena.promote(std.heap.page_allocator);
defer thread.name_arena = name_arena.state;
break :name std.fmt.allocPrintSentinel(
name_arena.allocator(),
"task {d}",
.{@atomicRmw(u64, &Fiber.next_name, .Add, 1, .monotonic)},
0,
) catch return error.ConcurrencyUnavailable;
},
};
closure.* = .{
.evented = ev,
.fiber = fiber,
.start = start,
.result_align = result_alignment,
};
@memcpy(closure.contextPointer(), context);
const thread: *Thread = .current();
if (ev.schedule(thread, .{ .head = fiber, .tail = fiber })) thread.submit();
return @ptrCast(fiber);
}
fn await(
userdata: ?*anyopaque,
future: *std.Io.AnyFuture,
result: []u8,
result_alignment: Alignment,
) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const awaiting: *Fiber = @ptrCast(@alignCast(future));
if (@atomicLoad(?*Fiber, &awaiting.link.awaiter, .acquire) != Fiber.finished)
ev.yield(null, .{ .await = awaiting });
@memcpy(result, awaiting.resultBytes(result_alignment));
awaiting.destroy();
}
fn cancel(
userdata: ?*anyopaque,
future: *std.Io.AnyFuture,
result: []u8,
result_alignment: Alignment,
) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const future_fiber: *Fiber = @ptrCast(@alignCast(future));
future_fiber.requestCancel(ev);
await(ev, future, result, result_alignment);
}
const Group = struct {
ptr: *Io.Group,
const List = packed struct(usize) {
cancel_requested: bool,
awaiter_delayed: bool,
fibers: Fiber.PackedPtr,
};
fn listPtr(group: Group) *List {
return @ptrCast(&group.ptr.token);
}
const Mutex = packed struct(u32) {
locked: bool,
contended: bool,
shared2: u30,
};
fn mutexPtr(group: Group) *Mutex {
return switch (comptime builtin.cpu.arch.endian()) {
.little => @ptrCast(&group.ptr.state),
.big => @ptrCast(@alignCast(
@as([*]u8, @ptrCast(&group.ptr.state)) + @sizeOf(usize) - @sizeOf(u32),
)),
};
}
const Awaiter = packed struct(usize) {
locked: bool,
contended: bool,
awaiter: Fiber.PackedPtr,
};
fn awaiterPtr(group: Group) *Awaiter {
return @ptrCast(&group.ptr.state);
}
fn lock(group: Group, ev: *Evented) void {
const mutex = group.mutexPtr();
{
const old_state = @atomicRmw(
Mutex,
mutex,
.Or,
.{ .locked = true, .contended = false, .shared2 = 0 },
.acquire,
);
if (!old_state.locked) {
@branchHint(.likely);
return;
}
if (old_state.contended) {
futexWaitUncancelable(ev, @ptrCast(mutex), @bitCast(old_state));
}
}
while (true) {
var old_state = @atomicRmw(
Mutex,
mutex,
.Or,
.{ .locked = true, .contended = true, .shared2 = 0 },
.acquire,
);
if (!old_state.locked) {
@branchHint(.likely);
return;
}
old_state.contended = true;
futexWaitUncancelable(ev, @ptrCast(mutex), @bitCast(old_state));
}
}
fn unlock(group: Group, ev: *Evented) void {
const mutex = group.mutexPtr();
const old_state = @atomicRmw(
Mutex,
mutex,
.And,
.{ .locked = false, .contended = false, .shared2 = std.math.maxInt(u30) },
.release,
);
assert(old_state.locked);
if (old_state.contended) futexWake(ev, @ptrCast(mutex), 1);
}
fn addFiber(group: Group, ev: *Evented, fiber: *Fiber) void {
group.lock(ev);
defer group.unlock(ev);
const list_ptr = group.listPtr();
const list = @atomicLoad(List, list_ptr, .monotonic);
if (list.cancel_requested) fiber.cancel_status = .{ .requested = true, .awaiting = .nothing };
const old_head = list.fibers.unpack();
if (old_head) |head| head.link.group.prev = fiber;
fiber.link.group.next = old_head;
@atomicStore(List, list_ptr, .{
.cancel_requested = list.cancel_requested,
.awaiter_delayed = list.awaiter_delayed,
.fibers = .pack(fiber),
}, .monotonic);
}
fn removeFiber(group: Group, ev: *Evented, fiber: *Fiber) ?*Fiber {
group.lock(ev);
defer group.unlock(ev);
const list_ptr = group.listPtr();
const list = @atomicLoad(List, list_ptr, .monotonic);
if (fiber.link.group.next) |next| next.link.group.prev = fiber.link.group.prev;
if (fiber.link.group.prev) |prev| {
prev.link.group.next = fiber.link.group.next;
} else if (fiber.link.group.next) |new_head| {
@atomicStore(List, list_ptr, .{
.cancel_requested = list.cancel_requested,
.awaiter_delayed = list.awaiter_delayed,
.fibers = .pack(new_head),
}, .monotonic);
} else if (@atomicLoad(Awaiter, group.awaiterPtr(), .monotonic).awaiter.unpack()) |awaiter| {
if (!awaiter.cancel_status.changeAwaiting(.group, .nothing) or list.cancel_requested) {
@atomicStore(List, list_ptr, .{
.cancel_requested = false,
.awaiter_delayed = false,
.fibers = .null,
}, .release);
assert(awaiter.status.awaiting_group.ptr == group.ptr);
awaiter.status = .{ .queue_next = null };
return awaiter;
}
// 与 `Fiber.requestCancel` 发生竞态
@atomicStore(List, list_ptr, .{
.cancel_requested = false,
.awaiter_delayed = true,
.fibers = .null,
}, .monotonic);
} else @atomicStore(List, list_ptr, .{
.cancel_requested = false,
.awaiter_delayed = false,
.fibers = .null,
}, .release);
return null;
}
fn await(group: Group, ev: *Evented, awaiter: *Fiber) bool {
group.lock(ev);
defer group.unlock(ev);
if (@atomicLoad(List, group.listPtr(), .monotonic).fibers.unpack()) |_| {
if (group.registerAwaiter(awaiter) and awaiter.cancel_protection.check() == .unblocked) {
// 等待方在尝试等待组之前,已经存在未确认的取消请求,
// 因此将取消传播到该组。
assert(!group.cancelLocked(ev, null));
}
return false;
}
return true;
}
fn cancel(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool {
group.lock(ev);
defer group.unlock(ev);
return group.cancelLocked(ev, maybe_awaiter);
}
/// 假定互斥锁已被持有。
fn cancelLocked(group: Group, ev: *Evented, maybe_awaiter: ?*Fiber) bool {
const list_ptr = group.listPtr();
const list = @atomicRmw(
List,
list_ptr,
.Add,
.{ .cancel_requested = true, .awaiter_delayed = false, .fibers = .null },
.monotonic,
);
assert(!list.cancel_requested);
if (list.fibers.unpack()) |head| {
var maybe_fiber: ?*Fiber = head;
while (maybe_fiber) |fiber| {
fiber.requestCancel(ev);
maybe_fiber = fiber.link.group.next;
}
if (maybe_awaiter) |awaiter| _ = group.registerAwaiter(awaiter);
return false;
}
@atomicStore(
List,
list_ptr,
.{ .cancel_requested = false, .awaiter_delayed = false, .fibers = .null },
.release,
);
return if (maybe_awaiter) |_| true else list.awaiter_delayed;
}
/// 假定互斥锁已被持有。
fn registerAwaiter(group: Group, awaiter: *Fiber) bool {
assert(awaiter.status.queue_next == null);
awaiter.status = .{ .awaiting_group = group };
assert(@atomicRmw(
Awaiter,
group.awaiterPtr(),
.Add,
.{ .locked = false, .contended = false, .awaiter = .pack(awaiter) },
.monotonic,
).awaiter == .null);
return awaiter.cancel_status.changeAwaiting(.nothing, .group);
}
const AsyncClosure = struct {
evented: *Evented,
group: Group,
fiber: *Fiber,
start: *const fn (context: *const anyopaque) void,
fn fromFiber(fiber: *Fiber) *Group.AsyncClosure {
return @ptrFromInt(Fiber.max_context_align.max(.of(Group.AsyncClosure)).backward(
@intFromPtr(fiber.allocatedEnd()) - Fiber.max_context_size,
) - @sizeOf(Group.AsyncClosure));
}
fn contextPointer(
closure: *Group.AsyncClosure,
) [*]align(Fiber.max_context_align.toByteUnits()) u8 {
return @alignCast(@as([*]u8, @ptrCast(closure)) + @sizeOf(Group.AsyncClosure));
}
fn entry() callconv(.naked) void {
switch (builtin.cpu.arch) {
.aarch64 => asm volatile (
\\ mov x0, sp
\\ b %[call]
:
: [call] "X" (&call),
),
.riscv64 => asm volatile (
\\ mv a0, sp
\\ tail %[call]@plt
:
: [call] "X" (&call),
),
.x86_64 => asm volatile (
\\ leaq 8(%%rsp), %%rdi
\\ jmp %[call:P]
:
: [call] "X" (&call),
),
else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
}
}
fn call(
closure: *Group.AsyncClosure,
contexts: *const Io.fiber.Switch,
) callconv(.withStackAlign(.c, @alignOf(Group.AsyncClosure))) noreturn {
const message: *const SwitchMessage = @fieldParentPtr("contexts", contexts);
const ev = closure.evented;
const fiber = closure.fiber;
message.handle(ev);
assert(fiber.status.queue_next == null);
closure.start(closure.contextPointer());
ev.yield(closure.group.removeFiber(ev, fiber), .destroy);
unreachable; // 切换至已终止的纤程
}
};
};
fn groupAsync(
userdata: ?*anyopaque,
type_erased: *Io.Group,
context: []const u8,
context_alignment: Alignment,
start: *const fn (context: *const anyopaque) void,
) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
return groupConcurrent(ev, type_erased, context, context_alignment, start) catch {
start(context.ptr);
};
}
fn groupConcurrent(
userdata: ?*anyopaque,
type_erased: *Io.Group,
context: []const u8,
context_alignment: Alignment,
start: *const fn (context: *const anyopaque) void,
) Io.ConcurrentError!void {
assert(context_alignment.compare(.lte, Fiber.max_context_align)); // TODO
assert(context.len <= Fiber.max_context_size); // TODO
const ev: *Evented = @ptrCast(@alignCast(userdata));
const group: Group = .{ .ptr = type_erased };
const fiber = Fiber.create(ev) catch |err| switch (err) {
error.OutOfMemory => return error.ConcurrencyUnavailable,
};
const closure: *Group.AsyncClosure = .fromFiber(fiber);
fiber.* = .{
.required_align = {},
.context = switch (builtin.cpu.arch) {
.aarch64 => .{
.sp = @intFromPtr(closure),
.fp = 0,
.pc = @intFromPtr(&Group.AsyncClosure.entry),
},
.riscv64 => .{
.sp = @intFromPtr(closure),
.fp = 0,
.pc = @intFromPtr(&Group.AsyncClosure.entry),
},
.x86_64 => .{
.rsp = @intFromPtr(closure) - 8,
.rbp = 0,
.rip = @intFromPtr(&Group.AsyncClosure.entry),
},
else => |arch| @compileError("unimplemented architecture: " ++ @tagName(arch)),
},
.link = .{ .group = .{ .prev = null, .next = null } },
.status = .{ .queue_next = null },
.cancel_status = .unrequested,
.cancel_protection = .unblocked,
.name = if (tracy.enable) name: {
const thread: *Thread = .current();
var name_arena = thread.name_arena.promote(std.heap.page_allocator);
defer thread.name_arena = name_arena.state;
break :name std.fmt.allocPrintSentinel(
name_arena.allocator(),
"group task {d}",
.{@atomicRmw(u64, &Fiber.next_name, .Add, 1, .monotonic)},
0,
) catch return error.ConcurrencyUnavailable;
},
};
closure.* = .{
.evented = ev,
.group = group,
.fiber = fiber,
.start = start,
};
@memcpy(closure.contextPointer(), context);
group.addFiber(ev, fiber);
const thread: *Thread = .current();
if (ev.schedule(thread, .{ .head = fiber, .tail = fiber })) thread.submit();
}
fn groupAwait(
userdata: ?*anyopaque,
type_erased: *Io.Group,
initial_token: *anyopaque,
) Io.Cancelable!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = initial_token;
ev.yield(null, .{ .group_await = .{ .ptr = type_erased } });
}
fn groupCancel(userdata: ?*anyopaque, type_erased: *Io.Group, initial_token: *anyopaque) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = initial_token;
ev.yield(null, .{ .group_cancel = .{ .ptr = type_erased } });
}
fn recancel(userdata: ?*anyopaque) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
Thread.current().currentFiber().cancel_protection.recancel();
}
fn swapCancelProtection(userdata: ?*anyopaque, new: Io.CancelProtection) Io.CancelProtection {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
const cancel_protection = &Thread.current().currentFiber().cancel_protection;
defer cancel_protection.user = new;
return cancel_protection.user;
}
fn checkCancel(userdata: ?*anyopaque) Io.Cancelable!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
const fiber = Thread.current().currentFiber();
switch (fiber.cancel_protection.check()) {
.unblocked => {
const cancel_status = @atomicLoad(Fiber.CancelStatus, &fiber.cancel_status, .monotonic);
assert(cancel_status.awaiting == .nothing);
if (cancel_status.requested) {
@branchHint(.unlikely);
fiber.cancel_protection.acknowledge();
return error.Canceled;
}
},
.blocked => {},
}
}
fn futexWait(
userdata: ?*anyopaque,
ptr: *const u32,
expected: u32,
timeout: Io.Timeout,
) Io.Cancelable!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const timespec: ?linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = timespec: switch (timeout) {
.none => .{
null,
.awake,
linux.IORING_TIMEOUT_ABS,
},
.duration => |duration| {
const ns = duration.raw.toNanoseconds();
break :timespec .{
.{
.sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
.nsec = @intCast(@mod(ns, std.time.ns_per_s)),
},
duration.clock,
0,
};
},
.deadline => |deadline| {
const ns = deadline.raw.toNanoseconds();
break :timespec .{
.{
.sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
.nsec = @intCast(@mod(ns, std.time.ns_per_s)),
},
deadline.clock,
linux.IORING_TIMEOUT_ABS,
};
},
};
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .FUTEX_WAIT,
.flags = if (timespec) |_| linux.IOSQE_IO_LINK else 0,
.ioprio = 0,
.fd = @bitCast(linux.FUTEX2_FLAGS{ .size = .U32, .private = true }),
.off = expected,
.addr = @intFromPtr(ptr),
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = std.math.maxInt(u32),
.resv = 0,
};
if (timespec) |*timespec_ptr| thread.enqueue().* = .{
.opcode = .LINK_TIMEOUT,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = @intFromPtr(timespec_ptr),
.len = 1,
.rw_flags = timeout_flags | @as(u32, switch (clock) {
.real => linux.IORING_TIMEOUT_REALTIME,
else => 0,
.boot => linux.IORING_TIMEOUT_BOOTTIME,
}),
.user_data = @backingInt(Completion.Userdata.wakeup),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => {}, // 由 `wake()` 通知
.INTR, .CANCELED => {}, // 调用者负责重试
.AGAIN => {}, // ptr.* != expect
.INVAL => {}, // 可能发生超时溢出
.TIMEDOUT => unreachable,
.FAULT => recoverableOsBugDetected(), // ptr 无效
else => recoverableOsBugDetected(),
}
}
fn futexWaitUncancelable(userdata: ?*anyopaque, ptr: *const u32, expected: u32) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .initBlocked();
defer cancel_region.deinit();
const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
};
thread.enqueue().* = .{
.opcode = .FUTEX_WAIT,
.flags = 0,
.ioprio = 0,
.fd = @bitCast(linux.FUTEX2_FLAGS{ .size = .U32, .private = true }),
.off = expected,
.addr = @intFromPtr(ptr),
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = std.math.maxInt(u32),
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => {}, // 由 `wake()` 通知
.INTR, .CANCELED => {}, // 调用者负责重试
.AGAIN => {}, // ptr.* != expect
.INVAL => {}, // 可能发生超时溢出
.FAULT => recoverableOsBugDetected(), // ptr 无效
else => recoverableOsBugDetected(),
}
}
fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
const thread: *Thread = .current();
thread.enqueue().* = .{
.opcode = .FUTEX_WAKE,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = @bitCast(linux.FUTEX2_FLAGS{ .size = .U32, .private = true }),
.off = max_waiters,
.addr = @intFromPtr(ptr),
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.futex_wake),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = std.math.maxInt(u32),
.resv = 0,
};
thread.submit();
}
fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Operation.Result {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
return switch (operation) {
.file_read_streaming => |o| .{
.file_read_streaming = ev.fileReadStreaming(
&maybe_sync.cancel_region,
o.file,
o.data,
) catch |err| switch (err) {
error.Canceled => |e| return e,
else => |e| e,
},
},
.file_write_streaming => |o| .{
.file_write_streaming = ev.fileWriteStreaming(
&maybe_sync.cancel_region,
o.file,
o.header,
o.data,
o.splat,
) catch |err| switch (err) {
error.Canceled => |e| return e,
else => |e| e,
},
},
.device_io_control => |o| .{
.device_io_control = try ev.deviceIoControl(try maybe_sync.enterSync(ev), o),
},
.net_receive => |o| .{
.net_receive = r: {
const opt_err, const n = ev.netReceive(&maybe_sync.cancel_region, o.socket_handle, o.message_buffer, o.data_buffer, o.flags);
break :r .{
if (opt_err) |err| switch (err) {
error.Canceled => |e| return e,
else => |e| e,
} else null,
n,
};
},
},
.net_send => |o| .{
.net_send = r: {
_ = o;
break :r .{ error.NetworkDown, 0 }; // TODO
},
},
.net_read => |o| .{
.net_read = r: {
_ = o;
break :r error.NetworkDown; // TODO
},
},
.net_write => @panic("TODO implement net_write operation"),
};
}
fn fileReadStreaming(
ev: *Evented,
cancel_region: *CancelRegion,
file: File,
data: []const []u8,
) File.ReadStreamingError!usize {
var iovecs_buffer: [max_iovecs_len]iovec = undefined;
var i: usize = 0;
for (data) |buf| {
if (iovecs_buffer.len - i == 0) break;
if (buf.len > 0) {
iovecs_buffer[i] = .{ .base = buf.ptr, .len = buf.len };
i += 1;
}
}
const dest = iovecs_buffer[0..i];
assert(dest[0].len > 0);
const n = try ev.preadv(cancel_region, file.handle, dest, null);
return if (n == 0) error.EndOfStream else n;
}
fn fileWriteStreaming(
ev: *Evented,
cancel_region: *CancelRegion,
file: File,
header: []const u8,
data: []const []const u8,
splat: usize,
) File.Writer.Error!usize {
var iovecs: [max_iovecs_len]iovec_const = undefined;
var iovlen: iovlen_t = 0;
addBuf(&iovecs, &iovlen, header);
for (data[0 .. data.len - 1]) |bytes| addBuf(&iovecs, &iovlen, bytes);
const pattern = data[data.len - 1];
var backup_buffer: [splat_buffer_size]u8 = undefined;
if (iovecs.len - iovlen != 0) switch (splat) {
0 => {},
1 => addBuf(&iovecs, &iovlen, pattern),
else => switch (pattern.len) {
0 => {},
1 => {
const splat_buffer = &backup_buffer;
const memset_len = @min(splat_buffer.len, splat);
const buf = splat_buffer[0..memset_len];
@memset(buf, pattern[0]);
addBuf(&iovecs, &iovlen, buf);
var remaining_splat = splat - buf.len;
while (remaining_splat > splat_buffer.len and iovecs.len - iovlen != 0) {
assert(buf.len == splat_buffer.len);
addBuf(&iovecs, &iovlen, splat_buffer);
remaining_splat -= splat_buffer.len;
}
addBuf(&iovecs, &iovlen, splat_buffer[0..@min(remaining_splat, splat_buffer.len)]);
},
else => for (0..@min(splat, iovecs.len - iovlen)) |_| {
addBuf(&iovecs, &iovlen, pattern);
},
},
};
return ev.pwritev(cancel_region, file.handle, iovecs[0..iovlen], null);
}
fn deviceIoControl(
ev: *Evented,
sync: *CancelRegion.Sync,
o: Io.Operation.DeviceIoControl,
) Io.Cancelable!i32 {
_ = ev;
while (true) {
try sync.cancel_region.await(.nothing);
const rc = linux.ioctl(o.file.handle, @bitCast(o.code), @intFromPtr(o.arg));
switch (linux.errno(rc)) {
.SUCCESS => return @bitCast(@as(u32, @truncate(rc))),
.INTR => {},
else => |err| return -@as(i32, @backingInt(err)),
}
}
}
fn batchAwaitAsync(userdata: ?*anyopaque, batch: *Io.Batch) Io.Cancelable!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
ev.batchDrainSubmitted(&maybe_sync, batch, false) catch |err| switch (err) {
error.ConcurrencyUnavailable => unreachable, // 传入 concurrency=false
error.Canceled => |e| return e,
};
maybe_sync.leaveSync(ev);
while (true) {
batchDrainReady(batch) catch |err| switch (err) {
error.Timeout => unreachable, // 无超时
};
if (batch.completed.head != .none or batch.pending.head == .none) return;
ev.yield(null, .{ .batch_await = batch });
}
}
fn batchAwaitConcurrent(
userdata: ?*anyopaque,
batch: *Io.Batch,
timeout: Io.Timeout,
) Io.Batch.AwaitConcurrentError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
try ev.batchDrainSubmitted(&maybe_sync, batch, true);
maybe_sync.leaveSync(ev);
const timespec: linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = while (true) {
batchDrainReady(batch) catch |err| switch (err) {
error.Timeout => unreachable, // 无超时
};
if (batch.completed.head != .none or batch.pending.head == .none) return;
switch (timeout) {
.none => ev.yield(null, .{ .batch_await = batch }),
.duration => |duration| {
const ns = duration.raw.toNanoseconds();
break .{
.{
.sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
.nsec = @intCast(@mod(ns, std.time.ns_per_s)),
},
duration.clock,
0,
};
},
.deadline => |deadline| {
const ns = deadline.raw.toNanoseconds();
break .{
.{
.sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
.nsec = @intCast(@mod(ns, std.time.ns_per_s)),
},
deadline.clock,
linux.IORING_TIMEOUT_ABS,
};
},
}
};
{
const thread = try maybe_sync.cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .TIMEOUT,
.flags = 0,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = @intFromPtr(×pec),
.len = 1,
.rw_flags = timeout_flags | @as(u32, switch (clock) {
.real => linux.IORING_TIMEOUT_REALTIME,
else => 0,
.boot => linux.IORING_TIMEOUT_BOOTTIME,
}),
.user_data = @intFromPtr(&batch.userdata) | 0b11,
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
}
while (batch.completed.head == .none and batch.pending.head != .none) {
ev.yield(null, .{ .batch_await = batch });
batchDrainReady(batch) catch |err| switch (err) {
error.Timeout => |e| return if (batch.completed.head == .none and
batch.pending.head != .none) e,
};
}
const thread = try maybe_sync.cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .TIMEOUT_REMOVE,
.flags = 0,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = @intFromPtr(&batch.userdata) | 0b11,
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(maybe_sync.cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (maybe_sync.cancel_region.errno()) {
.SUCCESS => return,
.BUSY, .NOENT => {},
else => |err| unexpectedErrno(err) catch {},
}
while (true) {
batchDrainReady(batch) catch |err| switch (err) {
error.Timeout => return,
};
ev.yield(null, .{ .batch_await = batch });
}
}
/// 若 `concurrency` 为 false,则 `error.ConcurrencyUnavailable` 不可达。
fn batchDrainSubmitted(
ev: *Evented,
maybe_sync: *CancelRegion.Sync.Maybe,
batch: *Io.Batch,
concurrency: bool,
) (Io.ConcurrentError || Io.Cancelable)!void {
var index = batch.submitted.head;
if (index == .none) return;
const thread = try maybe_sync.cancelRegion().awaitIoUring();
errdefer batch.submitted.head = index;
while (index != .none) {
const storage = &batch.storage[index.toIndex()];
const next_index = storage.submission.node.next;
if (@as(?Io.Operation.Result, result: switch (storage.submission.operation) {
.file_read_streaming => |o| {
const buffer = for (o.data) |buffer| {
if (buffer.len > 0) break buffer;
} else break :result .{ .file_read_streaming = 0 };
const fd = o.file.handle;
storage.* = .{ .pending = .{
.node = .{ .prev = batch.pending.tail, .next = .none },
.tag = .file_read_streaming,
.userdata = undefined,
} };
thread.enqueue().* = .{
.opcode = .READ,
.flags = 0,
.ioprio = 0,
.fd = fd,
.off = std.math.maxInt(u64),
.addr = @intFromPtr(buffer.ptr),
.len = @min(buffer.len, 0xfffff000),
.rw_flags = 0,
.user_data = @intFromPtr(&storage.pending.userdata) | 0b10,
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
break :result null;
},
.file_write_streaming => |o| {
const buffer = buffer: {
if (o.header.len != 0) break :buffer o.header;
for (o.data[0 .. o.data.len - 1]) |buffer| {
if (buffer.len > 0) break :buffer buffer;
}
if (o.splat > 0) break :buffer o.data[o.data.len - 1];
break :result .{ .file_write_streaming = 0 };
};
const fd = o.file.handle;
storage.* = .{ .pending = .{
.node = .{ .prev = batch.pending.tail, .next = .none },
.tag = .file_write_streaming,
.userdata = undefined,
} };
thread.enqueue().* = .{
.opcode = .WRITE,
.flags = 0,
.ioprio = 0,
.fd = fd,
.off = std.math.maxInt(u64),
.addr = @intFromPtr(buffer.ptr),
.len = @min(buffer.len, 0xfffff000),
.rw_flags = 0,
.user_data = @intFromPtr(&storage.pending.userdata) | 0b10,
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
break :result null;
},
.device_io_control => |o| if (concurrency)
return error.ConcurrencyUnavailable
else
.{ .device_io_control = try ev.deviceIoControl(try maybe_sync.enterSync(ev), o) },
.net_accept => |o| {
_ = o;
@panic("TODO implement batchDrainSubmitted for net_receive");
},
.net_receive => |o| {
_ = o;
@panic("TODO implement batchDrainSubmitted for net_receive");
},
.net_send => |o| {
_ = o;
@panic("TODO implement batchDrainSubmitted for net_send");
},
.net_read => |o| {
_ = o;
@panic("TODO implement batchDrainSubmitted for net_read");
},
.net_write => |o| {
_ = o;
@panic("TODO implement batchDrainSubmitted for net_write");
},
})) |result| {
switch (batch.completed.tail) {
.none => batch.completed.head = index,
else => |tail_index| batch.storage[tail_index.toIndex()].completion.node.next = index,
}
batch.completed.tail = index;
storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
} else {
switch (batch.pending.tail) {
.none => batch.pending.head = index,
else => |tail_index| batch.storage[tail_index.toIndex()].pending.node.next = index,
}
batch.pending.tail = index;
storage.pending.userdata[0] = @intFromPtr(batch);
}
index = next_index;
}
batch.submitted = .{ .head = .none, .tail = .none };
}
fn batchDrainReady(batch: *Io.Batch) Io.Timeout.Error!void {
while (@atomicRmw(?*anyopaque, &batch.userdata, .Xchg, null, .acquire)) |head| {
var next: usize = @intFromPtr(head);
var timeout = false;
while (cond: switch (@as(u2, @truncate(next))) {
0b00 => if (timeout) return error.Timeout else false,
0b01 => {
assert(!timeout);
return error.Timeout;
},
0b10 => true,
0b11 => {
assert(!timeout);
timeout = true;
break :cond true;
},
}) {
const operation_userdata: *Io.Operation.Storage.Pending.Userdata =
@ptrFromInt(next & ~@as(usize, 0b11));
next = operation_userdata[0];
const completion: Completion = .{
.result = @bitCast(@as(u32, @intCast(operation_userdata[1]))),
.flags = @intCast(operation_userdata[2]),
};
const pending: *Io.Operation.Storage.Pending =
@fieldParentPtr("userdata", operation_userdata);
const storage: *Io.Operation.Storage = @fieldParentPtr("pending", pending);
const index: Io.Operation.OptionalIndex = .fromIndex(storage - batch.storage.ptr);
assert(completion.flags & linux.IORING_CQE_F_SKIP == 0);
switch (pending.node.prev) {
.none => batch.pending.head = pending.node.next,
else => |prev_index| batch.storage[prev_index.toIndex()].pending.node.next =
pending.node.next,
}
switch (pending.node.next) {
.none => batch.pending.tail = pending.node.prev,
else => |prev_index| batch.storage[prev_index.toIndex()].pending.node.prev =
pending.node.prev,
}
if (@as(?Io.Operation.Result, result: switch (pending.tag) {
.file_read_streaming => .{
.file_read_streaming = switch (completion.errno()) {
.SUCCESS => if (completion.result == 0)
error.EndOfStream
else
@as(u32, @bitCast(completion.result)),
.INTR => 0,
.CANCELED => break :result null,
.INVAL => |err| errnoBug(err),
.FAULT => |err| errnoBug(err),
.AGAIN => error.WouldBlock,
.BADF => |err| errnoBug(err), // 关闭后仍使用文件描述符
.IO => error.InputOutput,
.ISDIR => error.IsDir,
.NOBUFS => error.SystemResources,
.NOMEM => error.SystemResources,
.NOTCONN => error.SocketUnconnected,
.CONNRESET => error.ConnectionResetByPeer,
else => |err| unexpectedErrno(err),
},
},
.file_write_streaming => .{
.file_write_streaming = switch (completion.errno()) {
.SUCCESS => @as(u32, @bitCast(completion.result)),
.INTR => 0,
.CANCELED => break :result null,
.INVAL => |err| errnoBug(err),
.FAULT => |err| errnoBug(err),
.AGAIN => error.WouldBlock,
.BADF => error.NotOpenForWriting, // 可能存在竞态条件。
.DESTADDRREQ => |err| errnoBug(err), // 从未调用 `connect`。
.DQUOT => error.DiskQuota,
.FBIG => error.FileTooBig,
.IO => error.InputOutput,
.NOSPC => error.NoSpaceLeft,
.PERM => error.PermissionDenied,
.PIPE => error.BrokenPipe,
.CONNRESET => |err| errnoBug(err), // 不是套接字句柄。
.BUSY => error.DeviceBusy,
else => |err| unexpectedErrno(err),
},
},
.device_io_control => unreachable,
.net_accept => @panic("TODO"),
.net_receive => @panic("TODO"),
.net_send => @panic("TODO"),
.net_read => @panic("TODO"),
.net_write => @panic("TODO"),
})) |result| {
switch (batch.completed.tail) {
.none => batch.completed.head = index,
else => |tail_index| batch.storage[tail_index.toIndex()].completion.node.next =
index,
}
storage.* = .{ .completion = .{ .node = .{ .next = .none }, .result = result } };
batch.completed.tail = index;
} else {
switch (batch.unused.tail) {
.none => batch.unused.head = index,
else => |tail_index| batch.storage[tail_index.toIndex()].unused.next = index,
}
storage.* = .{ .unused = .{ .prev = batch.unused.tail, .next = .none } };
batch.unused.tail = index;
}
}
}
}
fn batchCancel(userdata: ?*anyopaque, batch: *Io.Batch) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
batchDrainReady(batch) catch |err| switch (err) {
error.Timeout => unreachable, // 无超时
};
var index = batch.pending.head;
if (index == .none) return;
var cancel_region: CancelRegion = .initBlocked();
defer cancel_region.deinit();
const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
};
while (index != .none) {
const pending = &batch.storage[index.toIndex()].pending;
thread.enqueue().* = .{
.opcode = .ASYNC_CANCEL,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = @intFromPtr(&pending.userdata) | 0b10,
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.wakeup),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
index = pending.node.next;
}
while (batch.pending.head != .none) batchDrainReady(batch) catch |err| switch (err) {
error.Timeout => unreachable, // 无超时
};
}
fn dirCreateDir(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
permissions: Dir.Permissions,
) Dir.CreateDirError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .MKDIRAT,
.flags = 0,
.ioprio = 0,
.fd = dir.handle,
.off = 0,
.addr = @intFromPtr(sub_path_posix.ptr),
.len = permissions.toMode(),
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.ACCES => return error.AccessDenied,
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.PERM => return error.PermissionDenied,
.DQUOT => return error.DiskQuota,
.EXIST => return error.PathAlreadyExists,
.FAULT => |err| return errnoBug(err),
.LOOP => return error.SymLinkLoop,
.MLINK => return error.LinkQuotaExceeded,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOMEM => return error.SystemResources,
.NOSPC => return error.NoSpaceLeft,
.NOTDIR => return error.NotDir,
.ROFS => return error.ReadOnlyFileSystem,
.ILSEQ => return error.BadPathName,
else => |err| return unexpectedErrno(err),
}
}
}
fn dirCreateDirPath(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
permissions: Dir.Permissions,
) Dir.CreateDirPathError!Dir.CreatePathStatus {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var it = Dir.path.componentIterator(sub_path);
var status: Dir.CreatePathStatus = .existed;
var component = it.last() orelse return error.BadPathName;
while (true) {
if (dirCreateDir(ev, dir, component.path, permissions)) |_| {
status = .created;
} else |err| switch (err) {
error.PathAlreadyExists => {
// 获取文件状态,若不是目录则返回错误
// 此检查很重要,否则悬空符号链接
// 可能导致无限循环
const kind = try ev.filePathKind(dir, component.path);
if (kind != .directory) return error.NotDir;
},
error.FileNotFound => |e| {
component = it.previous() orelse return e;
continue;
},
else => |e| return e,
}
component = it.next() orelse return status;
}
}
fn filePathKind(ev: *Evented, dir: Dir, sub_path: []const u8) !File.Kind {
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
var statx_buf = std.mem.zeroes(linux.Statx);
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .STATX,
.flags = 0,
.ioprio = 0,
.fd = dir.handle,
.off = @intFromPtr(&statx_buf),
.addr = @intFromPtr(sub_path_posix.ptr),
.len = @bitCast(linux.STATX{ .TYPE = true }),
.rw_flags = linux.AT.NO_AUTOMOUNT | linux.AT.SYMLINK_NOFOLLOW,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => {
if (!statx_buf.mask.TYPE) return error.Unexpected;
return statxKind(statx_buf.mode);
},
.INTR, .CANCELED => {},
.ACCES => |err| return errnoBug(err),
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.LOOP => |err| return errnoBug(err),
.NAMETOOLONG => |err| return errnoBug(err),
.NOENT => |err| return errnoBug(err),
.NOMEM => return error.SystemResources,
.NOTDIR => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn dirCreateDirPathOpen(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
permissions: Dir.Permissions,
options: Dir.OpenOptions,
) Dir.CreateDirPathOpenError!Dir {
const ev: *Evented = @ptrCast(@alignCast(userdata));
return dirOpenDir(ev, dir, sub_path, options) catch |err| switch (err) {
error.FileNotFound => {
_ = try dirCreateDirPath(ev, dir, sub_path, permissions);
return dirOpenDir(ev, dir, sub_path, options);
},
else => |e| return e,
};
}
fn dirOpenDir(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
options: Dir.OpenOptions,
) Dir.OpenError!Dir {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return .{
.handle = ev.openat(&cancel_region, dir.handle, sub_path_posix, .{
.ACCMODE = .RDONLY,
.DIRECTORY = true,
.NOFOLLOW = !options.follow_symlinks,
.CLOEXEC = true,
.PATH = !options.iterate,
}, 0) catch |err| switch (err) {
error.IsDir => return errnoBug(.ISDIR),
error.WouldBlock => return errnoBug(.AGAIN),
error.FileTooBig => return errnoBug(.FBIG),
error.NoSpaceLeft => return errnoBug(.NOSPC),
error.DeviceBusy => return errnoBug(.BUSY), // EXCL 未设置。
error.FileBusy => return errnoBug(.TXTBSY),
error.PathAlreadyExists => return errnoBug(.EXIST), // 不创建。
error.OperationUnsupported => return errnoBug(.OPNOTSUPP), // 无 TMPFILE,无锁。
error.ReadOnlyFileSystem => return errnoBug(.ROFS), // 不创建。
else => |e| return e,
},
};
}
fn dirStat(userdata: ?*anyopaque, dir: Dir) Dir.StatError!Dir.Stat {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.stat(&cancel_region, dir.handle);
}
fn dirStatFile(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
options: Dir.StatFileOptions,
) Dir.StatFileError!File.Stat {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.statx(&cancel_region, dir.handle, sub_path_posix, linux.AT.NO_AUTOMOUNT |
@as(u32, if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW));
}
fn dirAccess(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
options: Dir.AccessOptions,
) Dir.AccessError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
const mode: u32 =
@as(u32, if (options.read) linux.R_OK else 0) |
@as(u32, if (options.write) linux.W_OK else 0) |
@as(u32, if (options.execute) linux.X_OK else 0);
const flags: u32 = if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW;
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.faccessat(dir.handle, sub_path_posix, mode, flags))) {
.SUCCESS => return,
.INTR => {},
.ACCES => return error.AccessDenied,
.PERM => return error.PermissionDenied,
.ROFS => return error.ReadOnlyFileSystem,
.LOOP => return error.SymLinkLoop,
.TXTBSY => return error.FileBusy,
.NOTDIR => return error.FileNotFound,
.NOENT => return error.FileNotFound,
.NAMETOOLONG => return error.NameTooLong,
.INVAL => |err| return errnoBug(err),
.FAULT => |err| return errnoBug(err),
.IO => return error.InputOutput,
.NOMEM => return error.SystemResources,
.ILSEQ => return error.BadPathName,
else => |err| return unexpectedErrno(err),
}
}
}
fn dirCreateFile(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
flags: Dir.CreateFileOptions,
) File.OpenError!File {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
const fd = ev.openat(&maybe_sync.cancel_region, dir.handle, sub_path_posix, .{
.ACCMODE = if (flags.read) .RDWR else .WRONLY,
.CREAT = true,
.TRUNC = flags.truncate,
.EXCL = flags.exclusive,
.CLOEXEC = true,
}, flags.permissions.toMode()) catch |err| switch (err) {
error.OperationUnsupported => return error.Unexpected, // 未设置 TMPFILE。
else => |e| return e,
};
errdefer ev.closeAsync(fd);
switch (flags.lock) {
.none => {},
.shared, .exclusive => try ev.flock(
try maybe_sync.enterSync(ev),
fd,
flags.lock,
if (flags.lock_nonblocking) .nonblocking else .blocking,
),
}
return .{ .handle = fd, .flags = .{ .nonblocking = false } };
}
fn dirCreateFileAtomic(
userdata: ?*anyopaque,
dir: Dir,
dest_path: []const u8,
options: Dir.CreateFileAtomicOptions,
) Dir.CreateFileAtomicError!File.Atomic {
const ev: *Evented = @ptrCast(@alignCast(userdata));
// Linux 有 O_TMPFILE,但 linkat() 不支持 AT_REPLACE,因此
// 既然最终仍须构造一个临时路径名执行 rename(),
// 它便没有用处。
if (!options.replace) tmpfile: {
const flags: linux.O = if (@hasField(linux.O, "TMPFILE")) .{
.ACCMODE = .RDWR,
.TMPFILE = true,
.DIRECTORY = true,
.CLOEXEC = true,
} else if (@hasField(linux.O, "TMPFILE0") and !@hasField(linux.O, "TMPFILE2")) .{
.ACCMODE = .RDWR,
.TMPFILE0 = true,
.TMPFILE1 = true,
.DIRECTORY = true,
.CLOEXEC = true,
} else break :tmpfile;
const dest_dirname = Dir.path.dirname(dest_path);
if (dest_dirname) |dirname| {
// 这样还有一个有益的副作用:预先触发 EISDIR 或
// ENOENT,避免下方的歧义。
_ = dirCreateDirPath(ev, dir, dirname, .default_dir) catch |err| switch (err) {
// 这些值在此上下文中均无意义。
error.IsDir,
error.Streaming,
error.DiskQuota,
error.PathAlreadyExists,
error.LinkQuotaExceeded,
error.PipeBusy,
error.FileTooBig,
error.DeviceBusy,
error.FileLocksUnsupported,
error.FileBusy,
=> return error.Unexpected,
else => |e| return e,
};
}
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(dest_dirname orelse ".", &path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return .{
.file = .{
.handle = ev.openat(
&cancel_region,
dir.handle,
sub_path_posix,
flags,
options.permissions.toMode(),
) catch |err| switch (err) {
error.IsDir, error.FileNotFound, error.OperationUnsupported => {
// 含义不明确的错误码。它可能表示文件系统不支持 O_TMPFILE,因此必须回退到不使用 O_TMPFILE。
//
//
break :tmpfile;
},
error.FileTooBig => return errnoBug(.FBIG),
error.DeviceBusy => return errnoBug(.BUSY), // 未传入 O_EXCL
error.PathAlreadyExists => return errnoBug(.EXIST), // 不创建。
else => |e| return e,
},
.flags = .{ .nonblocking = false },
},
.file_basename_hex = 0,
.dest_sub_path = dest_path,
.file_open = true,
.file_exists = false,
.close_dir_on_deinit = false,
.dir = dir,
};
}
if (Dir.path.dirname(dest_path)) |dirname| {
const new_dir = if (options.make_path)
dirCreateDirPathOpen(ev, dir, dirname, .default_dir, .{}) catch |err| switch (err) {
// 这些值在此上下文中均无意义。
error.IsDir,
error.Streaming,
error.DiskQuota,
error.PathAlreadyExists,
error.LinkQuotaExceeded,
error.PipeBusy,
error.FileTooBig,
error.FileLocksUnsupported,
error.DeviceBusy,
=> return error.Unexpected,
else => |e| return e,
}
else
try dirOpenDir(ev, dir, dirname, .{});
return ev.atomicFileInit(Dir.path.basename(dest_path), options.permissions, new_dir, true);
}
return ev.atomicFileInit(dest_path, options.permissions, dir, false);
}
fn atomicFileInit(
ev: *Evented,
dest_basename: []const u8,
permissions: File.Permissions,
dir: Dir,
close_dir_on_deinit: bool,
) Dir.CreateFileAtomicError!File.Atomic {
while (true) {
var random_integer: u64 = undefined;
random(ev, @ptrCast(&random_integer));
const tmp_sub_path = std.fmt.hex(random_integer);
const file = dirCreateFile(ev, dir, &tmp_sub_path, .{
.permissions = permissions,
.exclusive = true,
}) catch |err| switch (err) {
error.PathAlreadyExists => continue,
error.DeviceBusy => continue,
error.FileBusy => continue,
error.IsDir => return error.Unexpected, // 没有路径分量。
error.FileTooBig => return error.Unexpected, // 执行创建而非打开。
error.FileLocksUnsupported => return error.Unexpected, // 不请求锁。
error.PipeBusy => return error.Unexpected, // 未在打开管道。
else => |e| return e,
};
return .{
.file = file,
.file_basename_hex = random_integer,
.dest_sub_path = dest_basename,
.file_open = true,
.file_exists = true,
.close_dir_on_deinit = close_dir_on_deinit,
.dir = dir,
};
}
}
fn dirOpenFile(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
flags: Dir.OpenFileOptions,
) File.OpenError!File {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
const fd = ev.openat(&maybe_sync.cancel_region, dir.handle, sub_path_posix, .{
.ACCMODE = switch (flags.mode) {
.read_only => .RDONLY,
.write_only => .WRONLY,
.read_write => .RDWR,
},
.NOCTTY = !flags.allow_ctty,
.NOFOLLOW = !flags.follow_symlinks,
.CLOEXEC = true,
.PATH = flags.path_only,
}, 0) catch |err| switch (err) {
error.OperationUnsupported => return error.Unexpected, // 未设置 TMPFILE。
else => |e| return e,
};
errdefer ev.closeAsync(fd);
if (!flags.allow_directory) {
const is_dir = is_dir: {
const s = ev.stat(&maybe_sync.cancel_region, fd) catch |err| switch (err) {
// 是否为目录未知,或无法确定。
error.Streaming => break :is_dir false,
else => |e| return e,
};
break :is_dir s.kind == .directory;
};
if (is_dir) return error.IsDir;
}
switch (flags.lock) {
.none => {},
.shared, .exclusive => try ev.flock(
try maybe_sync.enterSync(ev),
fd,
flags.lock,
if (flags.lock_nonblocking) .nonblocking else .blocking,
),
}
return .{ .handle = fd, .flags = .{ .nonblocking = false } };
}
fn dirClose(userdata: ?*anyopaque, dirs: []const Dir) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
for (dirs) |dir| ev.close(dir.handle);
}
fn dirRead(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir.Reader.Error!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var buffer_index: usize = 0;
while (buffer.len - buffer_index != 0) {
if (dr.end - dr.index == 0) {
// 重新填充缓冲区,
// 除非已创建对缓冲数据的引用。
if (buffer_index != 0) break;
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
if (dr.state == .reset) {
ev.lseek(&sync, dr.dir.handle, 0, linux.SEEK.SET) catch |err| switch (err) {
error.Unseekable => return error.Unexpected,
else => |e| return e,
};
dr.state = .reading;
}
const n = while (true) {
try sync.cancel_region.await(.nothing);
const rc = linux.getdents64(dr.dir.handle, dr.buffer.ptr, @min(dr.buffer.len, std.math.maxInt(c_uint)));
switch (linux.errno(rc)) {
.SUCCESS => break rc,
.INTR => {},
.BADF => |err| return errnoBug(err), // Dir 无效,或打开时未启用迭代能力。
.FAULT => |err| return errnoBug(err),
.NOTDIR => |err| return errnoBug(err),
// 为保持跨平台一致,若遍历过程中
// 目录被删除,则终止遍历。
// 这与除 Linux、WASI 以外的
// UNIX 平台行为一致。
.NOENT => {
dr.state = .finished;
return 0;
},
// 读取 /proc/$PID/net 时可能发生,或者提供的缓冲区太小。此 API 不打算处理这两种情况。
//
//
.INVAL => return error.Unexpected,
.ACCES => return error.AccessDenied, // 没有遍历此目录的权限。
else => |err| return unexpectedErrno(err),
}
};
if (n == 0) {
dr.state = .finished;
return 0;
}
dr.index = 0;
dr.end = n;
}
// Linux 在名称的空字节后添加填充,对齐头部,
// 从而对齐下一个条目。因此,只检查下一个
// 记录之前的 8 字节即可找到名称末尾。但由于
// 文件名通常很短,最好保持机器码
// 简单。
//
// 此外,我观察到 qemu 用户模式不会对齐此结构体,
// 因此此代码采取保守选择,不假定其对齐。
const linux_entry: *align(1) linux.dirent64 = @ptrCast(&dr.buffer[dr.index]);
const next_index = dr.index + linux_entry.reclen;
dr.index = next_index;
const name_ptr: [*]u8 = &linux_entry.name;
const padded_name = name_ptr[0 .. linux_entry.reclen - @offsetOf(linux.dirent64, "name")];
const name_len = std.mem.findScalar(u8, padded_name, 0).?;
const name = name_ptr[0..name_len :0];
if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) continue;
const entry_kind: File.Kind = switch (linux_entry.type) {
linux.DT.BLK => .block_device,
linux.DT.CHR => .character_device,
linux.DT.DIR => .directory,
linux.DT.FIFO => .named_pipe,
linux.DT.LNK => .sym_link,
linux.DT.REG => .file,
linux.DT.SOCK => .unix_domain_socket,
else => .unknown,
};
buffer[buffer_index] = .{
.name = name,
.kind = entry_kind,
.inode = linux_entry.ino,
};
buffer_index += 1;
}
return buffer_index;
}
fn dirRealPath(userdata: ?*anyopaque, dir: Dir, out_buffer: []u8) Dir.RealPathError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
return ev.realPath(&sync, dir.handle, out_buffer);
}
fn dirRealPathFile(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
out_buffer: []u8,
) Dir.RealPathFileError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
const fd = ev.openat(&maybe_sync.cancel_region, dir.handle, sub_path_posix, .{
.CLOEXEC = true,
.PATH = true,
}, 0) catch |err| switch (err) {
error.WouldBlock => return errnoBug(.AGAIN),
error.OperationUnsupported => return errnoBug(.OPNOTSUPP), // 不请求锁。
error.ReadOnlyFileSystem => return errnoBug(.ROFS), // 不创建。
else => |e| return e,
};
defer ev.closeAsync(fd);
return ev.realPath(try maybe_sync.enterSync(ev), fd, out_buffer);
}
fn dirDeleteFile(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteFileError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .UNLINKAT,
.flags = 0,
.ioprio = 0,
.fd = dir.handle,
.off = 0,
.addr = @intFromPtr(sub_path_posix.ptr),
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.PERM => return error.PermissionDenied,
.ACCES => return error.AccessDenied,
.BUSY => return error.FileBusy,
.FAULT => |err| return errnoBug(err),
.IO => return error.FileSystem,
.ISDIR => return error.IsDir,
.LOOP => return error.SymLinkLoop,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOTDIR => return error.NotDir,
.NOMEM => return error.SystemResources,
.ROFS => return error.ReadOnlyFileSystem,
.EXIST => |err| return errnoBug(err),
.NOTEMPTY => |err| return errnoBug(err), // 未传入 AT.REMOVEDIR
.ILSEQ => return error.BadPathName,
.INVAL => |err| return errnoBug(err), // 标志无效,或路径名的最后一个分量为 .
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
else => |err| return unexpectedErrno(err),
}
}
}
fn dirDeleteDir(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8) Dir.DeleteDirError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .UNLINKAT,
.flags = 0,
.ioprio = 0,
.fd = dir.handle,
.off = 0,
.addr = @intFromPtr(sub_path_posix.ptr),
.len = 0,
.rw_flags = linux.AT.REMOVEDIR,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.ACCES => return error.AccessDenied,
.PERM => return error.PermissionDenied,
.BUSY => return error.FileBusy,
.FAULT => |err| return errnoBug(err),
.IO => return error.FileSystem,
.ISDIR => |err| return errnoBug(err),
.LOOP => return error.SymLinkLoop,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOTDIR => return error.NotDir,
.NOMEM => return error.SystemResources,
.ROFS => return error.ReadOnlyFileSystem,
.EXIST => |err| return errnoBug(err),
.NOTEMPTY => return error.DirNotEmpty,
.ILSEQ => return error.BadPathName,
.INVAL => |err| return errnoBug(err), // 标志无效,或路径名的最后一个分量为 .
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
else => |err| return unexpectedErrno(err),
}
}
}
fn dirRename(
userdata: ?*anyopaque,
old_dir: Dir,
old_sub_path: []const u8,
new_dir: Dir,
new_sub_path: []const u8,
) Dir.RenameError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var old_path_buffer: [PATH_MAX]u8 = undefined;
var new_path_buffer: [PATH_MAX]u8 = undefined;
const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.renameat(
&cancel_region,
old_dir.handle,
old_sub_path_posix,
new_dir.handle,
new_sub_path_posix,
.{},
);
}
fn dirRenamePreserve(
userdata: ?*anyopaque,
old_dir: Dir,
old_sub_path: []const u8,
new_dir: Dir,
new_sub_path: []const u8,
) Dir.RenamePreserveError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var old_path_buffer: [PATH_MAX]u8 = undefined;
var new_path_buffer: [PATH_MAX]u8 = undefined;
const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.renameat(
&cancel_region,
old_dir.handle,
old_sub_path_posix,
new_dir.handle,
new_sub_path_posix,
.{ .NOREPLACE = true },
);
}
fn dirSymLink(
userdata: ?*anyopaque,
dir: Dir,
target_path: []const u8,
sym_link_path: []const u8,
flags: Dir.SymLinkFlags,
) Dir.SymLinkError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = flags;
var target_path_buffer: [PATH_MAX]u8 = undefined;
var sym_link_path_buffer: [PATH_MAX]u8 = undefined;
const target_path_posix = try pathToPosix(target_path, &target_path_buffer);
const sym_link_path_posix = try pathToPosix(sym_link_path, &sym_link_path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .SYMLINKAT,
.flags = 0,
.ioprio = 0,
.fd = dir.handle,
.off = @intFromPtr(sym_link_path_posix.ptr),
.addr = @intFromPtr(target_path_posix.ptr),
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.ACCES => return error.AccessDenied,
.PERM => return error.PermissionDenied,
.DQUOT => return error.DiskQuota,
.EXIST => return error.PathAlreadyExists,
.IO => return error.FileSystem,
.LOOP => return error.SymLinkLoop,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOTDIR => return error.NotDir,
.NOMEM => return error.SystemResources,
.NOSPC => return error.NoSpaceLeft,
.ROFS => return error.ReadOnlyFileSystem,
.ILSEQ => return error.BadPathName,
else => |err| return unexpectedErrno(err),
}
}
}
fn dirReadLink(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
buffer: []u8,
) Dir.ReadLinkError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sub_path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &sub_path_buffer);
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
while (true) {
try sync.cancel_region.await(.nothing);
const rc = linux.readlinkat(dir.handle, sub_path_posix, buffer.ptr, buffer.len);
switch (linux.errno(rc)) {
.SUCCESS => return @bitCast(rc),
.INTR => {},
.ACCES => return error.AccessDenied,
.FAULT => |err| return errnoBug(err),
.INVAL => return error.NotLink,
.IO => return error.FileSystem,
.LOOP => return error.SymLinkLoop,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOMEM => return error.SystemResources,
.NOTDIR => return error.NotDir,
.ILSEQ => return error.BadPathName,
else => |err| return unexpectedErrno(err),
}
}
}
fn dirSetOwner(
userdata: ?*anyopaque,
dir: Dir,
owner: ?File.Uid,
group: ?File.Gid,
) Dir.SetOwnerError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
try ev.fchownat(
&sync,
dir.handle,
"",
owner orelse std.math.maxInt(linux.uid_t),
group orelse std.math.maxInt(linux.gid_t),
linux.AT.EMPTY_PATH,
);
}
fn dirSetFileOwner(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
owner: ?File.Uid,
group: ?File.Gid,
options: Dir.SetFileOwnerOptions,
) Dir.SetFileOwnerError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
try ev.fchownat(
&sync,
dir.handle,
sub_path_posix,
owner orelse std.math.maxInt(linux.uid_t),
group orelse std.math.maxInt(linux.gid_t),
if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW,
);
}
fn dirSetPermissions(
userdata: ?*anyopaque,
dir: Dir,
permissions: Dir.Permissions,
) Dir.SetPermissionsError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
ev.fchmodat(
&sync,
dir.handle,
"",
permissions.toMode(),
linux.AT.EMPTY_PATH,
) catch |err| switch (err) {
error.NameTooLong => return errnoBug(.NAMETOOLONG),
error.BadPathName => return errnoBug(.ILSEQ),
error.ProcessFdQuotaExceeded => return errnoBug(.MFILE),
error.SystemFdQuotaExceeded => return errnoBug(.NFILE),
error.OperationUnsupported => return errnoBug(.OPNOTSUPP),
else => |e| return e,
};
}
fn dirSetFilePermissions(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
permissions: Dir.Permissions,
options: Dir.SetFilePermissionsOptions,
) Dir.SetFilePermissionsError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
try ev.fchmodat(
&sync,
dir.handle,
sub_path_posix,
permissions.toMode(),
if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW,
);
}
fn dirSetTimestamps(
userdata: ?*anyopaque,
dir: Dir,
sub_path: []const u8,
options: Dir.SetTimestampsOptions,
) Dir.SetTimestampsError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
var cancel_region: CancelRegion.Sync = try .init(ev);
defer cancel_region.deinit(ev);
try ev.utimensat(
&cancel_region,
dir.handle,
sub_path_posix,
if (options.modify_timestamp != .now or options.access_timestamp != .now) &.{
setTimestampToPosix(options.access_timestamp),
setTimestampToPosix(options.modify_timestamp),
} else null,
if (options.follow_symlinks) 0 else linux.AT.SYMLINK_NOFOLLOW,
);
}
fn dirHardLink(
userdata: ?*anyopaque,
old_dir: Dir,
old_sub_path: []const u8,
new_dir: Dir,
new_sub_path: []const u8,
options: Dir.HardLinkOptions,
) Dir.HardLinkError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var old_path_buffer: [PATH_MAX]u8 = undefined;
var new_path_buffer: [PATH_MAX]u8 = undefined;
const old_sub_path_posix = try pathToPosix(old_sub_path, &old_path_buffer);
const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.linkat(
&cancel_region,
old_dir.handle,
old_sub_path_posix,
new_dir.handle,
new_sub_path_posix,
if (options.follow_symlinks) linux.AT.SYMLINK_FOLLOW else 0,
);
}
fn fileStat(userdata: ?*anyopaque, file: File) File.StatError!File.Stat {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.stat(&cancel_region, file.handle);
}
fn fileLength(userdata: ?*anyopaque, file: File) File.LengthError!u64 {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
var statx_buf = std.mem.zeroes(linux.Statx);
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .STATX,
.flags = 0,
.ioprio = 0,
.fd = file.handle,
.off = @intFromPtr(&statx_buf),
.addr = @intFromPtr(""),
.len = @bitCast(linux.STATX{ .SIZE = true }),
.rw_flags = linux.AT.EMPTY_PATH,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => {
if (!statx_buf.mask.SIZE) return error.Unexpected;
return statx_buf.size;
},
.INTR, .CANCELED => {},
.ACCES => |err| return errnoBug(err),
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.LOOP => |err| return errnoBug(err),
.NAMETOOLONG => |err| return errnoBug(err),
.NOENT => |err| return errnoBug(err),
.NOMEM => return error.SystemResources,
.NOTDIR => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn fileClose(userdata: ?*anyopaque, files: []const File) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
for (files) |file| ev.close(file.handle);
}
fn fileWritePositional(
userdata: ?*anyopaque,
file: File,
header: []const u8,
data: []const []const u8,
splat: usize,
offset: u64,
) File.WritePositionalError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var iovecs: [max_iovecs_len]iovec_const = undefined;
var iovlen: iovlen_t = 0;
addBuf(&iovecs, &iovlen, header);
for (data[0 .. data.len - 1]) |bytes| addBuf(&iovecs, &iovlen, bytes);
const pattern = data[data.len - 1];
var backup_buffer: [splat_buffer_size]u8 = undefined;
if (iovecs.len - iovlen != 0) switch (splat) {
0 => {},
1 => addBuf(&iovecs, &iovlen, pattern),
else => switch (pattern.len) {
0 => {},
1 => {
const splat_buffer = &backup_buffer;
const memset_len = @min(splat_buffer.len, splat);
const buf = splat_buffer[0..memset_len];
@memset(buf, pattern[0]);
addBuf(&iovecs, &iovlen, buf);
var remaining_splat = splat - buf.len;
while (remaining_splat > splat_buffer.len and iovecs.len - iovlen != 0) {
assert(buf.len == splat_buffer.len);
addBuf(&iovecs, &iovlen, splat_buffer);
remaining_splat -= splat_buffer.len;
}
addBuf(&iovecs, &iovlen, splat_buffer[0..@min(remaining_splat, splat_buffer.len)]);
},
else => for (0..@min(splat, iovecs.len - iovlen)) |_| {
addBuf(&iovecs, &iovlen, pattern);
},
},
};
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.pwritev(&cancel_region, file.handle, iovecs[0..iovlen], offset);
}
/// 此处为 usize 或 u32,二者均可。因此对写入文件
/// 和发送网络消息均使用同一个 `addBuf` 函数。
const iovlen_t = @FieldType(linux.msghdr_const, "iovlen");
fn addBuf(v: []iovec_const, i: *iovlen_t, bytes: []const u8) void {
// 操作系统先检查指针地址再检查长度,因此必须省略零长度向量。
if (bytes.len == 0) return;
if (v.len - i.* == 0) return;
v[i.*] = .{ .base = bytes.ptr, .len = bytes.len };
i.* += 1;
}
fn fileWriteFileStreaming(
userdata: ?*anyopaque,
file: File,
header: []const u8,
file_reader: *File.Reader,
limit: Io.Limit,
) File.Writer.WriteFileError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = file;
_ = header;
_ = file_reader;
_ = limit;
return error.Unimplemented;
}
fn fileWriteFilePositional(
userdata: ?*anyopaque,
file: File,
header: []const u8,
file_reader: *File.Reader,
limit: Io.Limit,
offset: u64,
) File.WriteFilePositionalError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = file;
_ = header;
_ = file_reader;
_ = limit;
_ = offset;
return error.Unimplemented;
}
fn fileReadPositional(
userdata: ?*anyopaque,
file: File,
data: []const []u8,
offset: u64,
) File.ReadPositionalError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var iovecs_buffer: [max_iovecs_len]iovec = undefined;
var i: usize = 0;
for (data) |buf| {
if (iovecs_buffer.len - i == 0) break;
if (buf.len > 0) {
iovecs_buffer[i] = .{ .base = buf.ptr, .len = buf.len };
i += 1;
}
}
if (i == 0) return 0;
const dest = iovecs_buffer[0..i];
assert(dest[0].len > 0);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.preadv(&cancel_region, file.handle, dest, offset) catch |err| switch (err) {
error.SocketUnconnected => return errnoBug(.NOTCONN), // 不是套接字
error.ConnectionResetByPeer => return errnoBug(.CONNRESET), // 不是套接字
else => |e| return e,
};
}
fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
try ev.lseek(&sync, file.handle, @bitCast(offset), linux.SEEK.CUR);
}
fn fileSeekTo(userdata: ?*anyopaque, file: File, offset: u64) File.SeekError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
try ev.lseek(&sync, file.handle, offset, linux.SEEK.SET);
}
fn fileSync(userdata: ?*anyopaque, file: File) File.SyncError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .FSYNC,
.flags = 0,
.ioprio = 0,
.fd = file.handle,
.off = 0,
.addr = 0,
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.BADF => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.ROFS => |err| return errnoBug(err),
.IO => return error.InputOutput,
.NOSPC => return error.NoSpaceLeft,
.DQUOT => return error.DiskQuota,
else => |err| return unexpectedErrno(err),
}
}
}
fn fileIsTty(userdata: ?*anyopaque, file: File) Io.Cancelable!bool {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
while (true) {
try sync.cancel_region.await(.nothing);
var wsz: winsize = undefined;
const rc = linux.ioctl(file.handle, linux.T.IOCGWINSZ, @intFromPtr(&wsz));
switch (linux.errno(rc)) {
.SUCCESS => return true,
.INTR => {},
else => return false,
}
}
}
fn fileEnableAnsiEscapeCodes(userdata: ?*anyopaque, file: File) File.EnableAnsiEscapeCodesError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
if (!try fileIsTty(ev, file)) return error.NotTerminalDevice;
}
fn fileSetLength(userdata: ?*anyopaque, file: File, length: u64) File.SetLengthError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .FTRUNCATE,
.flags = 0,
.ioprio = 0,
.fd = file.handle,
.off = length,
.addr = 0,
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.FBIG => return error.FileTooBig,
.IO => return error.InputOutput,
.PERM => return error.PermissionDenied,
.TXTBSY => return error.FileBusy,
.BADF => |err| return errnoBug(err), // 句柄未以写入方式打开。
.INVAL => return error.NonResizable, // 例如,/dev/null 会返回此值。
else => |err| return unexpectedErrno(err),
}
}
}
fn fileSetOwner(
userdata: ?*anyopaque,
file: File,
owner: ?File.Uid,
group: ?File.Gid,
) File.SetOwnerError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
try ev.fchownat(
&sync,
file.handle,
"",
owner orelse std.math.maxInt(linux.uid_t),
group orelse std.math.maxInt(linux.gid_t),
linux.AT.EMPTY_PATH,
);
}
fn fileSetPermissions(
userdata: ?*anyopaque,
file: File,
permissions: File.Permissions,
) File.SetPermissionsError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
ev.fchmodat(
&sync,
file.handle,
"",
permissions.toMode(),
linux.AT.EMPTY_PATH,
) catch |err| switch (err) {
error.NameTooLong => return errnoBug(.NAMETOOLONG),
error.BadPathName => return errnoBug(.ILSEQ),
error.ProcessFdQuotaExceeded => return errnoBug(.MFILE),
error.SystemFdQuotaExceeded => return errnoBug(.NFILE),
error.OperationUnsupported => return errnoBug(.OPNOTSUPP),
else => |e| return e,
};
}
fn fileSetTimestamps(
userdata: ?*anyopaque,
file: File,
options: File.SetTimestampsOptions,
) File.SetTimestampsError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
try ev.utimensat(
&sync,
file.handle,
"",
if (options.modify_timestamp != .now or options.access_timestamp != .now) &.{
setTimestampToPosix(options.access_timestamp),
setTimestampToPosix(options.modify_timestamp),
} else null,
linux.AT.EMPTY_PATH,
);
}
fn fileLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
ev.flock(&sync, file.handle, lock, .blocking) catch |err| switch (err) {
error.WouldBlock => unreachable, // 阻塞
else => |e| return e,
};
}
fn fileTryLock(userdata: ?*anyopaque, file: File, lock: File.Lock) File.LockError!bool {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
ev.flock(&sync, file.handle, lock, switch (lock) {
.none => .blocking,
.shared, .exclusive => .nonblocking,
}) catch |err| switch (err) {
error.WouldBlock => return false,
else => |e| return e,
};
return true;
}
fn fileUnlock(userdata: ?*anyopaque, file: File) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = .initBlocked(ev);
defer sync.deinit(ev);
ev.flock(&sync, file.handle, .none, .blocking) catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
error.WouldBlock => unreachable, // 阻塞
error.SystemResources => return recoverableOsBugDetected(), // 资源释放。
error.FileLocksUnsupported => return recoverableOsBugDetected(), // 我们已经获得锁。
error.Unexpected => return recoverableOsBugDetected(), // 资源释放必须成功。
};
}
fn fileDowngradeLock(userdata: ?*anyopaque, file: File) File.DowngradeLockError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
ev.flock(&sync, file.handle, .shared, .nonblocking) catch |err| switch (err) {
error.WouldBlock => return errnoBug(.AGAIN), // 文件未以排他模式加锁。
error.SystemResources => return errnoBug(.NOLCK), // 已获取锁。
error.FileLocksUnsupported => return errnoBug(.OPNOTSUPP), // 已获取锁。
else => |e| return e,
};
}
fn fileRealPath(userdata: ?*anyopaque, file: File, out_buffer: []u8) File.RealPathError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
return ev.realPath(&sync, file.handle, out_buffer);
}
fn fileHardLink(
userdata: ?*anyopaque,
file: File,
new_dir: Dir,
new_sub_path: []const u8,
options: File.HardLinkOptions,
) File.HardLinkError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var new_path_buffer: [PATH_MAX]u8 = undefined;
const new_sub_path_posix = try pathToPosix(new_sub_path, &new_path_buffer);
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
return ev.linkat(
&cancel_region,
file.handle,
"",
new_dir.handle,
new_sub_path_posix,
linux.AT.EMPTY_PATH | @as(u32, if (options.follow_symlinks) linux.AT.SYMLINK_FOLLOW else 0),
);
}
fn fileMemoryMapCreate(
userdata: ?*anyopaque,
file: File,
options: File.MemoryMap.CreateOptions,
) File.MemoryMap.CreateError!File.MemoryMap {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const prot: linux.PROT = .{
.READ = options.protection.read,
.WRITE = options.protection.write,
.EXEC = options.protection.execute,
};
const flags: linux.MAP = .{
.TYPE = .SHARED_VALIDATE,
.POPULATE = options.populate,
};
const page_align = std.heap.page_size_min;
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
const contents = while (true) {
try sync.cancel_region.await(.nothing);
const casted_offset = std.math.cast(i64, options.offset) orelse return error.Unseekable;
const rc = linux.mmap(null, options.len, prot, flags, file.handle, casted_offset);
switch (linux.errno(rc)) {
.SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..options.len],
.INTR => {},
.ACCES => return error.AccessDenied,
.AGAIN => return error.LockedMemoryLimitExceeded,
.MFILE => return error.ProcessFdQuotaExceeded,
.NFILE => return error.SystemFdQuotaExceeded,
.NOMEM => return error.OutOfMemory,
.PERM => return error.PermissionDenied,
.OVERFLOW => return error.Unseekable,
.BADF => |err| return errnoBug(err), // 始终存在竞态条件。
.INVAL => |err| return errnoBug(err), // mmap() 的参数无效
.OPNOTSUPP => |err| return errnoBug(err), // 在 Linux 上与 MAP.SHARED_VALIDATE 一起使用了无效标志。
else => |err| return unexpectedErrno(err),
}
};
return .{
.file = file,
.offset = options.offset,
.memory = contents,
.section = {},
};
}
fn fileMemoryMapDestroy(userdata: ?*anyopaque, mm: *File.MemoryMap) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
const memory = mm.memory;
if (memory.len == 0) return;
switch (linux.errno(linux.munmap(memory.ptr, memory.len))) {
.SUCCESS => {},
else => |err| if (builtin.mode == .debug)
std.log.err("failed to unmap {d} bytes at {*}: {t}", .{ memory.len, memory.ptr, err }),
}
mm.* = undefined;
}
fn fileMemoryMapSetLength(
userdata: ?*anyopaque,
mm: *File.MemoryMap,
new_len: usize,
) File.MemoryMap.SetLengthError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const page_size = std.heap.pageSize();
const alignment: Alignment = .fromByteUnits(page_size);
const page_align = std.heap.page_size_min;
const old_memory = mm.memory;
if (alignment.forward(new_len) == alignment.forward(old_memory.len)) {
mm.memory.len = new_len;
return;
}
const flags: linux.MREMAP = .{ .MAYMOVE = true };
const addr_hint: ?[*]const u8 = null;
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
const new_memory = while (true) {
try sync.cancel_region.await(.nothing);
const rc = linux.mremap(old_memory.ptr, old_memory.len, new_len, flags, addr_hint);
switch (linux.errno(rc)) {
.SUCCESS => break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..new_len],
.INTR => {},
.AGAIN => return error.LockedMemoryLimitExceeded,
.NOMEM => return error.OutOfMemory,
.INVAL => |err| return errnoBug(err),
.FAULT => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
};
mm.memory = new_memory;
}
fn fileMemoryMapRead(userdata: ?*anyopaque, mm: *File.MemoryMap) File.ReadPositionalError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = mm;
}
fn fileMemoryMapWrite(userdata: ?*anyopaque, mm: *File.MemoryMap) File.WritePositionalError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = mm;
}
fn processExecutableOpen(
userdata: ?*anyopaque,
flags: Dir.OpenFileOptions,
) process.OpenExecutableError!File {
const ev: *Evented = @ptrCast(@alignCast(userdata));
return dirOpenFile(ev, .{ .handle = linux.AT.FDCWD }, "/proc/self/exe", flags);
}
fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.ExecutablePathError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
return dirReadLink(ev, .cwd(), "/proc/self/exe", out_buffer) catch |err| switch (err) {
error.UnsupportedReparsePointType => unreachable, // 仅限 Windows
error.NetworkNotFound => unreachable, // 仅限 Windows
error.FileBusy => unreachable, // 仅限 Windows
else => |e| return e,
};
}
fn lockStderr(userdata: ?*anyopaque, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const ev_io = ev.io();
ev.stderr_mutex.lockUncancelable(ev_io);
errdefer ev.stderr_mutex.unlock(ev_io);
return ev.initLockedStderr(terminal_mode);
}
fn tryLockStderr(
userdata: ?*anyopaque,
terminal_mode: ?Io.Terminal.Mode,
) Io.Cancelable!?Io.LockedStderr {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const ev_io = ev.io();
if (!ev.stderr_mutex.tryLock()) return null;
errdefer ev.stderr_mutex.unlock(ev_io);
return try ev.initLockedStderr(terminal_mode);
}
fn initLockedStderr(ev: *Evented, terminal_mode: ?Io.Terminal.Mode) Io.Cancelable!Io.LockedStderr {
if (!ev.stderr_writer_initialized) {
const ev_io = ev.io();
const cancel_protection = swapCancelProtection(ev, .blocked);
defer assert(swapCancelProtection(ev, cancel_protection) == .blocked);
ev.scanEnviron() catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
};
const NO_COLOR = ev.environ.exist.NO_COLOR;
const CLICOLOR_FORCE = ev.environ.exist.CLICOLOR_FORCE;
ev.stderr_mode = Io.Terminal.Mode.detect(
ev_io,
ev.stderr_writer.file,
NO_COLOR,
CLICOLOR_FORCE,
) catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
};
ev.stderr_writer_initialized = true;
}
return .{
.file_writer = &ev.stderr_writer,
.terminal_mode = terminal_mode orelse ev.stderr_mode,
};
}
fn unlockStderr(userdata: ?*anyopaque) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
if (ev.stderr_writer.err == null) ev.stderr_writer.interface.flush() catch {};
if (ev.stderr_writer.err) |err| {
switch (err) {
error.Canceled => Thread.current().currentFiber().cancel_protection.recancel(),
else => {},
}
ev.stderr_writer.err = null;
}
ev.stderr_writer.interface.end = 0;
ev.stderr_writer.interface.buffer = &.{};
ev.stderr_mutex.unlock(ev.io());
}
fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.getcwd(buffer.ptr, buffer.len))) {
.SUCCESS => return std.mem.findScalar(u8, buffer, 0).?,
.INTR => {},
.NOENT => return error.CurrentDirUnlinked,
.RANGE => return error.NameTooLong,
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn processSetCurrentDir(userdata: ?*anyopaque, dir: Dir) process.SetCurrentDirError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
if (dir.handle == linux.AT.FDCWD) return;
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
return fchdir(&sync, dir.handle);
}
fn processSetCurrentPath(userdata: ?*anyopaque, dir_path: []const u8) process.SetCurrentPathError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var path_buffer: [PATH_MAX]u8 = undefined;
const dir_path_posix = try pathToPosix(dir_path, &path_buffer);
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
return chdir(&sync, dir_path_posix);
}
fn processReplace(userdata: ?*anyopaque, options: process.ReplaceOptions) process.ReplaceError {
const ev: *Evented = @ptrCast(@alignCast(userdata));
try ev.scanEnviron(); // 用于 PATH
const PATH = ev.environ.string.PATH orelse default_PATH;
var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
defer arena_allocator.deinit();
const arena = arena_allocator.allocator();
const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
const env_block = env_block: {
const prog_fd: i32 = -1;
if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
.zig_progress_fd = prog_fd,
});
break :env_block try ev.environ.process_environ.createPosixBlock(arena, .{
.zig_progress_fd = prog_fd,
});
};
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
switch (options.cwd) {
.inherit => {},
.dir => |cwd_dir| fchdir(&sync, cwd_dir.handle) catch |err| switch (err) {
error.NoDevice, error.UnrecognizedVolume => return error.FileSystem,
else => |e| return e,
},
.path => |cwd_path| {
var cwd_path_buffer: [PATH_MAX]u8 = undefined;
const cwd_path_posix = try pathToPosix(cwd_path, &cwd_path_buffer);
chdir(&sync, cwd_path_posix) catch |err| switch (err) {
error.SymLinkLoop => return error.FileSystem,
else => |e| return e,
};
},
}
for (options.inherit_dirs) |dir| try setFdFlags(&sync, dir.handle, 0);
for (options.inherit_files) |file| try setFdFlags(&sync, file.handle, 0);
if (options.start_suspended) {
switch (linux.errno(linux.kill(linux.getpid(), .STOP))) {
.SUCCESS => {},
.PERM => return error.PermissionDenied,
else => return error.Unexpected,
}
}
return processExec(&sync, options.exe, argv_buf.ptr, options.expand_arg0, env_block, PATH);
}
fn processSpawn(userdata: ?*anyopaque, options: process.SpawnOptions) process.SpawnError!process.Child {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const spawned = try ev.spawn(options);
var cancel_region: CancelRegion = .initBlocked();
defer cancel_region.deinit();
defer ev.closeAsync(spawned.err_fd);
// 等待子进程报告 `execvpe` 内部或之前发生的任何错误。
var child_err: ForkBailError = undefined;
ev.readAll(&cancel_region, spawned.err_fd, @ptrCast(&child_err)) catch |read_err| {
switch (read_err) {
error.Canceled => unreachable, // 已阻塞
error.EndOfStream => {
// 调用 `execvpe` 时,写入端由 CLOEXEC 关闭,
// 表示成功。
},
else => {
// 从错误报告管道读取错误时出现问题。
// 无法确定子进程仍存活还是已退出。最好假定它仍
// 存活,以免资源泄漏。
},
}
return .{
.id = spawned.pid,
.thread_handle = {},
.stdin = spawned.stdin,
.stdout = spawned.stdout,
.stderr = spawned.stderr,
.request_resource_usage_statistics = options.request_resource_usage_statistics,
};
};
return child_err;
}
const prog_fileno = @max(linux.STDIN_FILENO, linux.STDOUT_FILENO, linux.STDERR_FILENO);
const Spawned = struct {
pid: pid_t,
err_fd: fd_t,
stdin: ?File,
stdout: ?File,
stderr: ?File,
};
fn spawn(ev: *Evented, options: process.SpawnOptions) process.SpawnError!Spawned {
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
// 子进程确实需要访问这些管道的一端,但最初必须设置 CLOEXEC,以避免竞态条件。若另一个线程正在并发创建其他子进程,绝不能让后者继承这些文件描述符。例如,其他子进程可能保留管道写端引用,导致父进程调用 `poll` 时,无法在预期时机检测到目标子进程的标准输出关闭。
// 因此,创建管道时先设置 CLOEXEC。fork 后,必须在新子进程中确保保留所需引用。可以使用 `fcntl` 移除描述符上的 CLOEXEC,但实际上所有描述符都会经过 `dup2`,因此无需额外操作。
//
//
//
//
//
//
//
//
const pipe_flags: linux.O = .{ .CLOEXEC = true };
const stdin_pipe = if (options.stdin == .pipe) try pipe2(pipe_flags) else undefined;
errdefer if (options.stdin == .pipe) {
ev.destroyPipe(stdin_pipe);
};
const stdout_pipe = if (options.stdout == .pipe) try pipe2(pipe_flags) else undefined;
errdefer if (options.stdout == .pipe) {
ev.destroyPipe(stdout_pipe);
};
const stderr_pipe = if (options.stderr == .pipe) try pipe2(pipe_flags) else undefined;
errdefer if (options.stderr == .pipe) {
ev.destroyPipe(stderr_pipe);
};
const any_ignore =
options.stdin == .ignore or options.stdout == .ignore or options.stderr == .ignore;
const dev_null_fd = if (any_ignore) try ev.null_fd.open(ev, &cancel_region, "/dev/null", .{
.ACCMODE = .RDWR,
}) else undefined;
const prog_pipe: [2]fd_t = if (options.progress_node.index != .none) pipe: {
// 与 `pipe_flags` 中相同的原因,使用 CLOEXEC。
const pipe = try pipe2(.{ .NONBLOCK = true, .CLOEXEC = true });
_ = linux.fcntl(pipe[0], linux.F.SETPIPE_SZ, @as(u32, std.Progress.max_packet_len * 2));
break :pipe pipe;
} else .{ -1, -1 };
errdefer ev.destroyPipe(prog_pipe);
var arena_allocator = std.heap.ArenaAllocator.init(ev.allocator());
defer arena_allocator.deinit();
const arena = arena_allocator.allocator();
// POSIX 标准不允许在 fork() 与 execve() 之间调用 malloc(),
// 而此分配器可能是 libc 分配器。
// 我曾在 musl v1.1.24 中亲眼观察到:
// 由于 fork() 与 execve() 之间发生堆分配,
// 子进程尝试调用 malloc() 时发生死锁。
// 此外,我们希望减少 fork() 与 execve() 之间
// 可能发生失败的方式。
// 因此,execve() 所需的所有分配都在 fork() 之前完成。
// 这意味着必须在此处为 argv 和环境变量添加空字符终止符。
const argv_buf = try arena.allocSentinel(?[*:0]const u8, options.argv.len, null);
for (options.argv, 0..) |arg, i| argv_buf[i] = (try arena.dupeSentinel(u8, arg, 0)).ptr;
const env_block = env_block: {
const prog_fd: i32 = if (prog_pipe[1] == -1) -1 else prog_fileno;
if (options.environ_map) |environ_map| break :env_block try environ_map.createPosixBlock(arena, .{
.zig_progress_fd = prog_fd,
});
break :env_block try ev.environ.process_environ.createPosixBlock(arena, .{
.zig_progress_fd = prog_fd,
});
};
// 此管道在 `fork` 与 `execvpe` 之间向父进程传递子进程错误。
// 若 `execvpe` 成功,子进程会通过 CLOEXEC 关闭管道而不写入。
const err_pipe: [2]fd_t = try pipe2(.{ .CLOEXEC = true });
errdefer ev.destroyPipe(err_pipe);
try ev.scanEnviron(); // 用于 PATH
const PATH = ev.environ.string.PATH orelse default_PATH;
const pid_result: pid_t = fork: {
const rc = linux.fork();
switch (linux.errno(rc)) {
.SUCCESS => break :fork @intCast(rc),
.AGAIN => return error.SystemResources,
.NOMEM => return error.SystemResources,
.NOSYS => return error.OperationUnsupported,
else => |err| return unexpectedErrno(err),
}
};
if (pid_result == 0) {
defer comptime unreachable; // 当前是子进程。
// 注意,父进程 uring 已不可访问,因此不得再引用 `ev`。
var sync: CancelRegion.Sync = .{ .cancel_region = .initBlocked() };
const err = setUpChild(&sync, .{
.stdin_pipe = stdin_pipe[0],
.stdout_pipe = stdout_pipe[1],
.stderr_pipe = stderr_pipe[1],
.dev_null_fd = dev_null_fd,
.prog_pipe = prog_pipe[1],
.argv_buf = argv_buf,
.env_block = env_block,
.PATH = PATH,
.spawn = options,
});
writeAllSync(&sync, err_pipe[1], @ptrCast(&err)) catch {};
const exit = if (builtin.single_threaded) linux.exit else linux.exit_group;
exit(1);
}
const pid: pid_t = @intCast(pid_result); // 当前为父进程。
errdefer comptime unreachable; // 子进程已 fork;此后绝不能返回错误
ev.closeAsync(err_pipe[1]); // 确保只有子进程保持写入端打开
if (options.stdin == .pipe) ev.closeAsync(stdin_pipe[0]);
if (options.stdout == .pipe) ev.closeAsync(stdout_pipe[1]);
if (options.stderr == .pipe) ev.closeAsync(stderr_pipe[1]);
if (prog_pipe[1] != -1) ev.closeAsync(prog_pipe[1]);
options.progress_node.setIpcFile(ev, .{ .handle = prog_pipe[0], .flags = .{ .nonblocking = true } });
return .{
.pid = pid,
.err_fd = err_pipe[0],
.stdin = switch (options.stdin) {
.pipe => .{ .handle = stdin_pipe[1], .flags = .{ .nonblocking = false } },
else => null,
},
.stdout = switch (options.stdout) {
.pipe => .{ .handle = stdout_pipe[0], .flags = .{ .nonblocking = false } },
else => null,
},
.stderr = switch (options.stderr) {
.pipe => .{ .handle = stderr_pipe[0], .flags = .{ .nonblocking = false } },
else => null,
},
};
}
pub const PipeError = error{
SystemFdQuotaExceeded,
ProcessFdQuotaExceeded,
} || Io.UnexpectedError;
pub fn pipe2(flags: linux.O) PipeError![2]fd_t {
var fds: [2]fd_t = undefined;
switch (linux.errno(linux.pipe2(&fds, flags))) {
.SUCCESS => return fds,
.INVAL => |err| return errnoBug(err), // 无效的标志
.NFILE => return error.SystemFdQuotaExceeded,
.MFILE => return error.ProcessFdQuotaExceeded,
else => |err| return unexpectedErrno(err),
}
}
fn destroyPipe(ev: *Evented, pipe: [2]fd_t) void {
if (pipe[0] != -1) ev.closeAsync(pipe[0]);
if (pipe[0] != pipe[1]) ev.closeAsync(pipe[1]);
}
/// fork() 与 execv() 之间可能发生的错误。
const ForkBailError = process.SetCurrentDirError || ChdirError ||
process.SpawnError || process.ReplaceError;
fn setUpChild(sync: *CancelRegion.Sync, options: struct {
stdin_pipe: fd_t,
stdout_pipe: fd_t,
stderr_pipe: fd_t,
dev_null_fd: fd_t,
prog_pipe: fd_t,
argv_buf: [:null]?[*:0]const u8,
env_block: process.Environ.Block,
PATH: []const u8,
spawn: process.SpawnOptions,
}) ForkBailError {
// 必须在下方覆盖文件描述符之前执行。
switch (options.spawn.cwd) {
.inherit => {},
.dir => |cwd_dir| try fchdir(sync, cwd_dir.handle),
.path => |cwd_path| {
var cwd_path_buffer: [PATH_MAX]u8 = undefined;
const cwd_path_posix = try pathToPosix(cwd_path, &cwd_path_buffer);
try chdir(sync, cwd_path_posix);
},
}
for (options.spawn.inherit_dirs) |dir| try setFdFlags(sync, dir.handle, 0);
for (options.spawn.inherit_files) |file| try setFdFlags(sync, file.handle, 0);
try setUpChildIo(
sync,
options.spawn.stdin,
options.stdin_pipe,
linux.STDIN_FILENO,
options.dev_null_fd,
);
try setUpChildIo(
sync,
options.spawn.stdout,
options.stdout_pipe,
linux.STDOUT_FILENO,
options.dev_null_fd,
);
try setUpChildIo(
sync,
options.spawn.stderr,
options.stderr_pipe,
linux.STDERR_FILENO,
options.dev_null_fd,
);
// 必须在上方的 fchdir 之后执行,因为当前工作目录的文件描述符可能
// 等于 prog_fileno,并被此操作覆盖。
if (options.prog_pipe != -1) {
if (options.prog_pipe == prog_fileno)
try setFdFlags(sync, options.prog_pipe, 0)
else
try dup2(sync, options.prog_pipe, prog_fileno);
}
if (options.spawn.gid) |gid| {
switch (linux.errno(linux.setregid(gid, gid))) {
.SUCCESS => {},
.AGAIN => return error.ResourceLimitReached,
.INVAL => return error.InvalidUserId,
.PERM => return error.PermissionDenied,
else => return error.Unexpected,
}
}
if (options.spawn.uid) |uid| {
switch (linux.errno(linux.setreuid(uid, uid))) {
.SUCCESS => {},
.AGAIN => return error.ResourceLimitReached,
.INVAL => return error.InvalidUserId,
.PERM => return error.PermissionDenied,
else => return error.Unexpected,
}
}
if (options.spawn.pgid) |pid| {
switch (linux.errno(linux.setpgid(0, pid))) {
.SUCCESS => {},
.ACCES => return error.ProcessAlreadyExec,
.INVAL => return error.InvalidProcessGroupId,
.PERM => return error.PermissionDenied,
else => return error.Unexpected,
}
}
if (options.spawn.start_suspended) {
switch (linux.errno(linux.kill(linux.getpid(), .STOP))) {
.SUCCESS => {},
.PERM => return error.PermissionDenied,
else => return error.Unexpected,
}
}
return processExec(
sync,
options.spawn.exe,
options.argv_buf.ptr,
options.spawn.expand_arg0,
options.env_block,
options.PATH,
);
}
fn setUpChildIo(
sync: *CancelRegion.Sync,
stdio: process.SpawnOptions.StdIo,
pipe_fd: fd_t,
std_fileno: i32,
dev_null_fd: fd_t,
) !void {
switch (stdio) {
.pipe => try dup2(sync, pipe_fd, std_fileno),
.close => _ = linux.close(std_fileno),
.inherit => {},
.ignore => try dup2(sync, dev_null_fd, std_fileno),
.file => |file| try dup2(sync, file.handle, std_fileno),
}
}
fn setFdFlags(sync: *CancelRegion.Sync, fd: fd_t, flags: usize) (Io.Cancelable || Io.UnexpectedError)!void {
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.fcntl(fd, linux.F.SETFD, flags))) {
.SUCCESS => return,
.INTR => {},
else => |err| return unexpectedErrno(err),
}
}
}
pub const DupError = error{
ProcessFdQuotaExceeded,
SystemResources,
} || Io.UnexpectedError || Io.Cancelable;
pub fn dup2(sync: *CancelRegion.Sync, old_fd: fd_t, new_fd: fd_t) DupError!void {
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.dup2(old_fd, new_fd))) {
.SUCCESS => return,
.BUSY, .INTR => {},
.INVAL => |err| return errnoBug(err), // 无效参数
.BADF => |err| return errnoBug(err), // 释放后使用
.MFILE => return error.ProcessFdQuotaExceeded,
.NOMEM => return error.SystemResources,
else => |err| return unexpectedErrno(err),
}
}
}
fn processExec(
sync: *CancelRegion.Sync,
exe: process.ReplaceOptions.Exe,
argv: [*:null]?[*:0]const u8,
expand_arg0: process.ArgExpansion,
env_block: process.Environ.PosixBlock,
PATH: []const u8,
) process.ReplaceError {
const arg0_slice = std.mem.span(argv[0].?);
exe: switch (exe) {
.detect => continue :exe if (std.mem.findScalar(u8, arg0_slice, '/')) |_| .{
.path = .cwd(),
} else .search,
.search => {
if (Dir.path.isAbsolute(arg0_slice)) continue :exe .{ .path = .cwd() };
var path_buf: [PATH_MAX]u8 = undefined;
var it = std.mem.tokenizeScalar(u8, PATH, ':');
var err: error{ FileNotFound, NotDir } = error.FileNotFound;
while (it.next()) |search_path| {
const path_len = search_path.len + arg0_slice.len + 1;
if (path_buf.len < path_len + 1) return error.NameTooLong;
@memcpy(path_buf[0..search_path.len], search_path);
path_buf[search_path.len] = Dir.path.sep;
@memcpy(path_buf[search_path.len + 1 ..][0..arg0_slice.len], arg0_slice);
path_buf[path_len] = 0;
const full_path = path_buf[0..path_len :0].ptr;
switch (expand_arg0) {
.expand => argv[0] = full_path,
.no_expand => {},
}
switch (processExecveat(sync, linux.AT.FDCWD, full_path, argv, env_block)) {
error.AccessDenied => {},
error.FileNotFound, error.NotDir => |e| err = e,
else => |e| return e,
}
}
return err;
},
.path => |dir| return processExecveat(sync, dir.handle, arg0_slice, argv, env_block),
.file => |file| return processExecveat(sync, file.handle, null, argv, env_block),
.explicit => |explicit| {
var path_buffer: [PATH_MAX]u8 = undefined;
const path_posix = try pathToPosix(explicit.path, &path_buffer);
return processExecveat(sync, explicit.dir.handle, path_posix, argv, env_block);
},
}
}
fn processExecveat(
sync: *CancelRegion.Sync,
dir: fd_t,
path: ?[*:0]const u8,
argv: [*:null]const ?[*:0]const u8,
env_block: process.Environ.PosixBlock,
) process.ReplaceError {
try sync.cancel_region.await(.nothing);
const rc = if (path) |p|
if (dir == linux.AT.FDCWD or Dir.path.isAbsoluteZ(p))
linux.execve(p, argv, env_block.slice.ptr)
else
linux.execveat(dir, p, argv, env_block.slice.ptr, .{
.EMPTY_PATH = false,
.SYMLINK_NOFOLLOW = false,
})
else
linux.execveat(dir, "", argv, env_block.slice.ptr, .{
.EMPTY_PATH = true,
.SYMLINK_NOFOLLOW = false,
});
switch (linux.errno(rc)) {
.FAULT => |err| return errnoBug(err), // 错误的指针参数。
.@"2BIG" => return error.SystemResources,
.MFILE => return error.ProcessFdQuotaExceeded,
.NAMETOOLONG => return error.NameTooLong,
.NFILE => return error.SystemFdQuotaExceeded,
.NOMEM => return error.SystemResources,
.ACCES => return error.AccessDenied,
.PERM => return error.PermissionDenied,
.INVAL => return error.InvalidExe,
.NOEXEC => return error.InvalidExe,
.IO => return error.FileSystem,
.LOOP => return error.FileSystem,
.ISDIR => return error.IsDir,
.NOENT => return error.FileNotFound,
.NOTDIR => return error.NotDir,
.TXTBSY => return error.FileBusy,
.LIBBAD => return error.InvalidExe,
.NOSYS => return error.OperationUnsupported,
else => |err| return unexpectedErrno(err),
}
}
fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitError!process.Child.Term {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
defer ev.childCleanup(child);
const pid = child.id.?;
var info: linux.siginfo_t = undefined;
while (true) {
const thread = try maybe_sync.cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .WAITID,
.flags = 0,
.ioprio = 0,
.fd = pid,
.off = @intFromPtr(&info),
.addr = 0,
.len = @backingInt(linux.P.PID),
.rw_flags = 0,
.user_data = @intFromPtr(maybe_sync.cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = linux.W.EXITED |
@as(i32, if (child.request_resource_usage_statistics) linux.W.NOWAIT else 0),
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (maybe_sync.cancel_region.errno()) {
.SUCCESS => {
if (child.request_resource_usage_statistics) {
const sync = try maybe_sync.enterSync(ev);
while (true) {
try sync.cancel_region.await(.nothing);
var rusage: linux.rusage = undefined;
switch (linux.errno(linux.waitid(
.PID,
pid,
&info,
linux.W.EXITED | linux.W.NOHANG,
&rusage,
))) {
.SUCCESS => {
child.resource_usage_statistics.rusage = rusage;
break;
},
.INTR, .CANCELED => {},
.CHILD => |err| return errnoBug(err), // 重复释放。
else => |err| return unexpectedErrno(err),
}
}
}
const status: u32 = @bitCast(info.fields.common.second.sigchld.status);
const code: linux.CLD = @fromBackingInt(@intCast(info.code));
return switch (code) {
.EXITED => .{ .exited = @truncate(status) },
.KILLED, .DUMPED => .{ .signal = @fromBackingInt(@intCast(status)) },
.TRAPPED, .STOPPED => .{ .stopped = @fromBackingInt(@intCast(status)) },
_, .CONTINUED => .{ .unknown = status },
};
},
.INTR, .CANCELED => {},
.CHILD => |err| return errnoBug(err), // 重复释放。
else => |err| return unexpectedErrno(err),
}
}
}
fn childKill(userdata: ?*anyopaque, child: *process.Child) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var maybe_sync: CancelRegion.Sync.Maybe = .{ .sync = .initBlocked(ev) };
defer maybe_sync.deinit(ev);
defer ev.childCleanup(child);
const pid = child.id.?;
while (true) switch (linux.errno(linux.kill(pid, .TERM))) {
.SUCCESS => break,
.INTR => {},
.PERM => return,
.INVAL => |err| return errnoBug(err) catch {},
.SRCH => |err| return errnoBug(err) catch {},
else => |err| return unexpectedErrno(err) catch {},
};
maybe_sync.leaveSync(ev);
var info: linux.siginfo_t = undefined;
while (true) {
const thread = maybe_sync.cancel_region.awaitIoUring() catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
};
thread.enqueue().* = .{
.opcode = .WAITID,
.flags = 0,
.ioprio = 0,
.fd = pid,
.off = @intFromPtr(&info),
.addr = 0,
.len = @backingInt(linux.P.PID),
.rw_flags = 0,
.user_data = @intFromPtr(maybe_sync.cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = linux.W.EXITED,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (maybe_sync.cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.CHILD => |err| return errnoBug(err) catch {}, // 重复释放。
else => |err| return unexpectedErrno(err) catch {},
}
}
}
fn childCleanup(ev: *Evented, child: *process.Child) void {
if (child.stdin) |*stdin| {
ev.closeAsync(stdin.handle);
child.stdin = null;
}
if (child.stdout) |*stdout| {
ev.closeAsync(stdout.handle);
child.stdout = null;
}
if (child.stderr) |*stderr| {
ev.closeAsync(stderr.handle);
child.stderr = null;
}
child.id = null;
}
fn progressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileError!File {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const cancel_protection = swapCancelProtection(ev, .blocked);
defer assert(swapCancelProtection(ev, cancel_protection) == .blocked);
ev.scanEnviron() catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
};
return ev.environ.zig_progress_file;
}
fn inheritParentHandle(ev: *Evented, handle: fd_t) Io.InheritParentHandleError!void {
var sync: CancelRegion.Sync = try .init(ev);
defer sync.deinit(ev);
return setFdFlags(&sync, handle, linux.FD_CLOEXEC);
}
fn inheritParentDir(userdata: ?*anyopaque, handle: Dir.Handle) Io.InheritParentHandleError!Dir {
const ev: *Evented = @ptrCast(@alignCast(userdata));
try inheritParentHandle(ev, handle);
return .{ .handle = handle };
}
fn inheritParentFile(
userdata: ?*anyopaque,
handle: File.Handle,
flags: File.Flags,
) Io.InheritParentHandleError!File {
const ev: *Evented = @ptrCast(@alignCast(userdata));
try inheritParentHandle(ev, handle);
return .{ .handle = handle, .flags = flags };
}
fn scanEnviron(ev: *Evented) Io.Cancelable!void {
const ev_io = ev.io();
try ev.environ_mutex.lock(ev_io);
defer ev.environ_mutex.unlock(ev_io);
if (ev.environ_initialized) return;
ev.environ.scan(ev.allocator());
ev.environ_initialized = true;
}
fn clockResolution(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.ResolutionError!Io.Duration {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
const clock_id = clockToPosix(clock);
var timespec: linux.timespec = undefined;
return switch (linux.errno(linux.clock_getres(clock_id, ×pec))) {
.SUCCESS => .fromNanoseconds(nanosecondsFromPosix(×pec)),
.INVAL => return error.ClockUnavailable,
else => |err| return unexpectedErrno(err),
};
}
fn now(userdata: ?*anyopaque, clock: Io.Clock) Io.Timestamp {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
var tp: linux.timespec = undefined;
switch (linux.errno(linux.clock_gettime(clockToPosix(clock), &tp))) {
.SUCCESS => return timestampFromPosix(&tp),
else => return .zero,
}
}
fn sleep(userdata: ?*anyopaque, timeout: Io.Timeout) Io.Cancelable!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const timespec: linux.kernel_timespec, const clock: Io.Clock, const timeout_flags: u32 = timespec: switch (timeout) {
.none => .{
.{
.sec = std.math.maxInt(i64),
.nsec = std.time.ns_per_s - 1,
},
.awake,
linux.IORING_TIMEOUT_ABS,
},
.duration => |duration| {
const ns = duration.raw.toNanoseconds();
break :timespec .{
.{
.sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
.nsec = @intCast(@mod(ns, std.time.ns_per_s)),
},
duration.clock,
0,
};
},
.deadline => |deadline| {
const ns = deadline.raw.toNanoseconds();
break :timespec .{
.{
.sec = @intCast(@divFloor(ns, std.time.ns_per_s)),
.nsec = @intCast(@mod(ns, std.time.ns_per_s)),
},
deadline.clock,
linux.IORING_TIMEOUT_ABS,
};
},
};
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .TIMEOUT,
.flags = 0,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = @intFromPtr(×pec),
.len = 1,
.rw_flags = timeout_flags | @as(u32, switch (clock) {
.real => linux.IORING_TIMEOUT_REALTIME,
else => 0,
.boot => linux.IORING_TIMEOUT_BOOTTIME,
}),
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
// 处理 SUCCESS、时钟不可用及意外错误。
// 用户在到达此处之前有机会检查时钟分辨率,
// 该检查会报告 0,因此这仍是合法的
// 休眠时长。
}
fn random(userdata: ?*anyopaque, buffer: []u8) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var thread: *Thread = .current();
if (!thread.csprng.isInitialized()) {
@branchHint(.unlikely);
var seed: [Csprng.seed_len]u8 = undefined;
{
const ev_io = ev.io();
ev.csprng_mutex.lockUncancelable(ev_io);
defer ev.csprng_mutex.unlock(ev_io);
if (!ev.csprng.isInitialized()) {
@branchHint(.unlikely);
var cancel_region: CancelRegion = .initBlocked();
defer cancel_region.deinit();
ev.urandomReadAll(&cancel_region, &seed) catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
else => fallbackSeed(ev, &seed),
};
ev.csprng.rng = .init(seed);
thread = .current();
}
ev.csprng.rng.fill(&seed);
}
if (!thread.csprng.isInitialized()) {
@branchHint(.likely);
thread.csprng.rng = .init(seed);
} else thread.csprng.rng.addEntropy(&seed);
}
thread.csprng.rng.fill(buffer);
}
fn randomSecure(userdata: ?*anyopaque, buffer: []u8) Io.RandomSecureError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
if (buffer.len == 0) return;
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
ev.urandomReadAll(&cancel_region, buffer) catch |err| switch (err) {
error.Canceled => |e| return e,
else => return error.EntropyUnavailable,
};
}
fn netListenIpUnavailable(
userdata: ?*anyopaque,
address: *const net.IpAddress,
options: net.IpAddress.ListenOptions,
) net.IpAddress.ListenError!net.Socket {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = address;
_ = options;
return error.NetworkDown;
}
fn netAcceptUnavailable(
userdata: ?*anyopaque,
listen_handle: net.Socket.Handle,
options: net.Server.AcceptOptions,
) net.Server.AcceptError!net.Socket {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = listen_handle;
_ = options;
return error.NetworkDown;
}
fn netBindIp(
userdata: ?*anyopaque,
address: *const net.IpAddress,
options: net.IpAddress.BindOptions,
) net.IpAddress.BindError!net.Socket {
const ev: *Evented = @ptrCast(@alignCast(userdata));
const family = posixAddressFamily(address);
var maybe_sync: CancelRegion.Sync.Maybe = .{ .cancel_region = .init() };
defer maybe_sync.deinit(ev);
const socket_fd = try ev.socket(&maybe_sync.cancel_region, family, options);
errdefer ev.closeAsync(socket_fd);
var storage: PosixAddress = undefined;
var addr_len = addressToPosix(address, &storage);
try ev.bind(&maybe_sync.cancel_region, socket_fd, &storage.any, addr_len);
if (options.allow_broadcast) try ev.setsockopt(&maybe_sync.cancel_region, socket_fd, linux.SOL.SOCKET, linux.SO.BROADCAST, 1);
try ev.getsockname(try maybe_sync.enterSync(ev), socket_fd, &storage.any, &addr_len);
return .{ .handle = socket_fd, .address = addressFromPosix(&storage) };
}
fn netConnectIpUnavailable(
userdata: ?*anyopaque,
address: *const net.IpAddress,
options: net.IpAddress.ConnectOptions,
) net.IpAddress.ConnectError!net.Socket {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = address;
_ = options;
return error.NetworkDown;
}
fn netListenUnixUnavailable(
userdata: ?*anyopaque,
address: *const net.UnixAddress,
options: net.UnixAddress.ListenOptions,
) net.UnixAddress.ListenError!net.Socket.Handle {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = address;
_ = options;
return error.AddressFamilyUnsupported;
}
fn netConnectUnixUnavailable(
userdata: ?*anyopaque,
address: *const net.UnixAddress,
) net.UnixAddress.ConnectError!net.Socket.Handle {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = address;
return error.AddressFamilyUnsupported;
}
fn netSocketCreatePairUnavailable(
userdata: ?*anyopaque,
options: net.Socket.CreatePairOptions,
) net.Socket.CreatePairError![2]net.Socket {
_ = userdata;
_ = options;
return error.OperationUnsupported;
}
fn netReceive(
ev: *Evented,
cancel_region: *CancelRegion,
handle: net.Socket.Handle,
message_buffer: []net.IncomingMessage,
data_buffer: []u8,
flags: net.ReceiveFlags,
) struct { ?net.Socket.ReceiveError, usize } {
var message_i: usize = 0;
var data_i: usize = 0;
while (true) {
if (message_buffer.len - message_i == 0) return .{ null, message_i };
const message = &message_buffer[message_i];
const remaining_data_buffer = data_buffer[data_i..];
var storage: PosixAddress = undefined;
var iov: iovec = .{ .base = remaining_data_buffer.ptr, .len = remaining_data_buffer.len };
var msg: linux.msghdr = .{
.name = &storage.any,
.namelen = @sizeOf(PosixAddress),
.iov = (&iov)[0..1],
.iovlen = 1,
.control = message.control.ptr,
.controllen = @intCast(message.control.len),
.flags = undefined,
};
const thread = cancel_region.awaitIoUring() catch |err| return .{ err, message_i };
thread.enqueue().* = .{
.opcode = .RECVMSG,
.flags = 0,
.ioprio = 0,
.fd = handle,
.off = 0,
.addr = @intFromPtr(&msg),
.len = 0,
.rw_flags = linux.MSG.NOSIGNAL |
@as(u32, if (flags.oob) linux.MSG.OOB else 0) |
@as(u32, if (flags.peek) linux.MSG.PEEK else 0) |
@as(u32, if (flags.trunc) linux.MSG.TRUNC else 0),
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
const completion = cancel_region.completion();
switch (completion.errno()) {
.SUCCESS => {
const data = remaining_data_buffer[0..@intCast(completion.result)];
data_i += data.len;
message.* = .{
.from = addressFromPosix(&storage),
.data = data,
.control = if (msg.control) |ptr| @as([*]u8, @ptrCast(ptr))[0..msg.controllen] else message.control,
.flags = .{
.eor = msg.flags & linux.MSG.EOR != 0,
.trunc = msg.flags & linux.MSG.TRUNC != 0,
.ctrunc = msg.flags & linux.MSG.CTRUNC != 0,
.oob = msg.flags & linux.MSG.OOB != 0,
.errqueue = msg.flags & linux.MSG.ERRQUEUE != 0,
},
};
message_i += 1;
continue;
},
.AGAIN => unreachable,
.INTR, .CANCELED => {},
.BADF => |err| return .{ errnoBug(err), message_i },
.NFILE => return .{ error.SystemFdQuotaExceeded, message_i },
.MFILE => return .{ error.ProcessFdQuotaExceeded, message_i },
.FAULT => |err| return .{ errnoBug(err), message_i },
.INVAL => |err| return .{ errnoBug(err), message_i },
.NOBUFS => return .{ error.SystemResources, message_i },
.NOMEM => return .{ error.SystemResources, message_i },
.NOTCONN => return .{ error.SocketUnconnected, message_i },
.NOTSOCK => |err| return .{ errnoBug(err), message_i },
.MSGSIZE => return .{ error.MessageOversize, message_i },
.PIPE => return .{ error.SocketUnconnected, message_i },
.OPNOTSUPP => |err| return .{ errnoBug(err), message_i },
.CONNRESET => return .{ error.ConnectionResetByPeer, message_i },
.TIMEDOUT => return .{ error.ConnectionTimedOut, message_i },
.NETDOWN => return .{ error.NetworkDown, message_i },
else => |err| return .{ unexpectedErrno(err), message_i },
}
}
}
fn netWriteFileUnavailable(
userdata: ?*anyopaque,
socket_handle: net.Socket.Handle,
header: []const u8,
file_reader: *File.Reader,
limit: Io.Limit,
) net.Stream.Writer.WriteFileError!usize {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = socket_handle;
_ = header;
_ = file_reader;
_ = limit;
return error.Unimplemented;
}
fn netClose(userdata: ?*anyopaque, sockets: []const net.Socket) void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
for (sockets) |sock| ev.close(sock.handle);
}
fn netShutdown(
userdata: ?*anyopaque,
handle: net.Socket.Handle,
how: net.ShutdownHow,
) net.ShutdownError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
var cancel_region: CancelRegion = .init();
defer cancel_region.deinit();
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .SHUTDOWN,
.flags = 0,
.ioprio = 0,
.fd = handle,
.off = 0,
.addr = 0,
.len = switch (how) {
.recv => linux.SHUT.RD,
.send => linux.SHUT.WR,
.both => linux.SHUT.RDWR,
},
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.BADF, .NOTSOCK, .INVAL => |err| return errnoBug(err),
.NOTCONN => return error.SocketUnconnected,
.NOBUFS => return error.SystemResources,
else => |err| return unexpectedErrno(err),
}
}
}
fn netInterfaceNameResolveUnavailable(
userdata: ?*anyopaque,
name: *const net.Interface.Name,
) net.Interface.Name.ResolveError!net.Interface {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = name;
return error.InterfaceNotFound;
}
fn netInterfaceNameUnavailable(
userdata: ?*anyopaque,
interface: net.Interface,
) net.Interface.NameError!net.Interface.Name {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = ev;
_ = interface;
return error.Unexpected;
}
fn netLookupUnavailable(
userdata: ?*anyopaque,
host_name: net.HostName,
resolved: *Io.Queue(net.HostName.LookupResult),
options: net.HostName.LookupOptions,
) net.HostName.LookupError!void {
const ev: *Evented = @ptrCast(@alignCast(userdata));
_ = host_name;
_ = options;
resolved.close(ev.io());
return error.NetworkDown;
}
fn bind(
ev: *Evented,
cancel_region: *CancelRegion,
socket_fd: fd_t,
addr: *const linux.sockaddr,
addr_len: linux.socklen_t,
) !void {
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .BIND,
.flags = 0,
.ioprio = 0,
.fd = socket_fd,
.off = addr_len,
.addr = @intFromPtr(addr),
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.ACCES => return error.AccessDenied,
.ADDRINUSE => return error.AddressInUse,
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.INVAL => |err| return errnoBug(err), // 无效参数
.NOTSOCK => |err| return errnoBug(err), // 无效的 `sockfd`
.AFNOSUPPORT => return error.AddressFamilyUnsupported,
.ADDRNOTAVAIL => return error.AddressUnavailable,
.FAULT => |err| return errnoBug(err), // 无效的 `addr` 指针
.NOMEM => return error.SystemResources,
else => |err| return unexpectedErrno(err),
}
}
}
fn chdir(sync: *CancelRegion.Sync, path: [*:0]const u8) ChdirError!void {
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.chdir(path))) {
.SUCCESS => return,
.INTR => {},
.ACCES => return error.AccessDenied,
.IO => return error.FileSystem,
.LOOP => return error.SymLinkLoop,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOMEM => return error.SystemResources,
.NOTDIR => return error.NotDir,
.ILSEQ => return error.BadPathName,
.FAULT => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn close(ev: *Evented, fd: fd_t) void {
var cancel_region: CancelRegion = .initBlocked();
defer cancel_region.deinit();
const thread = cancel_region.awaitIoUring() catch |err| switch (err) {
error.Canceled => unreachable, // 已阻塞
};
thread.enqueue().* = .{
.opcode = .CLOSE,
.flags = 0,
.ioprio = 0,
.fd = fd,
.off = 0,
.addr = 0,
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.BADF => recoverableOsBugDetected(), // 始终存在竞态条件。
.INTR => {}, // 这仍然是成功。参见 https://github.com/ziglang/zig/issues/2425
else => {},
}
}
fn closeAsync(ev: *Evented, fd: fd_t) void {
_ = ev;
const thread: *Thread = .current();
thread.enqueue().* = .{
.opcode = .CLOSE,
.flags = linux.IOSQE_CQE_SKIP_SUCCESS,
.ioprio = 0,
.fd = fd,
.off = 0,
.addr = 0,
.len = 0,
.rw_flags = 0,
.user_data = @backingInt(Completion.Userdata.close),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
}
fn fchdir(sync: *CancelRegion.Sync, dir: fd_t) process.SetCurrentDirError!void {
if (dir == linux.AT.FDCWD) return;
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.fchdir(dir))) {
.SUCCESS => return,
.INTR => {},
.ACCES => return error.AccessDenied,
.NOTDIR => return error.NotDir,
.IO => return error.FileSystem,
.BADF => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn fchmodat(
ev: *Evented,
sync: *CancelRegion.Sync,
dir: fd_t,
path: [*:0]const u8,
mode: linux.mode_t,
flags: u32,
) Dir.SetFilePermissionsError!void {
_ = ev;
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.fchmodat2(dir, path, mode, flags))) {
.SUCCESS => return,
.INTR => {},
.BADF => |err| return errnoBug(err),
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.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.OperationUnsupported,
.PERM => return error.PermissionDenied,
.ROFS => return error.ReadOnlyFileSystem,
else => |err| return unexpectedErrno(err),
}
}
}
fn fchownat(
ev: *Evented,
sync: *CancelRegion.Sync,
dir: fd_t,
path: [*:0]const u8,
owner: linux.uid_t,
group: linux.gid_t,
flags: u32,
) File.SetOwnerError!void {
_ = ev;
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.fchownat(dir, path, owner, group, flags))) {
.SUCCESS => return,
.INTR => {},
.BADF => |err| return errnoBug(err), // fd 很可能指向未设置 `Dir.OpenOptions.iterate` 打开的目录
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.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.PermissionDenied,
.ROFS => return error.ReadOnlyFileSystem,
else => |err| return unexpectedErrno(err),
}
}
}
fn flock(
ev: *Evented,
sync: *CancelRegion.Sync,
fd: fd_t,
op: File.Lock,
blocking: enum { blocking, nonblocking },
) (File.LockError || error{WouldBlock})!void {
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.flock(fd, LOCK.NB | @as(i32, switch (op) {
.none => LOCK.UN,
.shared => LOCK.SH,
.exclusive => LOCK.EX,
})))) {
.SUCCESS => return,
.INTR => {},
.BADF => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err), // 无效参数
.NOLCK => return error.SystemResources,
.AGAIN => {
const thread = try sync.cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .NOP,
.flags = 0,
.ioprio = 0,
.fd = 0,
.off = 0,
.addr = 0,
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(sync.cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (sync.cancel_region.errno()) {
.SUCCESS, .INTR, .CANCELED => {},
else => unreachable,
}
switch (blocking) {
.blocking => continue,
.nonblocking => return error.WouldBlock,
}
},
.OPNOTSUPP => return error.FileLocksUnsupported,
else => |err| return unexpectedErrno(err),
}
}
}
fn getsockname(
ev: *Evented,
sync: *CancelRegion.Sync,
socket_fd: fd_t,
addr: *linux.sockaddr,
addr_len: *linux.socklen_t,
) !void {
_ = ev;
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.getsockname(socket_fd, addr, addr_len))) {
.SUCCESS => return,
.INTR => {},
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err), // 无效参数
.NOTSOCK => |err| return errnoBug(err), // 始终存在竞态条件
.NOBUFS => return error.SystemResources,
else => |err| return unexpectedErrno(err),
}
}
}
fn linkat(
ev: *Evented,
cancel_region: *CancelRegion,
old_dir: fd_t,
old_path: [*:0]const u8,
new_dir: fd_t,
new_path: [*:0]const u8,
flags: u32,
) File.HardLinkError!void {
// 允许的标志:https://man7.org/linux/man-pages/man2/linkat.2.html
assert(flags & ~(@as(u32, linux.AT.SYMLINK_FOLLOW | linux.AT.EMPTY_PATH)) == 0);
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .LINKAT,
.flags = 0,
.ioprio = 0,
.fd = old_dir,
.off = @intFromPtr(new_path),
.addr = @intFromPtr(old_path),
.len = @bitCast(new_dir),
.rw_flags = flags,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.ACCES => return error.AccessDenied,
.DQUOT => return error.DiskQuota,
.EXIST => return error.PathAlreadyExists,
.IO => return error.HardwareFailure,
.LOOP => return error.SymLinkLoop,
.MLINK => return error.LinkQuotaExceeded,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOMEM => return error.SystemResources,
.NOSPC => return error.NoSpaceLeft,
.NOTDIR => return error.NotDir,
.PERM => return error.PermissionDenied,
.ROFS => return error.ReadOnlyFileSystem,
.XDEV => return error.CrossDevice,
.ILSEQ => return error.BadPathName,
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn lseek(
ev: *Evented,
sync: *CancelRegion.Sync,
fd: fd_t,
offset: u64,
whence: u32,
) File.SeekError!void {
_ = ev;
while (true) {
try sync.cancel_region.await(.nothing);
var result: u64 = undefined;
switch (linux.errno(switch (@sizeOf(usize)) {
else => comptime unreachable,
4 => linux.llseek(fd, offset, &result, whence),
8 => linux.lseek(fd, @bitCast(offset), whence),
})) {
.SUCCESS => return,
.INTR => {},
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.INVAL => return error.Unseekable,
.OVERFLOW => return error.Unseekable,
.SPIPE => return error.Unseekable,
.NXIO => return error.Unseekable,
else => |err| return unexpectedErrno(err),
}
}
}
fn openat(
ev: *Evented,
cancel_region: *CancelRegion,
dir: fd_t,
path: [*:0]const u8,
flags: linux.O,
mode: linux.mode_t,
) !fd_t {
var mut_flags = flags;
if (@hasField(linux.O, "LARGEFILE")) mut_flags.LARGEFILE = true;
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .OPENAT,
.flags = 0,
.ioprio = 0,
.fd = dir,
.off = 0,
.addr = @intFromPtr(path),
.len = mode,
.rw_flags = @bitCast(mut_flags),
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
const completion = cancel_region.completion();
switch (completion.errno()) {
.SUCCESS => return completion.result,
.INTR, .CANCELED => {},
.FAULT => |err| return errnoBug(err),
.INVAL => return error.BadPathName,
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.ACCES => return error.AccessDenied,
.FBIG => return error.FileTooBig,
.OVERFLOW => return error.FileTooBig,
.ISDIR => return error.IsDir,
.LOOP => return error.SymLinkLoop,
.MFILE => return error.ProcessFdQuotaExceeded,
.NAMETOOLONG => return error.NameTooLong,
.NFILE => return error.SystemFdQuotaExceeded,
.NODEV => return error.NoDevice,
.NOENT => return error.FileNotFound,
.SRCH => return error.FileNotFound, // Linux 打开 procfs 文件时。
.NOMEM => return error.SystemResources,
.NOSPC => return error.NoSpaceLeft,
.NOTDIR => return error.NotDir,
.PERM => return error.PermissionDenied,
.EXIST => return error.PathAlreadyExists,
.BUSY => return error.DeviceBusy,
// 文件锁定和 TMPFILE 可能触发此情况,但这两个标志互斥。
//
.OPNOTSUPP => return error.OperationUnsupported,
.AGAIN => return error.WouldBlock,
.TXTBSY => return error.FileBusy,
.NXIO => return error.NoDevice,
.ROFS => return error.ReadOnlyFileSystem,
.ILSEQ => return error.BadPathName,
else => |err| return unexpectedErrno(err),
}
}
}
fn preadv(
ev: *Evented,
cancel_region: *CancelRegion,
fd: fd_t,
iov: []const iovec,
offset: ?u64,
) File.Reader.Error!usize {
if (iov.len == 0) return 0;
const gather = iov.len > 1 or iov[0].len > 0xfffff000;
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = if (gather) .READV else .READ,
.flags = 0,
.ioprio = 0,
.fd = fd,
.off = offset orelse std.math.maxInt(u64),
.addr = if (gather) @intFromPtr(iov.ptr) else @intFromPtr(iov[0].base),
.len = @intCast(if (gather) iov.len else iov[0].len),
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
const completion = cancel_region.completion();
switch (completion.errno()) {
.SUCCESS => return @as(u32, @bitCast(completion.result)),
.INTR, .CANCELED => {},
.INVAL => |err| return errnoBug(err),
.FAULT => |err| return errnoBug(err),
.AGAIN => return error.WouldBlock,
.BADF => |err| return errnoBug(err), // 关闭后仍使用文件描述符
.IO => return error.InputOutput,
.ISDIR => return error.IsDir,
.NOBUFS => return error.SystemResources,
.NOMEM => return error.SystemResources,
.NOTCONN => return error.SocketUnconnected,
.CONNRESET => return error.ConnectionResetByPeer,
else => |err| return unexpectedErrno(err),
}
}
}
fn pwritev(
ev: *Evented,
cancel_region: *CancelRegion,
fd: fd_t,
iov: []const iovec_const,
offset: ?u64,
) File.Writer.Error!usize {
if (iov.len == 0) return 0;
const scatter = iov.len > 1 or iov[0].len > 0xfffff000;
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = if (scatter) .WRITEV else .WRITE,
.flags = 0,
.ioprio = 0,
.fd = fd,
.off = offset orelse std.math.maxInt(u64),
.addr = if (scatter) @intFromPtr(iov.ptr) else @intFromPtr(iov[0].base),
.len = @intCast(if (scatter) iov.len else iov[0].len),
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
const completion = cancel_region.completion();
switch (completion.errno()) {
.SUCCESS => return @as(u32, @bitCast(completion.result)),
.INTR, .CANCELED => {},
.INVAL => |err| return errnoBug(err),
.FAULT => |err| return errnoBug(err),
.AGAIN => return error.WouldBlock,
.BADF => return error.NotOpenForWriting, // 可能存在竞态条件。
.DESTADDRREQ => |err| return errnoBug(err), // 从未调用 `connect`。
.DQUOT => return error.DiskQuota,
.FBIG => return error.FileTooBig,
.IO => return error.InputOutput,
.NOSPC => return error.NoSpaceLeft,
.PERM => return error.PermissionDenied,
.PIPE => return error.BrokenPipe,
.CONNRESET => |err| return errnoBug(err), // 不是套接字句柄。
.BUSY => return error.DeviceBusy,
else => |err| return unexpectedErrno(err),
}
}
}
fn readAll(
ev: *Evented,
cancel_region: *CancelRegion,
fd: fd_t,
buffer: []u8,
) (File.Reader.Error || error{EndOfStream})!void {
var index: usize = 0;
while (buffer.len - index != 0) {
const len = try ev.preadv(cancel_region, fd, &.{
.{ .base = buffer[index..].ptr, .len = buffer.len - index },
}, null);
if (len == 0) return error.EndOfStream;
index += len;
}
}
fn realPath(
ev: *Evented,
sync: *CancelRegion.Sync,
fd: fd_t,
out_buffer: []u8,
) File.RealPathError!usize {
_ = ev;
var procfs_buf: [std.fmt.count("/proc/self/fd/{d}\x00", .{std.math.minInt(fd_t)})]u8 = undefined;
const proc_path = std.mem.printSentinel(&procfs_buf, "/proc/self/fd/{d}", .{fd}, 0) catch
unreachable;
while (true) {
try sync.cancel_region.await(.nothing);
const rc = linux.readlink(proc_path, out_buffer.ptr, out_buffer.len);
switch (linux.errno(rc)) {
.SUCCESS => return rc,
.INTR => {},
.ACCES => return error.AccessDenied,
.FAULT => |err| return errnoBug(err),
.IO => return error.FileSystem,
.LOOP => return error.SymLinkLoop,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOMEM => return error.SystemResources,
.NOTDIR => return error.NotDir,
.ILSEQ => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn renameat(
ev: *Evented,
cancel_region: *CancelRegion,
old_dir: fd_t,
old_path: [*:0]const u8,
new_dir: fd_t,
new_path: [*:0]const u8,
flags: linux.RENAME,
) Dir.RenameError!void {
while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .RENAMEAT,
.flags = 0,
.ioprio = 0,
.fd = old_dir,
.off = @intFromPtr(new_path),
.addr = @intFromPtr(old_path),
.len = @bitCast(new_dir),
.rw_flags = @bitCast(flags),
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.ACCES => return error.AccessDenied,
.PERM => return error.PermissionDenied,
.BUSY => return error.FileBusy,
.DQUOT => return error.DiskQuota,
.ISDIR => return error.IsDir,
.IO => return error.HardwareFailure,
.LOOP => return error.SymLinkLoop,
.MLINK => return error.LinkQuotaExceeded,
.NAMETOOLONG => return error.NameTooLong,
.NOENT => return error.FileNotFound,
.NOTDIR => return error.NotDir,
.NOMEM => return error.SystemResources,
.NOSPC => return error.NoSpaceLeft,
.EXIST => return error.DirNotEmpty,
.NOTEMPTY => return error.DirNotEmpty,
.ROFS => return error.ReadOnlyFileSystem,
.XDEV => return error.CrossDevice,
.ILSEQ => return error.BadPathName,
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn setsockopt(
ev: *Evented,
cancel_region: *CancelRegion,
fd: fd_t,
level: i32,
opt_name: u32,
option: u32,
) !void {
const o: []const u8 = @ptrCast(&option);
while (true) {
const off: extern struct {
cmd_op: linux.IO_URING_SOCKET_OP,
pad: u32,
} align(@alignOf(u64)) = .{
.cmd_op = .SETSOCKOPT,
.pad = 0,
};
const addr: extern struct { level: i32, opt_name: u32 } align(@alignOf(u64)) = .{
.level = level,
.opt_name = opt_name,
};
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .URING_CMD,
.flags = 0,
.ioprio = 0,
.fd = fd,
.off = @as(*const u64, @ptrCast(&off)).*,
.addr = @as(*const u64, @ptrCast(&addr)).*,
.len = 0,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = @intCast(o.len),
.addr3 = @intFromPtr(o.ptr),
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return,
.INTR, .CANCELED => {},
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.NOTSOCK => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.FAULT => |err| return errnoBug(err),
else => |err| return unexpectedErrno(err),
}
}
}
fn socket(
ev: *Evented,
cancel_region: *CancelRegion,
family: linux.sa_family_t,
options: net.IpAddress.BindOptions,
) error{
AddressFamilyUnsupported,
ProtocolUnsupportedBySystem,
ProcessFdQuotaExceeded,
SystemFdQuotaExceeded,
SystemResources,
ProtocolUnsupportedByAddressFamily,
SocketModeUnsupported,
OptionUnsupported,
Unexpected,
Canceled,
}!fd_t {
const mode, const protocol = try posixSocketModeProtocol(family, options.mode, options.protocol);
const socket_fd = while (true) {
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .SOCKET,
.flags = 0,
.ioprio = 0,
.fd = family,
.off = mode | linux.SOCK.CLOEXEC,
.addr = 0,
.len = protocol,
.rw_flags = 0,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
const completion = cancel_region.completion();
switch (completion.errno()) {
.SUCCESS => break completion.result,
.INTR, .CANCELED => {},
.AFNOSUPPORT => return error.AddressFamilyUnsupported,
.INVAL => return error.ProtocolUnsupportedBySystem,
.MFILE => return error.ProcessFdQuotaExceeded,
.NFILE => return error.SystemFdQuotaExceeded,
.NOBUFS => return error.SystemResources,
.NOMEM => return error.SystemResources,
.PROTONOSUPPORT => return error.ProtocolUnsupportedByAddressFamily,
.PROTOTYPE => return error.SocketModeUnsupported,
else => |err| return unexpectedErrno(err),
}
};
errdefer ev.closeAsync(socket_fd);
if (options.ip6_only) |ip6_only| {
if (linux.IPV6 == void) return error.OptionUnsupported;
try ev.setsockopt(cancel_region, socket_fd, linux.IPPROTO.IPV6, linux.IPV6.V6ONLY, @intFromBool(ip6_only));
}
return socket_fd;
}
fn stat(ev: *Evented, cancel_region: *CancelRegion, fd: fd_t) Dir.StatError!Dir.Stat {
return ev.statx(cancel_region, fd, "", linux.AT.EMPTY_PATH) catch |err| switch (err) {
error.BadPathName, error.NameTooLong => unreachable, // 路径为空
error.AccessDenied => return errnoBug(.ACCES),
error.SymLinkLoop => return errnoBug(.LOOP),
error.FileNotFound => return errnoBug(.NOENT),
error.NotDir => return errnoBug(.NOTDIR),
else => |e| return e,
};
}
fn statx(
ev: *Evented,
cancel_region: *CancelRegion,
dir: fd_t,
path: [*:0]const u8,
flags: u32,
) (Dir.StatError || Dir.PathNameError || error{ FileNotFound, NotDir, SymLinkLoop })!Dir.Stat {
while (true) {
var statx_buf = std.mem.zeroes(linux.Statx);
const thread = try cancel_region.awaitIoUring();
thread.enqueue().* = .{
.opcode = .STATX,
.flags = 0,
.ioprio = 0,
.fd = dir,
.off = @intFromPtr(&statx_buf),
.addr = @intFromPtr(path),
.len = @bitCast(linux_statx_request),
.rw_flags = flags,
.user_data = @intFromPtr(cancel_region.fiber),
.buf_index = 0,
.personality = 0,
.splice_fd_in = 0,
.addr3 = 0,
.resv = 0,
};
ev.yield(null, .nothing);
switch (cancel_region.errno()) {
.SUCCESS => return statFromLinux(&statx_buf),
.INTR, .CANCELED => {},
.ACCES => return error.AccessDenied,
.BADF => |err| return errnoBug(err), // 文件描述符在关闭后被使用。
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.LOOP => return error.SymLinkLoop,
.NAMETOOLONG => |err| return errnoBug(err),
.NOENT => return error.FileNotFound,
.NOTDIR => return error.NotDir,
.NOMEM => return error.SystemResources,
else => |err| return unexpectedErrno(err),
}
}
}
fn urandomReadAll(
ev: *Evented,
cancel_region: *CancelRegion,
buffer: []u8,
) (File.OpenError || File.Reader.Error || error{EndOfStream})!void {
return ev.readAll(cancel_region, try ev.random_fd.open(ev, cancel_region, "/dev/urandom", .{
.ACCMODE = .RDONLY,
.CLOEXEC = true,
}), buffer);
}
fn utimensat(
ev: *Evented,
sync: *CancelRegion.Sync,
dir: fd_t,
path: [*:0]const u8,
times: ?*const [2]linux.timespec,
flags: u32,
) File.SetTimestampsError!void {
_ = ev;
while (true) {
try sync.cancel_region.await(.nothing);
switch (linux.errno(linux.utimensat(dir, path, times, flags))) {
.SUCCESS => return,
.INTR => {},
.BADF => |err| return errnoBug(err), // 始终存在竞态条件
.FAULT => |err| return errnoBug(err),
.INVAL => |err| return errnoBug(err),
.ACCES => return error.AccessDenied,
.PERM => return error.PermissionDenied,
.ROFS => return error.ReadOnlyFileSystem,
else => |err| return unexpectedErrno(err),
}
}
}
fn writeAllSync(sync: *CancelRegion.Sync, fd: fd_t, buffer: []const u8) File.Writer.Error!void {
var index: usize = 0;
while (buffer.len - index != 0) index += try writeSync(sync, fd, buffer[index..]);
}
fn writeSync(sync: *CancelRegion.Sync, fd: fd_t, buffer: []const u8) File.Writer.Error!usize {
while (true) {
try sync.cancel_region.await(.nothing);
const rc = linux.write(fd, buffer.ptr, buffer.len);
switch (linux.errno(rc)) {
.SUCCESS => return @intCast(rc),
.INTR => {},
.INVAL => |err| return errnoBug(err),
.FAULT => |err| return errnoBug(err),
.AGAIN => return error.WouldBlock,
.BADF => return error.NotOpenForWriting, // 可能存在竞态条件。
.DESTADDRREQ => |err| return errnoBug(err), // 从未调用 `connect`。
.DQUOT => return error.DiskQuota,
.FBIG => return error.FileTooBig,
.IO => return error.InputOutput,
.NOSPC => return error.NoSpaceLeft,
.PERM => return error.PermissionDenied,
.PIPE => return error.BrokenPipe,
.CONNRESET => |err| return errnoBug(err), // 不是套接字句柄。
.BUSY => return error.DeviceBusy,
else => |err| return unexpectedErrno(err),
}
}
}
test {
_ = Fiber.CancelProtection;
}