Compare commits

...
203 Commits
Author SHA1 Message Date
Jonathan Flat f325ebf78f Merge pull request #391 from jrflat/improve-csystem-import-handling-v2
Improve CSystem import handling
2026-10-16 15:24:40 -06:00
Jonathan Flat 4179b2cce5 Remove CSystemFreeBSD.h, too 2026-10-12 19:39:54 -06:00
Jonathan Flat f5fe750a57 Improve CSystem import handling 2026-10-12 19:39:51 -06:00
Guillaume Lessard b0d4217c8c [ci] update github actions (#389)
* [ci] update version of workflows dependencies
2026-09-25 14:58:42 -07:00
Aryan Singh K.andGuillaume Lessard 869129b7bf fix(MachPort): silence concurrency check for mach_task_self_ (#379)
Darwin.Mach's mach_task_self_ is a shared global; Swift 6.3
reports it as not concurrency-safe when imported. Use a
preconcurrency import for older Darwin SDKs.

Fixes #373

Co-authored-by: Guillaume Lessard <guillaume.lessard@apple.com>
2026-08-13 12:54:10 -07:00
Aryan Singh K. 5c2854d7bd fix(wasi): use mock TLS for all non-threaded WASI targets (#378)
The gate os(WASI) && (swift(<6.1) || !_runtime) incorrectly falls
through to pthread APIs on Swift 6.1+ non-threaded WASI, where
pthread_* is not in scope. Guard solely on !_runtime.

Fixes #370
2026-08-12 11:08:01 -07:00
Guillaume Lessard d0ef8d091d [readme] update for 1.8.x branch 2026-08-11 13:46:15 -07:00
Guillaume Lessard 704705c5c5 Merge pull request #369 from apple/dev/swift6-language-mode
Enable Swift 6 language mode
2026-08-04 09:13:02 -07:00
Guillaume Lessard 16cfbd4f8b Enable Swift 6 language mode 2026-07-30 07:33:23 -07:00
Guillaume Lessard 755a5b4b3d Merge pull request #367 from apple/dev/linux-import-issue
Prepare for Swift 6 language mode
2026-07-30 07:18:05 -07:00
Guillaume Lessard 6485260369 [Windows] use Atomic to protect the backing store of umask() 2026-07-29 19:41:17 -07:00
Guillaume Lessard d4e86324e9 Add availability macro support to CMake build
For now this heplfully silences warnings.
2026-07-29 19:41:17 -07:00
Guillaume Lessard 29b14a3025 Concurrency tweak for single-thread wasm 2026-07-29 19:41:17 -07:00
Guillaume Lessard 6a63f086f6 Merge branch 'release/1.7.0' into main
# Conflicts:
#	Tests/SystemTests/FileOperationsTest.swift
2026-07-29 18:12:22 -07:00
Guillaume Lessard b9e0ecaa60 [linux] remove @_implementationOnly import qualifiers 2026-07-29 09:28:38 -07:00
Guillaume Lessard 8ac955bde7 Merge pull request #365 from apple/dev/fix-imports 2026-07-28 12:47:38 -07:00
Guillaume Lessard 617edb8398 Move an import
In all other cases, the `import CSystem` happens before the platform-specific import. This makes this detail consistent.
2026-07-28 10:28:06 -07:00
Guillaume Lessard 5db65c3086 Add an explicit import
Necessary to use `timespec` in Swift 6 mode.
2026-07-28 10:27:25 -07:00
Guillaume Lessard 2159235ef0 Merge pull request #363 from apple/dev/tweaks-just-gardening
[gardening] some corrections
2026-07-27 17:08:17 -07:00
Guillaume Lessard 353a48d98d Correct a doc-comment 2026-07-27 12:43:15 -07:00
Guillaume Lessard aa7ed87b5f Correct a copyright notice 2026-07-27 12:43:15 -07:00
Guillaume Lessard 73067f8221 Availability annotation tweaks 2026-07-27 11:57:38 -07:00
Guillaume Lessard a352b4c224 Improve test timing for Android targets 2026-07-22 11:22:27 -07:00
Guillaume Lessard cd18a372c0 Implement dup3/pipe2 wrappers and types for Darwin 2026-07-22 11:10:19 -07:00
Guillaume Lessard 0d9e29baa0 Fix some doc-comments 2026-07-22 11:01:56 -07:00
Guillaume Lessard 4966bcbf8b Further clarifications 2026-07-22 11:01:56 -07:00
Guillaume Lessard 71be76265f Proposal typo fixes 2026-07-22 11:01:56 -07:00
Guillaume Lessard 90a174256e Revise 0007-FileDescriptor-dup3-pipe2.md 2026-07-22 11:01:56 -07:00
Guillaume Lessard a9597cc068 Merge branch 'release/1.7.0' into main 2026-07-21 10:25:33 -07:00
Jonathan Flat 50688cacbd Update Stat.generationNumber to UInt64 2026-07-21 10:07:16 -07:00
Jonathan Flat bd155c104f Enable FreeBSD checks 2026-07-21 10:06:51 -07:00
Jonathan Flat 52930bf6be Merge pull request #355 from jrflat/stat-equality
Don't compare padding/reserved fields for `Stat` equality
2026-07-20 16:55:53 -06:00
Jonathan Flat 7c072c0d97 Hash the same fields compared by ==
From the `hash(into:)` docs: "The components used for hashing must be the same as the components compared in your type’s == operator implementation."
2026-07-20 13:30:27 -06:00
Jonathan Flat 5d61ccdc7e Remove @_alwaysEmitIntoClient from == and hash(into:)
The implementations of these functions are non-trivial, so remove the annotation to reduce client code size.
2026-07-20 11:48:41 -06:00
Jonathan Flat 2b266acf85 Don't compare padding/reserved fields for Stat equality 2026-07-17 15:15:09 -06:00
Guillaume Lessard 101cc809ba Merge branch 'release/1.6.0' into ‘release/1.7.0’ 2026-07-16 13:19:29 -07:00
Guillaume Lessard 0b30161977 Merge branch 'release/1.5.0' into ‘release/1.6.0’ 2026-07-16 13:02:41 -07:00
Guillaume Lessard b349ff8c05 Update pull request workflow 2026-07-16 12:41:01 -07:00
Guillaume Lessard 7cb32eb7a4 Cherry-pick: remove unnecessary type casting
The compiler now imports these as their canonical type, allowing us to directly use without the explicit type cast. Due to the floor of Swift 6.3, we must preserve the type cast values. Introduce an overlay to explicitly cast the values in the older compilers.

Cherry-pick of #308
2026-07-16 10:21:23 -07:00
Guillaume Lessard a6515006f5 Adjust availability macro 2026-07-13 10:56:30 -07:00
Guillaume Lessard 7edc09a749 Remove an accidental throw annotation 2026-07-13 10:56:05 -07:00
Guillaume Lessard 03604ffcd9 Use typed error instead of rethrows 2026-07-13 10:40:41 -07:00
Guillaume Lessard 2d0912acba Specify some omitted error types 2026-07-13 10:40:41 -07:00
Owen Voorhees 16cdb0d008 Set -package-name in CMake build 2026-07-10 17:03:44 -07:00
Guillaume Lessard e2ae946862 Merge branch 'release/1.7.0' 2026-07-09 12:55:43 -07:00
Guillaume LessardandJonathan Flat f05c1d815d [ci] improve cmake-checking script
Co-authored-by: Jonathan Flat <jflat@apple.com>
2026-07-09 12:54:49 -07:00
Guillaume Lessard 0601f0edec [ci] validate cmake build on Linux 2026-07-09 12:54:49 -07:00
Guillaume Lessard a10991ab88 Fix a test flakiness issue
These timestamps are frequently equal on Android, causing spurious failures.
2026-07-09 09:03:39 -07:00
Guillaume Lessard b5544ba79a Merge pull request #338 from apple/dev/cmake-again
Fix cmake configuration
2026-07-07 16:40:41 -07:00
Guillaume Lessard dda389ed2b Fix cmake configuration 2026-07-07 16:23:09 -07:00
Guillaume Lessard d3c632e868 Merge branch 'release/1.7.0' 2026-07-07 11:26:07 -07:00
Guillaume Lessard 326260ee3b Merge pull request #332 from finagolfin/patch-1
Update CI to latest version of official workflows
2026-07-07 11:24:24 -07:00
Guillaume Lessard d5f004e6f1 Merge pull request #328 from 3405691582/invisible
Don't define __BSD_VISIBLE on OpenBSD.
2026-07-07 11:18:28 -07:00
Guillaume Lessard 38cd4aaf65 Merge pull request #336 from glessard/ioring-syscall-wrappers
Improve syscall wrappers for IORing
2026-07-07 10:11:37 -07:00
Minh Vu 41de235573 Add missing System CMake sources (#325) 2026-07-07 10:34:42 -06:00
Guillaume Lessard efc401eb32 Add testing of throwing behaviour 2026-07-06 14:11:32 -07:00
Guillaume Lessard 73da907161 improve Errno handling for io_uring_register 2026-07-06 14:11:32 -07:00
Guillaume Lessard 124e17164c improve Errno handling for io_uring_enter 2026-07-06 14:11:32 -07:00
Guillaume Lessard d7ca4a9e4c improve Errno handling for io_uring_enter2 2026-07-06 14:11:32 -07:00
Guillaume Lessard 4a55025558 Merge pull request #335 from apple/dev/windows-closeOnExec-1.7.x 2026-07-06 13:17:19 -07:00
Guillaume Lessard 8771bb6199 Add test of OpenOptions.closeOnExec for Windows 2026-07-06 13:15:48 -07:00
Jake Petroules e927959165 Enable .closeOnExec for FileDescriptor.open on Windows
Make OpenOptions.closeOnExec available on Windows, where it maps to
_O_CLOEXEC (O_NOINHERIT). The Windows open adapter already decodes
O_NOINHERIT into a non-inheritable handle, so this produces the
expected close-on-exec semantics. Also add the deprecated O_NOINHERIT
alias, matching the PipeOptions treatment from #312.
2026-07-06 13:15:48 -07:00
Guillaume Lessard f52438c1b8 Merge pull request #334 from apple/dev/workflows-update
[1.7.x] Update CI to latest version of official workflows
2026-07-06 12:37:04 -07:00
finagolfin 636e14a3d2 Update CI to latest version of official workflows 2026-07-06 12:11:05 -07:00
Guillaume Lessard 7c504cabbf Exclude unavailable combinations 2026-07-06 12:07:58 -07:00
Guillaume Lessard 0b7fc03c76 Add test of OpenOptions.closeOnExec for Windows 2026-07-06 11:44:36 -07:00
Jake Petroules a7e7c56fec Enable .closeOnExec for FileDescriptor.open on Windows
Make OpenOptions.closeOnExec available on Windows, where it maps to
_O_CLOEXEC (O_NOINHERIT). The Windows open adapter already decodes
O_NOINHERIT into a non-inheritable handle, so this produces the
expected close-on-exec semantics. Also add the deprecated O_NOINHERIT
alias, matching the PipeOptions treatment from #312.
2026-07-06 11:02:51 -07:00
finagolfin c124911240 Update CI to latest version of official workflows 2026-07-03 11:45:09 +05:30
Guillaume Lessard a17caca7af Merge pull request #329 from glessard/fix-ioring-blockingConsumeCompletion
Test ioring's blocking consume completion with timeout
2026-07-01 16:47:17 -07:00
Guillaume Lessard 1cfd5105b2 [gardening] remove a forgotten print statement 2026-06-27 11:24:37 -07:00
Guillaume Lessard 76a2dc6162 Improve _blockingConsumeCompletionGuts 2026-06-27 11:24:37 -07:00
Guillaume Lessard e0aa78a944 Test for an implementation bug 2026-06-27 11:24:36 -07:00
Guillaume Lessard 1494bb89fc Change the io_uring existence macros to integer values
`true` and `false` import differently with C23 than before, so the swift-side test `(__SWIFT_IORING_SUPPORTED != 0)` became dependent on the toolchain. Integer constants are more reliable for this.
2026-06-26 17:10:10 -07:00
Guillaume Lessard e358151f96 Improve existence/enablement test for io_uring 2026-06-26 17:10:10 -07:00
Guillaume Lessard e7723528a1 Apply suggestions from code review
Refactor conditional compilation blocks

Co-authored-by: Guillaume Lessard <glessard@tffenterprises.com>
2026-06-26 16:15:53 -07:00
Minh Vu 58bce128ce Forward io_uring_enter2 size argument (#326) 2026-06-25 19:54:56 -07:00
3405691582 5b670937e3 Don't define __BSD_VISIBLE on OpenBSD.
This causes a compilation error because OpenBSD headers that refer to
this aren't `#ifdef` but `#if`, so the define must have a value.

This doesn't actually seem to be necessary on OpenBSD, so let's just
remove it on OpenBSD.
2026-06-25 20:44:48 -04:00
Jonathan Flat 74bc402c95 Add Android to MemberImportVisibility test probe (#327) 2026-06-16 10:00:21 -06:00
Guillaume Lessard 96c5f3b852 Merge branch 'release/1.7.0' into dev/mergeback-1.7.x 2026-06-13 09:18:51 -07:00
Minh Vu 776989a955 Install missing CSystem headers (#323) 2026-06-13 09:09:41 -07:00
Aditya Singh 671bd1a573 Replace precondition with fatalError for missing permissions on .create (#307)
FileDescriptor.open traps when options contains .create but permissions
is nil. The previous precondition could elide its message in optimized
builds, leaving users to hunt through source to diagnose the crash.
Use fatalError with a descriptive message so the reason is always
present in the crash dump, and document the trapping behavior.

Fixes #78
2026-06-12 17:12:22 -07:00
Guillaume Lessard 69ba2cd76e Merge pull request #315 from apple/dev/mergeback-1.7.x
Merge forward from release/1.7.0
2026-06-12 17:08:34 -07:00
Sarunas ede51c41cb fix: build with MemberImportVisibility 2026-06-12 16:35:26 -07:00
Guillaume Lessard 64545cfc87 Merge branch 'release/1.7.0' into mergeback-1.7.x 2026-06-12 15:30:38 -07:00
Guillaume Lessard 7502b711c9 Update README to indicate 1.7.x is the latest version 2026-06-12 15:29:47 -07:00
Guillaume Lessard abcf8e31b3 Merge pull request #321 from apple/dev/member-visibility-build-1.7.x
[1.7.0] Fix package build with MemberImportVisibility enabled
2026-06-12 15:22:05 -07:00
Jonathan Flat 0a3460f369 [1.7.0] Fix Stat MemberImportVisibility regression and add test (#320)
* Fix Stat MemberImportVisibility regression and add test

* Remove Android from the MIV test
2026-06-12 18:21:14 -04:00
Sarunas c50ad26d06 fix: build with MemberImportVisibility 2026-06-12 15:00:50 -07:00
Guillaume Lessard 666fba77fc Merge pull request #319 from kkebo/fix-freebsd-closeOnFork
Fix missing `O_CLOFORK` on older FreeBSD
2026-06-12 09:26:30 -07:00
Kenta Kubo 360e6f70f0 Fix missing O_CLOFORK on older FreeBSD 2026-06-12 22:31:04 +09:00
Guillaume Lessard e402d5fa38 Merge pull request #314 from apple/dev/typecast-1.7.x
System: remove unnecessary type casting
2026-06-11 13:50:16 -07:00
Guillaume Lessard 1bd796b6b9 Merge pull request #312 from glessard/pipe2-windows
Add `pipe(options:)` for Windows
2026-06-11 13:39:28 -07:00
Saleem Abdulrasool 7e888c0cb4 System: remove unnecessary type casting
The compiler now imports these as their canonical type, allowing us to
directly use without the explicit type cast. Due to the floor of Swift
6.3, we must preserve the type cast values. Introduce an overlay to
explicitly cast the values in the older compilers.
2026-06-11 13:37:29 -07:00
Guillaume Lessard d937d15735 Add clarifications to the doc-comments of the new overloads. 2026-06-11 13:22:29 -07:00
Saleem Abdulrasool 8af20f00ab Merge pull request #308 from compnerd/typecast
System: remove unnecessary type casting
2026-06-11 13:16:39 -07:00
Saleem Abdulrasool 9a8bef12be System: remove unnecessary type casting
The compiler now imports these as their canonical type, allowing us to
directly use without the explicit type cast. Due to the floor of Swift
6.3, we must preserve the type cast values. Introduce an overlay to
explicitly cast the values in the older compilers.
2026-06-11 09:29:01 -07:00
Guillaume Lessard e60d362ada fix typo 2026-06-10 10:44:38 -07:00
Guillaume Lessard b7b66845da Update proposal with Windows change 2026-06-10 10:27:45 -07:00
Guillaume Lessard 4fdc665a0f Compile out testAdHocDuplicate2 on Windows 2026-06-09 16:39:56 -07:00
Guillaume Lessard 3e0b318176 Add a test for pipe2 2026-06-09 16:27:18 -07:00
Guillaume Lessard a2bc5f0625 Add tests specific to dup2 and dup3 2026-06-09 16:27:18 -07:00
Guillaume Lessard 2cc89c12b3 Defer pipe buffering decision to the OS on Windows 2026-06-09 16:27:18 -07:00
Guillaume Lessard e59002fa14 Add option-taking pipe() implementation for Windows 2026-06-09 16:27:18 -07:00
Guillaume Lessard ebbbc31709 Merge pull request #310 from apple/release/1.6.0 2026-06-05 17:37:50 -07:00
Guillaume Lessard c6cc06d24d Merge pull request #306 from kkebo/enable-freebsd-ci
[CI] Enable FreeBSD testing
2026-06-05 15:06:13 -07:00
David Smith 669763cfd5 Merge pull request #309 from apple/david/ioring-crash-fix
Fix a crash when work is interleaved between prepare and submit in IORing
2026-06-04 16:38:10 -07:00
David Smith 6fa5c8a6c1 Explain why this is a class 2026-06-04 16:05:44 -07:00
David Smith 2cae953181 Fix a crash when work is interleaved between prepare and submit in IORing 2026-06-04 16:05:28 -07:00
Guillaume Lessard 03453849a2 Merge pull request #274 from glessard/dup3-pipe2-proposal
Proposal to add wrappers for `dup3` and `pipe2`
2026-06-02 09:26:20 -07:00
Guillaume Lessard 0d7feaa50c Merge pull request #303 from apple/dup3-pipe2
[SYS-0007] Add overloads to cover dup3 and pipe2 POSIX APIs
2026-06-01 16:02:18 -07:00
Jonathan Flat 34f4970c1c Build CSystem as a static library in CMake so shims.c is compiled 2026-05-29 12:48:43 -06:00
Kenta Kubo 2986958695 [CI] Enable FreeBSD testing 2026-05-28 15:04:49 +09:00
Guillaume Lessard 30d09ac188 Merge pull request #305 from glessard/github-actions-refresh
[ci] update workflows library to a recent version
2026-05-27 19:32:52 -07:00
Guillaume Lessard 686feb3a39 [ci] update workflows library to latest version 2026-05-26 17:30:12 -07:00
Guillaume Lessard 56dad9d66e [ci] update workflows library to latest version 2026-05-26 17:16:41 -07:00
Guillaume Lessard 929b835515 Merge pull request #304 from apple/dev/github-actions-refresh
[ci] update workflows library to a recent version
2026-05-26 17:10:03 -07:00
Guillaume Lessard 26f8c4f195 [ci] update workflows library to latest version 2026-05-26 16:53:38 -07:00
Guillaume Lessard de8779fb3d Update copyright headers 2026-05-26 16:21:28 -07:00
Guillaume Lessard 491b97c7c0 Complete implementation of SYS-0007 2026-05-20 10:01:11 -07:00
Guillaume Lessard 814d09c7ea Improve doc-comments 2026-05-20 09:58:46 -07:00
Guillaume Lessard 61280ab365 Fix declaration inconsistencies 2026-05-20 09:58:46 -07:00
Guillaume Lessard cc4afd1a71 Fix types of new static members of option sets 2026-05-20 09:58:46 -07:00
Jake Petroules 348b497836 Add overloads to cover dup3 and pipe2 POSIX APIs
This follows the existing pattern of wrapping dup/dup2 and pipe with FileDescriptor.duplicate and FileDescriptor.pipe, with additional overloads for passing the O_CLOEXEC and similar flags.
2026-05-20 09:58:46 -07:00
Guillaume Lessard 0323dff7db Rephrase using active voice 2026-05-19 18:40:04 -07:00
Guillaume Lessard 4d2c21f6b3 fix a few more inconsistencies 2026-05-19 18:39:02 -07:00
Guillaume Lessard 45e26e7cc1 Merge pull request #278 from glessard/dev/require-swift-6.1
Require Swift 6.1 for the upcoming 1.7.0 tag
2026-03-23 13:41:34 -07:00
Guillaume Lessard 9554473133 Merge pull request #301 from glessard/dev/typo-fix
Fix typo: remove extra space after comma
2026-03-10 15:40:02 -07:00
Guillaume Lessard c0fa05b225 fix typo in Stat proposal
Cherry-picked from commit 9ddcf9a051
Co-authored-by: Layla <0x04cb@gmail.com>
2026-03-03 10:54:26 -08:00
Jonathan Flat 51d396093d [Implementation] Back-deploy CInterop.stat for Migration Compatibility (#299) 2026-03-02 18:17:36 -07:00
Jonathan Flat 6d25d11066 [Proposal] Back-deploy CInterop.stat for Migration Compatibility (#298)
* [Proposal] Back-deploy CInterop.stat for Migration Compatibility

* Update implementation and pitch links

* v2/3: Clarify that CInterop.stat(_:_:) is a new function and why this proposal should not set a precedence for future System APIs

* Rename to SYS-0008
2026-03-02 18:15:49 -07:00
Guillaume Lessard cb63c9a073 Merge pull request #297 from finagolfin/droid
[CI] Use latest workflows tag and properly enable Android with emulator testing
2026-02-20 14:13:45 -08:00
Finagolfin 4471eaa313 [CI] Remove Android SDK exclusions that didn't work, and enable new emulator testing 2026-02-18 03:54:21 +05:30
Finagolfin f86edc7020 [CI] Use latest tag of official workflows, now that they've settled 2026-02-18 03:52:52 +05:30
Guillaume Lessard 71db29e931 Merge pull request #293 from kkebo/fix-freebsd
Fix FreeBSD build
2026-02-06 15:04:21 -08:00
Kenta Kubo 043bda4234 Remove unclear helper function 2026-02-04 02:18:24 +09:00
Kenta Kubo 4278ed8d97 Unify assertions of sizeAllocated on all POSIX platforms 2026-02-04 01:55:12 +09:00
Kenta Kubo cf6956a19a Reduce the use of compile-time branching 2026-01-28 21:33:06 +09:00
Kenta Kubo 91bd99f29a Fix Darwin tests 2026-01-28 21:24:57 +09:00
Kenta Kubo 7c0af0ded6 Fix FreeBSD build 2026-01-28 00:02:14 +09:00
Guillaume Lessard 7e474cb4bd Merge pull request #289 from glessard/issue288-resilient-machport
MachPort inlinability fixes
2026-01-21 12:39:55 -08:00
Guillaume Lessard b0e5ec8932 MachPort inlinability fixes
When compiled with library resilience, `consuming` functions which `discard self` cannot also be `@inlinable`.
2026-01-21 09:10:29 -08:00
Guillaume Lessard 538ae25062 Merge pull request #287 from apple/dev/merge-back-1.6.x
Merge back changes from the 1.6.x branch
2026-01-14 08:44:19 -08:00
Guillaume Lessard fb3c3abebf Merge branch 'release/1.6.0' 2026-01-13 19:20:33 -08:00
Guillaume Lessard f6b96c3ba7 Merge pull request #279 from mairinkdev/main
Fix silent buffer size truncation in Windows pread/pwrite
2026-01-13 14:35:02 -08:00
Guillaume Lessard 7c6ad0fc39 Merge pull request #286 from apple/dev/fix-pread-truncation-windows-1.6.0
[Windows] fix pread/pwrite truncation
2026-01-13 13:53:28 -08:00
lee 13851a3421 Fix silent buffer size truncation in Windows pread/pwrite 2026-01-13 13:37:44 -08:00
Guillaume Lessard 8f8d80a4fe Merge pull request #285 from glessard/fix-HRESULT_FACILITY-1.6.0
[Windows] Fix HRESULT_FACILITY
2026-01-13 13:33:25 -08:00
Guillaume Lessard 608a75b962 Merge pull request #284 from glessard/workflow-edits-1.6.0-again
[ci] re-allow 5.9 and 5.10 for 1.6.x
2026-01-13 12:49:27 -08:00
AZero13 0dbbab4aa1 Fix HRESULT_FACILITY
HRESULT_FACILITY is >> 16 & 0x1fff, not <<
2026-01-13 12:41:47 -08:00
Guillaume Lessard 2eb655e0b7 [ci] re-allow 5.9 and 5.10
- they were excluded in error.
2026-01-13 12:38:57 -08:00
Guillaume Lessard 53afbde6ab Merge pull request #275 from AZero13/patch-1 2026-01-13 12:07:29 -08:00
Guillaume Lessard 07a3f090d7 Merge pull request #280 from glessard/workflow-edits-1.6.0
[ci] adjust the pull-request action
2026-01-08 17:06:26 -08:00
Guillaume Lessard dda2b535b7 [ci] adjust the pull-request action 2026-01-08 16:46:01 -08:00
AZero13 0ed3416369 Merge branch 'main' into patch-1 2026-01-08 14:10:19 -05:00
lee 766415499c Fix silent buffer size truncation in Windows pread/pwrite 2026-01-07 11:37:16 -03:00
Guillaume Lessard 097805e869 require Swift 6.1
- and exclude 6.0 toolchains from executing in CI
2026-01-06 17:10:56 -08:00
Guillaume Lessard e65f5a6cad dup3 wrapper proposal
Improve a sentence.
2026-01-06 17:08:56 -08:00
Guillaume Lessard 2e372aa16c Merge pull request #277 from glessard/dev/adjust-gh-actions
[ci] adjust the pull-request action
2026-01-06 17:07:27 -08:00
Guillaume Lessard 4956c2c512 [ci] adjust the pull-request action 2026-01-06 13:29:46 -08:00
AZero13 0dcedcb7bb Fix HRESULT_FACILITY
HRESULT_FACILITY is >> 16 & 0x1fff, not <<
2025-12-28 14:33:38 -05:00
Jonathan Flat b083113aef Merge pull request #270 from jrflat/fix-android-stat
Fix Stat build on Android
2025-11-04 10:29:45 -07:00
Jonathan Flat f9a2b9443b Exclude focal for Android build 2025-11-03 18:29:15 -07:00
Jonathan Flat b252c123a7 Enable Android SDK build 2025-11-03 18:11:02 -07:00
Jonathan Flat e133abb3e0 Fix Stat build on Android 2025-11-03 18:05:50 -07:00
Jonathan Flat b11b33ab57 Merge pull request #256 from jrflat/stat-implementation
Stat implementation for Swift System
2025-11-03 11:47:40 -07:00
Jonathan Flat 55350cd06d Add availability to new CInterop typealiases 2025-11-02 22:31:37 -07:00
Jonathan Flat 87f8e49ba7 Assign rawValue instead of self 2025-10-30 14:11:45 -06:00
Guillaume Lessard d5f59fe404 Merge pull request #267 from incertum/chore/workflow-permissions
chore: restrict GitHub workflow permissions - future-proof
2025-10-29 11:03:22 -07:00
Jonathan Flat c2e385e849 Remove commented-out code pt. 2 2025-10-29 12:01:13 -06:00
Jonathan Flat 4911642226 Add availability, fix CInterop availability issue on old Darwin platforms 2025-10-29 12:01:01 -06:00
Jonathan Flat 40e1deb663 Consolidate internal Stat functions 2025-10-29 11:47:32 -06:00
Jonathan Flat eee0145671 Standardize on "file system" 2025-10-28 22:52:34 -06:00
Jonathan Flat 90dba1dc68 AT_SYMLINK_FOLLOW -> AT_SYMLINK_NOFOLLOW 2025-10-28 22:31:34 -06:00
Jonathan Flat 501bb7d052 Remove commented-out code for future directions 2025-10-28 22:30:47 -06:00
Melissa Kilby 67a2fd2ca1 chore: restrict GitHub workflow permissions - future-proof
Signed-off-by: Melissa Kilby <mkilby@apple.com>
2025-10-17 16:28:56 -07:00
Stephen Canon bc16a3c120 Merge pull request #257 from jrflat/stat-proposal
[Proposal] Stat for Swift System
2025-10-13 12:14:18 -04:00
Jonathan Flat 98712f67f2 Remove _GNU_SOURCE define and AT_EMPTY_PATH for now 2025-10-06 13:32:29 -06:00
Jonathan Flat 2f5b12b854 Updates for proposal v3 2025-09-29 12:02:59 -06:00
Jonathan Flat 905f9f842d Expose C timespec properties until UTCClock can be used 2025-09-29 11:34:04 -06:00
Jonathan Flat a07696ace3 Fix AT_RESOLVE_BENEATH availability 2025-09-29 11:34:03 -06:00
Jonathan Flat 57d515e1d0 Stat implementation 2025-09-29 11:34:02 -06:00
Jonathan Flat 2f4c8c216c Create Proposals directory 2025-09-29 11:26:15 -06:00
Jonathan Flat 70f197f036 Address feedback (v3) 2025-09-29 11:19:36 -06:00
Guillaume Lessard f477389569 Merge pull request #264 from apple/adjust-toolchain-support
Adjust toolchain support
2025-09-19 09:06:44 -07:00
Guillaume Lessard bc4e6e3bea Use Swift 5 language mode
`MachPort` is fine with Swift 6.1 and up, but does not compile with Swift 6.0’s Swift 6 language mode.
`import CSystem` is a problem in the Linux version (inconsistently imported as implementation-only.)
The Wasm implementation seems not concurrency-safe.
2025-09-18 17:52:01 -07:00
Guillaume Lessard d8dd95176b adjust pull-request workflow 2025-09-18 17:30:36 -07:00
Guillaume Lessard 2ae0c650be Make shared state constant as intended. 2025-09-18 17:01:26 -07:00
Guillaume Lessard 478da393fa Use new names for Swift 6 mode 2025-09-18 16:59:28 -07:00
Guillaume Lessard 80587df07f Require Swift 6.0 2025-09-18 16:58:21 -07:00
Guillaume Lessard 4bbe3f3eeb Merge pull request #261 from apple/release/1.6.0
Merge back tag 1.6.3
2025-09-18 11:41:27 -07:00
Guillaume Lessard 9ddc89964b Merge pull request #263 from apple/workflow-edits-1.6.0
[1.6.0] Apply GitHub workflow edits
2025-09-18 11:14:47 -07:00
Guillaume Lessard 18a52c4729 [workflows] declare 2D exclusions 2025-09-18 10:47:41 -07:00
Guillaume Lessard 1c1ad1d3f4 [workflows] change ubuntus to test against 2025-09-18 10:09:02 -07:00
Guillaume Lessard 2fdd948a28 Merge pull request #262 from glessard/workflow-edits
[workflows] change ubuntus to test against
2025-09-18 09:47:02 -07:00
Guillaume Lessard 227ebbbe2d [workflows] declare 2D exclusions 2025-09-18 08:00:59 -07:00
Guillaume Lessard b6bd66889b [workflows] change ubuntus to test against 2025-09-17 15:46:21 -07:00
Guillaume Lessard 395a77f0aa Merge pull request #260 from apple/eng/PR-duplicate-as-release/1.6.0
[1.6] Fix: FileDescriptor.duplicate(as:) returns an invalid file descriptor on Windows
2025-09-15 10:31:53 -07:00
Jake Petroules b1618475cc [1.6] Fix: FileDescriptor.duplicate(as:) returns an invalid file descriptor on Windows
FileDescriptor.duplicate(as:) is backed by dup2 on Unix, and _dup2 on Windows.
On Unix, dup2 returns its second argument. On Windows, _dup2 instead returns
0 on success and -1 on error. This results in the newly returned FileDescriptor
object always containing a '0' file descriptor rather than the newly created
file descriptor, in violation of the documented behavior.

Account for the platform difference in the syscall wrapper to fix this.

Closes #192

(cherry picked from commit b2711a872a)
2025-09-15 10:16:15 -07:00
Jake Petroules b2711a872a Fix: FileDescriptor.duplicate(as:) returns an invalid file descriptor on Windows
FileDescriptor.duplicate(as:) is backed by dup2 on Unix, and _dup2 on Windows.
On Unix, dup2 returns its second argument. On Windows, _dup2 instead returns
0 on success and -1 on error. This results in the newly returned FileDescriptor
object always containing a '0' file descriptor rather than the newly created
file descriptor, in violation of the documented behavior.

Account for the platform difference in the syscall wrapper to fix this.

Closes #192
2025-09-12 22:11:45 -07:00
Jonathan Flat 0b3b691d0b Update pitch link 2025-08-12 12:36:17 -06:00
Jonathan Flat 0610d8f893 Stat proposal 2025-08-12 12:16:13 -06:00
Guillaume Lessard 890830fff1 Merge pull request #254 from jrflat/fix-generic-int-typedefs-1.6.0 2025-08-03 17:11:41 -07:00
Jonathan Flat a5f13c77b8 Fix typedef errors on platforms with _ASM_GENERIC_INT headers 2025-08-03 11:24:24 -06:00
49 changed files with 5311 additions and 416 deletions

No files matched your search

+88 -19
View File
@@ -1,5 +1,8 @@
name: Pull request
permissions:
contents: read
on:
pull_request:
types: [opened, reopened, synchronize]
@@ -7,43 +10,109 @@ on:
jobs:
tests:
name: Test
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.15
with:
linux_os_versions: '["jammy", "focal"]'
enable_macos_checks: true
# FIXME: https://github.com/swiftlang/github-workflows/pull/140
# Xcode 16.0 and 16.1 are not actually available
macos_exclude_xcode_versions: |
[
{"xcode_version": "16.0"},
{"xcode_version": "16.1"},
]
swift_flags: "-Xbuild-tools-swiftc -DSYSTEM_CI"
enable_linux_checks: true
linux_os_versions: '["noble", "jammy", "focal"]'
linux_exclude_swift_versions: |
[
{"swift_version": "5.9"},
{"swift_version": "5.10"},
{"swift_version": "6.0"},
{"os_version": "focal", "swift_version": "nightly-6.2"},
{"os_version": "focal", "swift_version": "6.2"},
{"os_version": "focal", "swift_version": "nightly-6.3"},
{"os_version": "focal", "swift_version": "6.3"},
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
{"os_version": "focal", "swift_version": "6.4.x"},
{"os_version": "focal", "swift_version": "nightly-main"},
]
enable_macos_checks: true
macos_exclude_xcode_versions: '[]'
enable_windows_checks: true
windows_exclude_swift_versions: |
[
{"swift_version": "5.9"},
{"swift_version": "5.10"},
{"swift_version": "6.0"},
]
enable_linux_static_sdk_build: true
linux_static_sdk_exclude_swift_versions: |
[
{"os_version": "focal", "swift_version": "nightly-6.2"},
{"os_version": "focal", "swift_version": "6.2"},
{"os_version": "focal", "swift_version": "nightly-6.3"},
{"os_version": "focal", "swift_version": "6.3"},
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
{"os_version": "focal", "swift_version": "6.4.x"},
{"os_version": "focal", "swift_version": "nightly-main"},
]
enable_wasm_sdk_build: true
wasm_exclude_swift_versions: |
[
{"os_version": "focal", "swift_version": "nightly-6.2"},
{"os_version": "focal", "swift_version": "6.2"},
{"os_version": "focal", "swift_version": "nightly-6.3"},
{"os_version": "focal", "swift_version": "6.3"},
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
{"os_version": "focal", "swift_version": "6.4.x"},
{"os_version": "focal", "swift_version": "nightly-main"},
]
enable_android_sdk_build: true
enable_android_sdk_checks: true
enable_freebsd_checks: true
build-abi-stable:
name: Build ABI Stable
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.15
with:
enable_linux_checks: false
enable_macos_checks: true
enable_windows_checks: false
# Only build
macos_build_command: "xcrun swift build --build-tests"
# FIXME: https://github.com/swiftlang/github-workflows/pull/140
# Xcode 16.0 and 16.1 are not actually available
macos_exclude_xcode_versions: |
[
{"xcode_version": "16.0"},
{"xcode_version": "16.1"},
]
macos_exclude_xcode_versions: '[]'
# Enable availability to match ABI stable verion of system.
swift_flags: "-Xbuild-tools-swiftc -DSYSTEM_CI -Xbuild-tools-swiftc -DSYSTEM_ABI_STABLE"
cmake_build:
name: CMake Validation
runs-on: ubuntu-latest
container: swiftlang/swift:nightly-main-noble
steps:
- name: Copy Sources
uses: actions/checkout@v6
- name: Install Dependencies
shell: bash
run: apt update && apt install -y cmake ninja-build jq
- name: Configure Project
shell: bash
run: |
mkdir -p build/.cmake/api/v1/query
touch build/.cmake/api/v1/query/codemodel-v2
cmake -G 'Ninja' -B build -S . -DCMAKE_C_COMPILER=clang -DCMAKE_Swift_COMPILER=swiftc -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=YES
- name: Validate CMake File Lists
shell: bash
run: |
swift package describe --type json > /tmp/swiftpm.json
cat build/.cmake/api/v1/reply/target-SystemPackage-*.json > /tmp/cmake.json
jq '.targets[] | select(.name == "SystemPackage") | .sources[]' /tmp/swiftpm.json | sort > /tmp/swiftpm-list.txt
jq '.sources[].path[15:]' /tmp/cmake.json | sort > /tmp/cmake-list.txt
comm -23 /tmp/swiftpm-list.txt /tmp/cmake-list.txt > /tmp/missing.txt
if [ -s /tmp/missing.txt ]; then
echo "::error::SystemPackage CMakeLists.txt does not match SwiftPM. Missing sources:"
cat /tmp/missing.txt
exit 1
fi
echo "::notice::SystemPackage CMakeLists.txt matches SwiftPM"
- name: Build Project with CMake
shell: bash
run: cmake --build build
soundness:
name: Soundness
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@0.0.15
with:
license_header_check_project_name: "Swift.org"
# https://github.com/apple/swift-system/issues/224
+2
View File
@@ -13,6 +13,8 @@ project(SwiftSystem
include(GNUInstallDirs)
set(CMAKE_Swift_LANGUAGE_VERSION 6)
list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/modules)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+13 -8
View File
@@ -1,4 +1,4 @@
// swift-tools-version:5.9
// swift-tools-version:6.1
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
@@ -59,11 +59,9 @@ let availability: [Available] = [
Available("1.3.2", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4, visionOS 1.0"),
Available("1.4.0", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4, visionOS 1.0"),
Available("1.4.1", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.4.2", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.5.0", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.6.0", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.6.1", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.7.0", "macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0"),
Available("199", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
]
let swiftSettingsAvailability = availability.map(\.swiftSetting)
@@ -139,5 +137,12 @@ let package = Package(
exclude: testsToExclude,
cSettings: cSettings,
swiftSettings: swiftSettings),
])
// Builds a SystemPackage consumer with MemberImportVisibility enabled.
// Fails if a C member of a vended type is attributed to the CSystem module.
.testTarget(
name: "MemberImportVisibility",
dependencies: ["SystemPackage"],
swiftSettings: [.enableUpcomingFeature("MemberImportVisibility")]),
],
swiftLanguageModes: [.v6]
)
+985
View File
@@ -0,0 +1,985 @@
# Stat for Swift System
* Proposal: [SYS-0006](0006-system-stat.md)
* Authors: [Jonathan Flat](https://github.com/jrflat), [Michael Ilseman](https://github.com/milseman), [Rauhul Varma](https://github.com/rauhul)
* Review Manager: TBD
* Status: **Awaiting review**
* Implementation: [apple/swift-system#256](https://github.com/apple/swift-system/pull/256)
* Review: ([pitch](https://forums.swift.org/t/pitch-stat-types-for-swift-system/81616))
#### Revision history
* **v1** Initial version
* **v2** Moved `UTCClock.Instant` properties to **Future Directions** and exposed C `timespec` properties. Expanded **Alternatives Considered** for `Stat` name and time properties.
* **v3** Add `init(_:)` to wrapper types, clarify `FileType(rawValue:)` behavior with `S_IFMT`, rename `.pipe` to `.fifo`, mention `ALLPERMS` instead of `0o7777`, explain "is"-less flag names in **Alternatives Considered**, fix conditionals for FreeBSD flags, clarify that `.type` and `.permissions` depend on `.mode`, clarify that size property behaviors are file system-dependent.
## Introduction
This proposal introduces a Swift-native `Stat` type to the System library, providing comprehensive access to file metadata on Unix-like platforms through type-safe, platform-aware APIs that wrap the C `stat` types and system calls.
## Motivation
Currently, Swift developers who want to work with the file system's lowest level API can only do so through bridged C interfaces. These interfaces lack type safety and require writing non-idiomatic Swift, leading to errors and confusion.
The goal of the `Stat` type is to provide a faithful and performant Swift wrapper around the underlying C system calls while adding type safety, platform abstraction, and improved discoverability/usability with clear naming. For more on the motivation behind System, see [https://www.swift.org/blog/swift-system](https://www.swift.org/blog/swift-system)
## Proposed solution
This proposal adds a `struct Stat` that is available on Unix-like platforms. See discussion on Windows-specific API in **Future Directions**.
### `Stat` - File Metadata
A Swift wrapper around the C `stat` struct that provides type-safe access to file metadata:
```swift
// Get file status from path String
let stat = try Stat("/path/to/file")
// From FileDescriptor
let stat = try fd.stat()
// From FilePath
let stat = try filePath.stat()
// `followTargetSymlink: true` (default) behaves like `stat()`
// `followTargetSymlink: false` behaves like `lstat()`
let stat = try symlinkPath.stat(followTargetSymlink: false)
// Supply flags and optional file descriptor to use the `fstatat()` variant
let stat = try Stat("path/to/file", relativeTo: fd, flags: .symlinkNoFollow)
print("Size: \(stat.size) bytes")
print("Size allocated: \(stat.sizeAllocated) bytes")
print("Type: \(stat.type)") // .regular, .directory, .symbolicLink, etc.
print("Permissions: \(stat.permissions)")
print("Modified: \(stat.modificationTime)")
// Platform-specific information when available
#if canImport(Darwin) || os(FreeBSD)
print("Creation time: \(stat.creationTime)")
#endif
```
### Error Handling
All initializers throw the existing `Errno` type:
```swift
do {
let stat = try Stat("/nonexistent/file")
} catch Errno.noSuchFileOrDirectory {
print("File not found")
} catch {
print("Other error: \(error)")
}
```
These initializers use a typed `throws(Errno)` and require Swift 6.0 or later.
## Detailed design
See the **Appendix** section at the end of this proposal for a table view of Swift API to C mappings.
All API are marked `@_alwaysEmitIntoClient` for performance and back-dating of availability, except `Stat`'s `==` and `hash(into:)`, which are ordinary `public` API.
### FileType
This proposal introduces `FileType` and `FileMode` types to represent `mode_t` values from the C `stat` struct. The type and permissions of a `FileMode` can be modified for convenience, and `FileMode` handles the respective bit masking.
```swift
/// A file type matching those contained in a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
public struct FileType: RawRepresentable, Sendable, Hashable, Codable {
/// The raw file-type bits from the C mode.
public var rawValue: CInterop.Mode
/// Creates a strongly-typed file type from the raw C `mode_t`.
///
/// - Note: This initializer stores the `rawValue` directly and **does not**
/// mask the value with `S_IFMT`. If the supplied `rawValue` contains bits
/// outside of the `S_IFMT` mask, the resulting `FileType` will not compare
/// equal to constants like `.directory` and `.symbolicLink`, which may
/// be unexpected.
///
/// If you're unsure whether the `mode_t` contains bits outside of `S_IFMT`,
/// you can use `FileMode(rawValue:)` instead to get a strongly-typed
/// `FileMode`, then call `.type` to get the properly masked `FileType`.
public init(rawValue: CInterop.Mode)
/// Directory
///
/// The corresponding C constant is `S_IFDIR`.
public static var directory: FileType { get }
/// Character special device
///
/// The corresponding C constant is `S_IFCHR`.
public static var characterSpecial: FileType { get }
/// Block special device
///
/// The corresponding C constant is `S_IFBLK`.
public static var blockSpecial: FileType { get }
/// Regular file
///
/// The corresponding C constant is `S_IFREG`.
public static var regular: FileType { get }
/// FIFO (or named pipe)
///
/// The corresponding C constant is `S_IFIFO`.
public static var fifo: FileType { get }
/// Symbolic link
///
/// The corresponding C constant is `S_IFLNK`.
public static var symbolicLink: FileType { get }
/// Socket
///
/// The corresponding C constant is `S_IFSOCK`.
public static var socket: FileType { get }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Whiteout file
///
/// The corresponding C constant is `S_IFWHT`.
public static var whiteout: FileType { get }
#endif
}
```
### FileMode
```swift
/// A strongly-typed file mode representing a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
public struct FileMode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C mode.
public var rawValue: CInterop.Mode
/// Creates a strongly-typed `FileMode` from the raw C value.
public init(rawValue: CInterop.Mode)
/// Creates a strongly-typed `FileMode` from the raw C value.
public init(_ rawValue: CInterop.Mode)
/// Creates a `FileMode` from the given file type and permissions.
///
/// - Note: This initializer masks the inputs with their respective bit masks.
public init(type: FileType, permissions: FilePermissions)
/// The file's type, from the mode's file-type bits.
///
/// Setting this property will mask the `newValue` with the file-type bit mask `S_IFMT`.
public var type: FileType { get set }
/// The file's permissions, from the mode's permission bits.
///
/// Setting this property will mask the `newValue` with the permissions bit mask `ALLPERMS`.
public var permissions: FilePermissions { get set }
}
```
### Supporting ID Types
This proposal also uses new `DeviceID`, `UserID`, `GroupID`, and `Inode` types to represent the respective C data types found in `stat`. These are strongly-typed structs instead of `CInterop` typealiases to prevent ambiguity in future System implementations and to allow for added functionality.
For example, with an implementation of `chown`, a developer might accidentally misplace user and group parameters with no warning if both were a typealias of the underlying `unsigned int`. Furthermore, a strongly-typed `DeviceID` would allow us to add functionality such as a `makedev` function, or `major` and `minor` getters.
For now, we define the following for use in `Stat`.
```swift
@frozen
public struct UserID: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.UserID
public init(rawValue: CInterop.UserID)
public init(_ rawValue: CInterop.UserID)
}
@frozen
public struct GroupID: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.GroupID
public init(rawValue: CInterop.GroupID)
public init(_ rawValue: CInterop.GroupID)
}
@frozen
public struct DeviceID: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.DeviceID
public init(rawValue: CInterop.DeviceID)
public init(_ rawValue: CInterop.DeviceID)
}
@frozen
public struct Inode: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.Inode
public init(rawValue: CInterop.Inode)
public init(_ rawValue: CInterop.Inode)
}
```
Each type stores a `CInterop` typealias to ensure an appropriate `rawValue` for the current platform. Added functionality is outside the scope of this proposal and will be included in a future proposal.
### FileFlags
A new `FileFlags` type represents file-specific flags found in a `stat` struct on Darwin, FreeBSD, and OpenBSD. This type would also be useful for an implementation of `chflags()`.
```swift
/// File-specific flags found in the `st_flags` property of a `stat` struct
/// or used as input to `chflags()`.
///
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@frozen
public struct FileFlags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
public let rawValue: CInterop.FileFlags
/// Creates a strongly-typed `FileFlags` from the raw C value.
public init(rawValue: CInterop.FileFlags)
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
/// Do not dump the file during backups.
///
/// The corresponding C constant is `UF_NODUMP`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var noDump: FileFlags { get }
/// File may not be changed.
///
/// The corresponding C constant is `UF_IMMUTABLE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var userImmutable: FileFlags { get }
/// Writes to the file may only append.
///
/// The corresponding C constant is `UF_APPEND`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var userAppend: FileFlags { get }
/// File has been archived.
///
/// The corresponding C constant is `SF_ARCHIVED`.
/// - Note: This flag may only be changed by the superuser.
public static var archived: FileFlags { get }
/// File may not be changed.
///
/// The corresponding C constant is `SF_IMMUTABLE`.
/// - Note: This flag may only be changed by the superuser.
public static var systemImmutable: FileFlags { get }
/// Writes to the file may only append.
///
/// The corresponding C constant is `SF_APPEND`.
/// - Note: This flag may only be changed by the superuser.
public static var systemAppend: FileFlags { get }
// MARK: Flags Available on Darwin and FreeBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Directory is opaque when viewed through a union mount.
///
/// The corresponding C constant is `UF_OPAQUE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var opaque: FileFlags { get }
/// File should not be displayed in a GUI.
///
/// The corresponding C constant is `UF_HIDDEN`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var hidden: FileFlags { get }
/// File may not be removed or renamed.
///
/// The corresponding C constant is `SF_NOUNLINK`.
/// - Note: This flag may only be changed by the superuser.
public static var systemNoUnlink: FileFlags { get }
#endif
// MARK: Flags Available on Darwin only
#if SYSTEM_PACKAGE_DARWIN
/// File is compressed at the file system level.
///
/// The corresponding C constant is `UF_COMPRESSED`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
public static var compressed: FileFlags { get }
/// File is tracked for the purpose of document IDs.
///
/// The corresponding C constant is `UF_TRACKED`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var tracked: FileFlags { get }
/// File requires an entitlement for reading and writing.
///
/// The corresponding C constant is `UF_DATAVAULT`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var dataVault: FileFlags { get }
/// File requires an entitlement for writing.
///
/// The corresponding C constant is `SF_RESTRICTED`.
/// - Note: This flag may only be changed by the superuser.
public static var restricted: FileFlags { get }
/// File is a firmlink.
///
/// Firmlinks are used by macOS to create transparent links between
/// the read-only system volume and writable data volume. For example,
/// the `/Applications` folder on the system volume is a firmlink to
/// the `/Applications` folder on the data volume, allowing the user
/// to see both system- and user-installed applications in a single folder.
///
/// The corresponding C constant is `SF_FIRMLINK`.
/// - Note: This flag may only be changed by the superuser.
public static var firmlink: FileFlags { get }
/// File is a dataless placeholder (content is stored remotely).
///
/// The system will attempt to materialize the file when accessed according to
/// the dataless file materialization policy of the accessing thread or process.
/// See `getiopolicy_np(3)`.
///
/// The corresponding C constant is `SF_DATALESS`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
public static var dataless: FileFlags { get }
#endif
// MARK: Flags Available on FreeBSD Only
#if os(FreeBSD)
/// File may not be removed or renamed.
///
/// The corresponding C constant is `UF_NOUNLINK`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var userNoUnlink: FileFlags { get }
/// File has the Windows offline attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_OFFLINE` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_OFFLINE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var offline: FileFlags { get }
/// File is read-only.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_READONLY` attribute.
///
/// The corresponding C constant is `UF_READONLY`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var readOnly: FileFlags { get }
/// File contains a Windows reparse point.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_REPARSE_POINT` attribute.
///
/// The corresponding C constant is `UF_REPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var reparse: FileFlags { get }
/// File is sparse.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SPARSE_FILE` attribute,
/// or to indicate a sparse file.
///
/// The corresponding C constant is `UF_SPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var sparse: FileFlags { get }
/// File has the Windows system attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SYSTEM` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_SYSTEM`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var system: FileFlags { get }
/// File is a snapshot.
///
/// The corresponding C constant is `SF_SNAPSHOT`.
/// - Note: This flag may only be changed by the superuser.
public static var snapshot: FileFlags { get }
#endif
}
```
### Stat
`Stat` can be initialized from a `FilePath`, `UnsafePointer<CChar>`, or `FileDescriptor`. This proposal also includes functions on `FileDescriptor` and `FilePath` for creating a `Stat` object, seen in the section below.
The initializer accepting a `FileDescriptor` corresponds to `fstat()`. If the file descriptor points to a symlink, this will return information about the symlink itself.
In the non-`FileDescriptor` case, one form of the initializer takes a `followTargetSymlink: Bool = true` parameter. The default `true` corresponds to `stat()` and will follow a symlink at the end of the path. Setting `followTargetSymlink: false` corresponds to `lstat()` and will return information about the symlink itself.
The other form of the initializer receives a path, which can be optionally resolved against a given file descriptor, and a set of `Stat.Flags`. These APIs correspond to the `fstatat()` system call and use a default file descriptor of `AT_FDCWD` if one isn't supplied.
```swift
/// A Swift wrapper of the C `stat` struct.
///
/// - Note: Only available on Unix-like platforms.
@frozen
public struct Stat: RawRepresentable, Sendable {
/// The raw C `stat` struct.
public var rawValue: CInterop.Stat
/// Creates a Swift `Stat` from the raw C struct.
public init(rawValue: CInterop.Stat)
// MARK: Stat.Flags
/// Flags representing those passed to `fstatat()`.
@frozen
public struct Flags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
public let rawValue: CInt
/// Creates a strongly-typed `Stat.Flags` from raw C flags.
public init(rawValue: CInt)
/// If the path ends with a symbolic link, return information about the link itself.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW`.
public static var symlinkNoFollow: Flags { get }
#if SYSTEM_PACKAGE_DARWIN
/// If the path ends with a symbolic link, return information about the link itself.
/// If _any_ symbolic link is encountered during path resolution, return an error.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW_ANY`.
/// - Note: Only available on Darwin.
public static var symlinkNoFollowAny: Flags { get }
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// If the path does not reside in the hierarchy beneath the starting directory, return an error.
///
/// The corresponding C constant is `AT_RESOLVE_BENEATH`.
/// - Note: Only available on Darwin and FreeBSD.
@available(macOS 26.0, iOS 26.0, tvOS 26.0, watchOS 26.0, visionOS 26.0, *)
public static var resolveBeneath: Flags { get }
#endif
#if os(FreeBSD) || os(Linux) || os(Android)
/// If the path is an empty string (or `NULL` since Linux 6.11),
/// return information about the given file descriptor.
///
/// The corresponding C constant is `AT_EMPTY_PATH`.
/// - Note: Only available on FreeBSD, Linux, and Android.
public static var emptyPath: Flags { get }
#endif
}
// MARK: Initializers
/// Creates a `Stat` struct from a `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
public init(
_ path: FilePath,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
public init(
_ path: UnsafePointer<CChar>,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from a `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
public init(
_ fd: FileDescriptor,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from a `FilePath` and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: FilePath,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from a `FilePath` and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: FilePath,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: UnsafePointer<CChar>,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: UnsafePointer<CChar>,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
// MARK: Properties
/// ID of device containing file
///
/// The corresponding C property is `st_dev`.
public var deviceID: DeviceID { get set }
/// Inode number
///
/// The corresponding C property is `st_ino`.
public var inode: Inode { get set }
/// File mode
///
/// The corresponding C property is `st_mode`.
public var mode: FileMode { get set }
/// File type for the given mode
///
/// - Note: This property is equivalent to `mode.type`. Modifying this
/// property will update the underlying `st_mode` accordingly.
public var type: FileType { get set }
/// File permissions for the given mode
///
/// - Note: This property is equivalent to `mode.permissions`. Modifying
/// this property will update the underlying `st_mode` accordingly.
public var permissions: FilePermissions { get set }
/// Number of hard links
///
/// The corresponding C property is `st_nlink`.
public var linkCount: Int { get set }
/// User ID of owner
///
/// The corresponding C property is `st_uid`.
public var userID: UserID { get set }
/// Group ID of owner
///
/// The corresponding C property is `st_gid`.
public var groupID: GroupID { get set }
/// Device ID (if special file)
///
/// For character or block special files, the returned `DeviceID` may have
/// meaningful `.major` and `.minor` values. For non-special files, this
/// property is usually meaningless and often set to 0.
///
/// The corresponding C property is `st_rdev`.
public var specialDeviceID: DeviceID { get set }
/// Total size, in bytes
///
/// The semantics of this property are tied to the underlying C `st_size` field,
/// which can have file system-dependent behavior. For example, this property
/// can return different values for a file's data fork and resource fork, and some
/// file systems report logical size rather than actual disk usage for compressed
/// or cloned files.
///
/// The corresponding C property is `st_size`.
public var size: Int64 { get set }
/// Block size for filesystem I/O, in bytes
///
/// The corresponding C property is `st_blksize`.
public var preferredIOBlockSize: Int { get set }
/// Number of 512-byte blocks allocated
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file system-dependent behavior.
///
/// The corresponding C property is `st_blocks`.
public var blocksAllocated: Int64 { get set }
/// Total size allocated, in bytes
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file system-dependent behavior.
///
/// - Note: Calculated as `512 * blocksAllocated`.
public var sizeAllocated: Int64 { get }
// NOTE: "st_" property names are used for the `timespec` properties so
// we can reserve `accessTime`, `modificationTime`, etc. for potential
// `UTCClock.Instant` properties in the future.
// See Future Directions for more info.
/// Time of last access, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_atim` (or `st_atimespec` on Darwin).
public var st_atim: timespec { get set }
/// Time of last modification, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_mtim` (or `st_mtimespec` on Darwin).
public var st_mtim: timespec { get set }
/// Time of last status (inode) change, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_ctim` (or `st_ctimespec` on Darwin).
public var st_ctim: timespec { get set }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Time of file creation, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_birthtim` (or `st_birthtimespec` on Darwin).
/// - Note: Only available on Darwin and FreeBSD.
public var st_birthtim: timespec { get set }
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
/// File flags
///
/// The corresponding C property is `st_flags`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
public var flags: FileFlags { get set }
/// File generation number
///
/// The file generation number may be used to distinguish between different
/// files that have used the same inode over time.
///
/// The corresponding C property is `st_gen`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD. The underlying C
/// field is 32-bit on Darwin and OpenBSD, and 64-bit on FreeBSD.
public var generationNumber: UInt64 { get set }
#endif
}
// MARK: - Equatable and Hashable
extension Stat: Equatable {
/// Compares the meaningful file-metadata fields of two `Stat` values.
///
/// Alignment padding and platform reserved/"spare" fields are not compared.
public static func == (lhs: Self, rhs: Self) -> Bool
}
extension Stat: Hashable {
/// Hashes the meaningful file-metadata fields of a `Stat` struct.
public func hash(into hasher: inout Hasher)
}
```
### FileDescriptor and FilePath Extensions
```swift
extension FileDescriptor {
/// Creates a `Stat` struct for the file referenced by this `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
public func stat(
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
}
extension FilePath {
/// Creates a `Stat` struct for the file referenced by this `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
public func stat(
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
public func stat(
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
public func stat(
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
}
```
### CInterop Extensions
This proposal extends the existing `CInterop` namespace with platform-appropriate typealiases for the underlying C types. These typealiases are used as the `rawValue` for their strongly-typed representations.
```swift
extension CInterop {
public typealias Stat
public typealias Inode
public typealias UserID
public typealias GroupID
public typealias DeviceID
public typealias FileFlags
}
```
## Source compatibility
This proposal is additive and source-compatible with existing code.
## ABI compatibility
This proposal is additive and ABI-compatible with existing code.
## Implications on adoption
This feature can be freely adopted and un-adopted in source code with no deployment constraints and without affecting source or ABI compatibility.
## Future directions
To remain faithful to the underlying system calls, we don't anticipate extending `Stat`. However, the types introduced in this proposal could serve as the foundation of broader file system APIs in Swift.
While this proposal does not include `Stat` on Windows, a separate proposal should provide Swift-native wrappers of idiomatic `GetFileInformation` functions with their associated types.
A more general `FileInfo` API could then build on these OS-specific types to provide an ergonomic, cross-platform abstraction for file metadata. These future cross-platform APIs might be better implemented outside of System, such as in Foundation, the standard library, or somewhere in between. They could provide additional information or convenience features, such as reading and modifying extended attributes or setting file timestamps.
In the future, more functionality could be added to types such as `DeviceID`.
### Using `UTCClock.Instant` for time properties
When the `UTCClock` proposal and code destination is finalized, we could use the `UTCClock.Instant` type for `Stat` time properties:
```swift
extension Stat {
/// Time of last access, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_atim` (or `st_atimespec` on Darwin).
public var accessTime: UTCClock.Instant { get set }
/// Time of last modification, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_mtim` (or `st_mtimespec` on Darwin).
public var modificationTime: UTCClock.Instant { get set }
/// Time of last status (inode) change, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_ctim` (or `st_ctimespec` on Darwin).
public var changeTime: UTCClock.Instant { get set }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Time of file creation, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_birthtim` (or `st_birthtimespec` on Darwin).
/// - Note: Only available on Darwin and FreeBSD.
public var creationTime: UTCClock.Instant { get set }
#endif
}
```
We would reserve the more ergonomic `accessTime`, `modificationTime`, etc. names for these future extensions.
## Alternatives considered
### `FileInfo` as the lowest-level type
An alternative approach could be to have a more general `FileInfo` type be the lowest level of abstraction provided by the System library. This type would then handle all the `stat` or Windows-specific struct storage and accessors. However, this alternative:
- Is inconsistent with System's philosophy of providing low-level system abstractions.
- Introduces an even larger number of system-specific APIs on each type.
- Misses out on the familiarity of the `stat` name. Developers know what to look for and what to expect from this type.
### Single combined type for both file and file system metadata
Combining `Stat` and `StatFS` (separate proposal) into a single type was considered but rejected because file and file system information serve different purposes and are typically needed in different contexts. Storing and/or initializing both `stat` and `statfs` structs unnecessarily reduces performance when one isn't needed.
### Making `Stat` available on Windows
It's possible to make `Stat` available on Windows and use either the non-native `_stat` functions from CRT or populate the information via a separate `GetFileInformation` call. However, many of the `stat` fields are not- or less-applicable on Windows and are treated as such by `_stat`. For instance, `st_uid` is always zero on Windows, `st_ino` has no meaning in FAT, HPFS, or NTFS file systems, and `st_mode` can only specify a regular file, directory, or character special, with the executable bit depending entirely on the file's path extension.
Rather than forcing Windows file metadata semantics into a cross-platform `Stat` type, we should instead create Windows-specific types that give developers full access to platform-native file metadata. Combined with a higher-level `FileInfo` type that _is_ cross-platform, this gives the best of both low-level and platform-agnostic APIs.
### Only have `FilePath` and `FileDescriptor` extensions rather than initializers that accept these types
While having `.stat()` functions on `FilePath` and `FileDescriptor` is preferred for ergonomics and function chaining, this technique might lack the discoverability of having an initializer on `Stat` directly. This proposal therefore includes both the initializers and extensions.
### Types for time properties
`UTCClock.Instant` would ideally be chosen over alternatives such as `Duration` or a new `Timespec` type to provide a comparable instant in time rather than a duration since the Epoch. However, this would depend on lowering `UTCClock` to System or the standard library and depends on that separate proposal.
Exposing a `timespec` property directly also has benefits; it's faithful to the underlying system's type and already has conversion support to/from `Duration` in the standard library.
Given that `timespec` is not particularly crufty and already has public API supporting its conversions, we decided to expose the raw `timespec` for now under the original C property names (`st_atim`, `st_mtim`, etc.) and reserve more ergonomic names for future extensions.
### Type names
`Stat` was chosen over alternatives like `FileStat` or `FileStatus` for its brevity and likeness to the "stat" system call. Unlike generic names such as `FileInfo` or `FileMetadata`, `Stat` emphasizes the platform-specific nature of this type.
`Stat` and (possible future) `StatFS` names were chosen over `FileStat` and `FileSystemStat`, or a namespaced `File.Stat` and `FileSystem.Stat`, because `Stat` is recognized more as its own concept rather than shorthand for "status." Thus, using `FileSystem.Stat` or `FileSystemStat` for `statfs` in the future might lead to confusion. Also, precedence from other languages' `stat` APIs that use a "file system" namespace might add to this confusion:
```
Rust: fs::metadata() -> fs::Metadata
Python: os.stat() -> os.stat_result
Go: os.Stat() -> fs.FileInfo
```
`Inode` was chosen over alternatives like `FileIndex` or `FileID` to emphasize the platform-specific nature. `IndexNode` is a bit verbose, and despite its etymology, "inode" is now ubiquitous and understood as a single word, making the capitalization `Inode` preferable to `INode`.
### `FileFlags` naming conventions
`FileFlags` property names such as `hidden` and `compressed` could alternatively use an "is" prefix commonly seen in boolean properties to form `.isHidden` and `.isCompressed`. However, we chose to omit the "is" prefix for the following reasons:
- The "is"-less flag names are succinct and closely aligned with the underlying C constants they represent.
- `OptionSet` property names often use an adjective ("hidden") rather than a predicate ("is hidden") when describing a single subject, such as a file. This is likely because "is" does not add to the flow of `flags.contains(.isHidden)` like it does for a direct boolean property, such as `file.isHidden`.
- For both `OptionSet` APIs that describe a single subject and those that describe a collection of elements, there's precedence to omit the "is". Examples of single-subject `OptionSet` APIs include `UIControl.State`, which uses `.highlighted` and `.disabled` rather than `.isHighlighted` and `.isDisabled`, and `FilePermissions`, which uses `.ownerRead` rather than `.isOwnerReadable`. Examples of multi-subject `OptionSet` APIs include `Edge.Set`, which uses `.top` and `.bottom`, and `ShippingOptions` from the `OptionSet` documentation, which uses `.nextDay`, `.priority`, etc.
## Acknowledgments
These new APIs build on excellent types currently available in the System library.
## Appendix
### Swift API to C Mappings
The following tables show the mapping between Swift APIs and their underlying C system calls across different operating systems:
#### `Stat` Initializer Mappings
The `retryOnInterrupt: Bool = true` parameter is omitted for clarity.
| Swift API | Unix-like Platforms |
|-----------|---------------------|
| `Stat(_ path: FilePath, followTargetSymlink: true)` | `stat()` |
| `Stat(_ path: UnsafePointer<CChar>, followTargetSymlink: true)` | `stat()` |
||
| `Stat(_ path: FilePath, followTargetSymlink: false)` | `lstat()` |
| `Stat(_ path: UnsafePointer<CChar>, followTargetSymlink: false)` | `lstat()` |
||
| `Stat(_ path: FilePath, relativeTo: FileDescriptor, flags: Stat.Flags)` | `fstatat()` |
| `Stat(_ path: UnsafePointer<CChar>, relativeTo: FileDescriptor, flags: Stat.Flags)` | `fstatat()` |
||
| `Stat(_ fd: FileDescriptor)` | `fstat()` |
| `FileDescriptor.stat()` | `fstat()` |
||
| `FilePath.stat(followTargetSymlink: true)` | `stat()` |
| `FilePath.stat(followTargetSymlink: false)` | `lstat()` |
| `FilePath.stat(relativeTo: FileDescriptor, flags: Stat.Flags)` | `fstatat()` |
#### `Stat` Property Mappings
`"` denotes the same property name across all operating systems.
| Swift Property | Darwin | FreeBSD | OpenBSD | Linux | Android | WASI |
|----------------|--------|---------|---------|-------|---------|------|
| `deviceID` | `st_dev` | " | " | " | " | " |
| `inode` | `st_ino` | " | " | " | " | " |
| `mode` | `st_mode` | " | " | " | " | " |
| `linkCount` | `st_nlink` | " | " | " | " | " |
| `userID` | `st_uid` | " | " | " | " | " |
| `groupID` | `st_gid` | " | " | " | " | " |
| `specialDeviceID` | `st_rdev` | " | " | " | " | " |
| `size` | `st_size` | " | " | " | " | " |
| `preferredIOBlockSize` | `st_blksize` | " | " | " | " | " |
| `blocksAllocated` | `st_blocks` | " | " | " | " | " |
| `st_atim` | `st_atimespec` | `st_atim` | `st_atim` | `st_atim` | `st_atim` | `st_atim` |
| `st_mtim` | `st_mtimespec` | `st_mtim` | `st_mtim` | `st_mtim` | `st_mtim` | `st_mtim` |
| `st_ctim` | `st_ctimespec` | `st_ctim` | `st_ctim` | `st_ctim` | `st_ctim` | `st_ctim` |
| `st_birthtim` | `st_birthtimespec` | `st_birthtim` | N/A | N/A | N/A | N/A |
| `flags` | `st_flags` | `st_flags` | `st_flags` | N/A | N/A | N/A |
| `generationNumber` | `st_gen` | `st_gen` | `st_gen` | N/A | N/A | N/A |
#### `Stat.Flags` Mappings
| Swift Flag | Darwin | FreeBSD | OpenBSD | Linux | Android | WASI |
|------------|--------|---------|---------|-------|---------|------|
| `symlinkNoFollow` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` |
| `symlinkNoFollowAny` | `AT_SYMLINK_NOFOLLOW_ANY` | N/A | N/A | N/A | N/A | N/A |
| `resolveBeneath` | `AT_RESOLVE_BENEATH` | `AT_RESOLVE_BENEATH` | N/A | N/A | N/A | N/A |
| `emptyPath` | N/A | `AT_EMPTY_PATH` | N/A | `AT_EMPTY_PATH` | `AT_EMPTY_PATH` | N/A |
#### `FileFlags` Mappings
**Note:** `FileFlags` is only available on Darwin, FreeBSD, and OpenBSD.
| Swift Flag | Darwin | FreeBSD | OpenBSD |
|------------|--------|---------|---------|
| `noDump` | `UF_NODUMP` | `UF_NODUMP` | `UF_NODUMP` |
| `userImmutable` | `UF_IMMUTABLE` | `UF_IMMUTABLE` | `UF_IMMUTABLE` |
| `userAppend` | `UF_APPEND` | `UF_APPEND` | `UF_APPEND` |
| `archived` | `SF_ARCHIVED` | `SF_ARCHIVED` | `SF_ARCHIVED` |
| `systemImmutable` | `SF_IMMUTABLE` | `SF_IMMUTABLE` | `SF_IMMUTABLE` |
| `systemAppend` | `SF_APPEND` | `SF_APPEND` | `SF_APPEND` |
| `opaque` | `UF_OPAQUE` | `UF_OPAQUE` | N/A |
| `hidden` | `UF_HIDDEN` | `UF_HIDDEN` | N/A |
| `systemNoUnlink` | `SF_NOUNLINK` | `SF_NOUNLINK` | N/A |
| `compressed` | `UF_COMPRESSED` | N/A | N/A |
| `tracked` | `UF_TRACKED` | N/A | N/A |
| `dataVault` | `UF_DATAVAULT` | N/A | N/A |
| `restricted` | `SF_RESTRICTED` | N/A | N/A |
| `firmlink` | `SF_FIRMLINK` | N/A | N/A |
| `dataless` | `SF_DATALESS` | N/A | N/A |
| `userNoUnlink` | N/A | `UF_NOUNLINK` | N/A |
| `offline` | N/A | `UF_OFFLINE` | N/A |
| `readOnly` | N/A | `UF_READONLY` | N/A |
| `reparse` | N/A | `UF_REPARSE` | N/A |
| `sparse` | N/A | `UF_SPARSE` | N/A |
| `system` | N/A | `UF_SYSTEM` | N/A |
| `snapshot` | N/A | `SF_SNAPSHOT` | N/A |
+190
View File
@@ -0,0 +1,190 @@
# Add support for `dup3` and `pipe2` POSIX API to `FileDescriptor`
* Proposal: SYS-0007
* Authors: Jake Petroules <jake.petroules@apple.com>, Guillaume Lessard <guillaume.lessard@apple.com>
* Other Reviews: [Swift Forums Pitch](https://forums.swift.org/t/82486)
#### Revision history
* **v1** Initial version
* **v2** Add Windows version of `pipe(options:)`
* **v3** Add Darwin versions of `dup3` and `pipe2` wrappers
## Introduction
Swift System today provides `FileDescriptor.duplicate()`, `FileDescriptor.duplicate(as:)` and `FileDescriptor.pipe()` cover APIs for the POSIX `dup`, `dup2`, and `pipe` functions, respectively.
This proposal adds additional `FileDescriptor` overloads to cover new POSIX 2024 functions in this family of APIs. These overloads will be available on Linux, FreeBSD, Android, and the Apple operating systems based on Darwin 27.0 or newer; `pipe(options:)` will also be available on Windows.
## Motivation
It is considered best practice to set the `O_CLOEXEC` (close-on-exec) bit on newly created file descriptors to prevent them from being inherited by subprocesses.
Some POSIX functions such as `open` provide a "flags" parameter allowing the close-on-exec bit to be set atomically on the newly created file descriptor. However, others provide no such flags parameter, and require the caller to use `fcntl` to set the close-on-exec bit after the fact. This can lead to race conditions and security bugs where file descriptors can be inherited between calling the function creating the file descriptor, and calling `fcntl`.
POSIX 2024 corrects this deficiency for `dup2` and `pipe` by introducing `dup3` and `pipe2` variants that allow the close-on-exec bit to be set atomically.
While it's *also* considered best practice for subprocess spawning code to close all open file descriptors in the newly created subprocess (swiftlang/swift-subprocess does this for example), there is no guarantee that a user of Swift System is using a mechanism which does so throughout their entire process, and might be using process spawning code they don't control. Adding the proposed overloads will allow developers to write code which adopts a posture of defense in depth with respect to opened file descriptors.
## Proposed solution
This proposal adds new overloads to `FileDescriptor.duplicate(as:)` and `FileDescriptor.pipe()` that will wrap the functionality of the `dup3` and `pipe2` functions.
## Example usage
```swift
import System
let fd0 = try FileDescriptor.open("/tmp/test.txt", .readOnly)
let fd1 = FileDescriptor(rawValue: 731)
let fd2 = try fd0.duplicate(as: fd1, options: [.closeOnFork, .closeOnExec])
```
## Detailed design
`FileDescriptor` will add the following overloads and types:
```swift
struct FileDescriptor {
/// Creates a unidirectional data channel, which can be used for
/// interprocess communication.
///
/// NOTE: This overload called with an empty option set is not necessarily
/// equivalent to calling the overload with no options. On Windows, the
/// no-parameter `pipe()` overload enables the `.closeOnExec` behaviour,
/// but this overload disables it when called with an empty option set.
///
/// - Parameters:
/// - options: The behavior for creating the pipe.
///
/// - Returns: The pair of file descriptors.
///
/// The corresponding C function is `pipe2`.
public static func pipe(
options: PipeOptions
) throws(Errno) -> (readEnd: FileDescriptor, writeEnd: FileDescriptor)
/// Duplicate this file descriptor and return the newly created copy.
///
/// - Parameters:
/// - target: The desired target file descriptor.
/// - options: The behavior for creating the target file descriptor.
/// - retryOnInterrupt: Whether to retry the operation
/// if it throws ``Errno/interrupted``. The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The new file descriptor.
///
/// If the `target` descriptor is the same as `self`, then EINVAL is thrown.
/// If the `target` descriptor is already in use, then it is first
/// deallocated as if a close(2) call had been done first.
///
/// NOTE: This overload called with an empty option set is not necessarily
/// equivalent to calling the overload with no options, because `dup3` with
/// no set options is not required to behave identically to `dup2`.
///
/// File descriptors are merely references to some underlying system resource.
/// The system does not distinguish between the original and the new file
/// descriptor in any way. For example, read, write and seek operations on
/// one of them also affect the logical file position in the other, and
/// append mode, non-blocking I/O and asynchronous I/O options are shared
/// between the references. If a separate pointer into the file is desired,
/// a different object reference to the file must be obtained by issuing an
/// additional call to `open`.
///
/// However, each file descriptor maintains its own close-on-exec and
/// close-on-fork flags.
///
/// The corresponding C function is `dup3`.
@discardableResult
public func duplicate(
as target: FileDescriptor,
options: DuplicateOptions,
retryOnInterrupt: Bool = true
) throws(Errno) -> FileDescriptor
/// Options that specify behavior for a newly-created pipe.
public struct PipeOptions: OptionSet, Sendable, Hashable, Codable {
/// The raw C options.
public var rawValue: CInt
/// Create a strongly-typed options value from raw C options.
public init(rawValue: CInt)
/// Indicates that all subsequent input and output operations
/// on the pipe's file descriptors will be nonblocking.
///
/// The corresponding C constant is `O_NONBLOCK`.
public static var nonBlocking: PipeOptions
/// Indicates that executing a program closes the file.
///
/// Normally, file descriptors remain open across calls to the `exec(2)`
/// family of functions. If you specify this option, the system closes the
/// file descriptor when replacing this process with another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOEXEC`.
public static var closeOnExec: PipeOptions
/// Indicates that forking a program closes the file.
///
/// Normally, file descriptors remain open across calls to the `fork(2)`
/// function. If you specify this option, the system closes the file
/// descriptor when forking this process into another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOFORK`.
public static var closeOnFork: PipeOptions
}
/// Options that specify behavior for a duplicated file descriptor.
public struct DuplicateOptions: OptionSet, Sendable, Hashable, Codable {
/// The raw C options.
public var rawValue: CInt
/// Create a strongly-typed options value from raw C options.
public init(rawValue: CInt)
/// Indicates that executing a program closes the file.
///
/// Normally, file descriptors remain open across calls to the `exec(2)`
/// family of functions. If you specify this option, the system closes the
/// file descriptor when replacing this process with another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOEXEC`.
public static var closeOnExec: DuplicateOptions
/// Indicates that forking a program closes the file.
///
/// Normally, file descriptors remain open across calls to the `fork(2)`
/// function. If you specify this option, the system closes the file
/// descriptor when forking this process into another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOFORK`.
public static var closeOnFork: DuplicateOptions
}
}
```
`pipe(options:)` is added for Windows with the option `.closeOnExec`, but `duplicate(as:options:)` is not added because the underlying API does not match `dup3`.
`closeOnFork` is unavailable on Linux and Android, as the underlying `O_CLOFORK` constant does not exist.
## Impact on existing code
This change will have no impact on existing code, as it is purely additive.
## Alternatives considered
None. The underlying POSIX API are additions that help C developers follow best practices, and these overloads provide the same value to Swift developers.
+262
View File
@@ -0,0 +1,262 @@
# Back-Deploy CInterop.stat for Migration Compatibility
* Proposal: SYS-0008
* Author: [Jonathan Flat](https://github.com/jrflat)
* Status: **Awaiting review**
* Implementation: [apple/swift-system#299](https://github.com/apple/swift-system/pull/299)
* Review: ([pitch](https://forums.swift.org/t/pitch-back-deploy-system-cinterop-stat-for-migration-compatibility/84930))
#### Revision history
* **v1** Initial version
* **v2** Clarify that `CInterop.stat(_:_:)` is a new function
* **v3** Explain why this proposal should not set a precedence for future System APIs
## Introduction
This proposal introduces `CInterop.stat(_:_:)` and back-deploys the `CInterop.Stat` typealias from System to make them available on older OS versions, enabling a migration path for clients who may encounter naming conflicts with `FilePath.stat()` or `FileDescriptor.stat()` when System's new `Stat` API ships.
## Motivation
The introduction of `FilePath.stat()` and `FileDescriptor.stat()` in [SYS-0006](0006-system-stat.md) creates a potential source compatibility issue for a small number of clients. While we estimate this affects an exceedingly rare set of developers (1 case found in public GitHub repositories), we want to provide a clear migration path.
### Compatibility scenario
Some clients may have extended `FilePath` or `FileDescriptor` with custom functions that use `Darwin.stat()` and `Darwin.stat(_:_:)` **without** the `Darwin.` (or other libc) module qualification inside the function body:
```swift
extension FilePath {
func isRegularFile() -> Bool {
var s = stat() // Calls Darwin.stat(_:_:) - unqualified!
guard stat(self.string, &s) == 0 else { // Calls Darwin.stat(_:_:) - unqualified!
return false
}
return s.st_mode & S_IFMT == S_IFREG
}
}
```
When the new `FilePath.stat()` API from SYS-0006 ships, these unqualified calls to `stat()` and `stat(_:_:)` will refer to the new instance method, causing build errors:
```
error: Call can throw, but it is not marked with 'try' and the error is not handled
error: Use of 'stat' refers to instance method rather than global function 'stat' in module 'Darwin'
```
### Why not just use `Darwin.stat`?
Clients could resolve the ambiguity by qualifying their calls with `Darwin.`, `Glibc.`, etc. However, this approach has several limitations:
1. **Cross-platform code**: Clients writing code for multiple platforms would need platform-specific `#if` blocks with code for each platform's libc module.
2. **Awkward syntax**: Due to the overload between the `stat` type and `stat(_:_:)` function, clients must use the verbose `Darwin.stat(_:_:)(path, &s)` syntax to call the function, which is unintuitive.
3. **Older deployment targets**: Clients supporting older deployment targets can't use the new `System.Stat` API on older OS versions but still need to avoid build breakage when compiled with an SDK that includes the new `FilePath.stat()`
By back-deploying `CInterop.stat(_:_:)` to `System 0.0.2 (macOS 12.0, iOS 15.0)`, we provide a cross-platform, ergonomic solution: clients can replace `stat(_:_:)` with `CInterop.stat(_:_:)` for older deployment targets, and use the new `Stat` API moving forward.
## Proposed solution
Back-deploy `CInterop.Stat` and `CInterop.stat(_:_:)` to `@available(System 0.0.2, *)`, making them available on `macOS 12.0, iOS 15.0` and aligned. Note that `System 0.0.2` already maps to earliest source availability when System is used as a package, so the back-deployment is only relevant for System as an OS framework.
### API Overview
```swift
#if !os(Windows)
@available(System 0.0.2, *) // Original availability of CInterop
extension CInterop {
public typealias Stat = stat
@_alwaysEmitIntoClient
public static func stat(_ path: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32
}
#endif
```
The implementation uses `@_alwaysEmitIntoClient` to make the function available on older OS versions by embedding the implementation in client code. This makes sense for a widely-available and standardized C function like `stat()`.
### Migration guidance
If you have `FilePath` or `FileDescriptor` extensions that use unqualified `stat()` calls and need to support older deployment targets, migrate to `CInterop.Stat` (type) and `CInterop.stat(_:_:)` (function):
#### Before:
```swift
extension FilePath {
func isRegularFile() throws -> Bool {
var s = stat()
guard stat(self.string, &s) == 0 else {
throw Errno.current
}
return s.st_mode & S_IFMT == S_IFREG
}
}
```
#### After:
```swift
extension FilePath {
func isRegularFile() throws -> Bool {
var s = CInterop.Stat() // stat() --> CInterop.Stat()
guard CInterop.stat(self.string, &s) == 0 else { // stat(_:_:) --> CInterop.stat(_:_:)
throw Errno.current
}
return s.st_mode & S_IFMT == S_IFREG
}
}
```
#### Migrate to the new `Stat` API:
Migrate to the more ergonomic interface on newer OS versions using `if #available`:
```swift
extension FilePath {
func isRegularFile() throws -> Bool {
if #available(macOS X, iOS Y, *) {
return try stat().type == .regular // Calls FilePath.stat()
}
var s = CInterop.Stat()
guard CInterop.stat(self.string, &s) == 0 else {
throw Errno.current
}
return s.st_mode & S_IFMT == S_IFREG
}
}
```
Alternatively, you may use just the new API if your deployment target supports it.
#### Who should use `CInterop.stat(_:_:)`?
This scenario is rare and only occurs when a project meets **all** of the following conditions:
1. Has a custom extension on `FilePath` or `FileDescriptor`, that
2. Uses **unqualified** `stat()` or `stat(_:_:)` calls inside that method, and
3. Needs to support deployment targets older than the new `Stat` API availability
If your code uses qualified calls, e.g. `Darwin.stat()`, or uses a wrapper around `stat()` already, it is **not** affected by this issue and no migration is needed.
## Detailed design
### CInterop extension
```swift
#if !os(Windows)
@available(System 0.0.2, *) // Original availability of CInterop
extension CInterop {
/// The C `stat` struct.
public typealias Stat = stat
/// Calls the C `stat()` function.
///
/// This is a direct wrapper around the C `stat()` system call.
/// For a more ergonomic Swift API, use `Stat` instead.
///
/// - Warning: This API is primarily intended for migration purposes when
/// supporting older deployment targets. If your deployment target supports
/// it, prefer using the `Stat` API introduced in SYS-0006, which provides
/// type-safe, ergonomic access to file metadata in Swift.
///
/// - Parameters:
/// - path: A null-terminated C string representing the file path.
/// - s: An `inout` reference to a `CInterop.Stat` struct to populate.
/// - Returns: 0 on success, -1 on error (check `Errno.current`).
@_alwaysEmitIntoClient
public static func stat(_ path: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
system_stat(path, &s)
}
}
#endif
```
### Internal wrapper
The `system_stat` wrapper is also marked `@_alwaysEmitIntoClient` so it can be inlined. `system_stat` calls the global `stat` function for the current platform.
```swift
#if !os(Windows)
@_alwaysEmitIntoClient
internal func system_stat(_ path: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
stat(path, &s)
}
#endif
```
## Source compatibility
This proposal is additive and source-compatible.
## ABI compatibility
This proposal is ABI-compatible. The use of `@_alwaysEmitIntoClient` ensures that the implementation is embedded in client code.
## Implications on adoption
Clients can adopt `CInterop.Stat` and `CInterop.stat(_:_:)` to support older deployment targets when building with the new SDK.
## Future directions
Once clients can raise their deployment targets to support the new `Stat` API introduced in SYS-0006, they should migrate to it, which provides:
- Type-safe, ergonomic Swift interfaces
- Strongly-typed wrappers (`FileType`, `FileMode`, `FilePermissions`, etc.)
- Proper error handling with typed throws
## Why this should not set a precedent for CInterop functions
We should not expose `CInterop` functions for most, if not all, other methods that shadow a global function. `stat` is a special case for a few reasons:
- Many other syscalls gain a more Swift-y API name, e.g. `dup/dup2` → `duplicate(as:)`, `ftruncate` → `resize(to:)`, `umask` → `FilePermissions.creationMask` if that becomes API, etc. Those renames mean user extensions are unlikely to collide with future System API. `stat` is one of the few syscalls whose C name is already clear and idiomatic enough to use directly as the Swift API name.
- Many syscalls that do keep their C name (e.g. `open`, `close`, `read`, `write`) have been in System since the beginning, so there was never a window where someone would have needed to create their own extension for that functionality.
- `stat` is both widely used and was missing from System for some time, which creates a better chance for migration friction.
- Other syscalls that could be added to System naturally disambiguate through parameter labels. Names like `rename`, `link`, and `unlink` would require non-optional arguments (e.g. `rename(to:)`, `link(to:)`), so their Swift signatures wouldn't collide with the bare C functions. `stat` is unusual in that it works as a zero-argument call on `FilePath`/`FileDescriptor` and has the same shape as the global C `stat()` struct initializer.
## Alternatives considered
### Do nothing
We could choose not to provide a migration path and let affected clients handle the ambiguity by:
1. Qualifying their calls with platform-specific modules (e.g. `Darwin.stat`)
2. Wrapping `stat()` in another function
3. Raising their deployment target to use the new `Stat` API
However, this creates an unnecessary burden for the (admittedly rare) affected clients, especially those who need to maintain backward compatibility with older OS versions.
### Use a different name for `FilePath.stat()`
We could use a different name such as `FilePath.statInfo()`, `FilePath.status()`, `FilePath.Stat()`, or `FilePath.fileInfo()`. However, considering the rarity of the issue, changing to a less concise, discoverable, and expressive function name is not preferrable when we can offer a migration solution.
### Create `stat()` overloads directly on `FilePath`
We could create `stat()` extensions on `FilePath` within System that guide a developer to use the new instance method via `try stat()`, e.g:
```swift
extension FilePath {
@available(*, deprecated, message: "Use 'try stat()' in your FilePath extension to get a System.Stat instead. Then, use '.rawValue' to get the underlying C type if desired.")
public func stat() -> CInterop.Stat {
CInterop.Stat()
}
@available(*, deprecated, message: "Use 'try stat()' in your FilePath extension to get a System.Stat instead. Then, use '.rawValue' to get the underlying C type if desired.")
public func stat(
_ path: UnsafePointer<CChar>,
_ s: inout CInterop.Stat
) -> Int32 {
system_stat(path, &s)
}
}
```
This is beneficial because it prevents any SDK breakage with only a System change. However, this is not a great long-term solution to have as public API because:
- It makes choosing the right `stat()` more confusing with 5 total overloads.
- It hurts discoverability for the new `Stat` API.
### Expose the internal `system_stat` wrapper directly
This would achieve the same effect as exposing `CInterop.stat(_:_:)`, but goes against the API naming/organization patterns in System. `CInterop` seems like a clear place for the direct C `stat` wrapper to belong.
### Back-deploy the full `Stat` API
Unlike functions and typealiases, types such as `Stat`, `FileType`, `FileMode`, etc. would require significant coordination and effort to back-deploy, making this alternative less desirable, especially considering it's not required to address the issue.
+13 -10
View File
@@ -32,7 +32,7 @@ To use the `SystemPackage` library in a SwiftPM project,
add the following line to the dependencies in your `Package.swift` file:
```swift
.package(url: "https://github.com/apple/swift-system", from: "1.6.1"),
.package(url: "https://github.com/apple/swift-system", from: "1.8.0"),
```
Finally, include `"SystemPackage"` as a dependency for your executable target:
@@ -41,7 +41,7 @@ Finally, include `"SystemPackage"` as a dependency for your executable target:
let package = Package(
// name, platforms, products, etc.
dependencies: [
.package(url: "https://github.com/apple/swift-system", from: "1.6.1"),
.package(url: "https://github.com/apple/swift-system", from: "1.8.0"),
// other dependencies
],
targets: [
@@ -87,7 +87,8 @@ The following table maps existing package releases to their minimum required Swi
| Package version | Swift version | Xcode release |
| ----------------------- | --------------- | ------------- |
| swift-system 1.3.x | >= Swift 5.8 | >= Xcode 14.3 |
| swift-system 1.4.x through 1.6.x | >= Swift 5.9 | >= Xcode 15.0 |
| swift-system 1.4.0 through 1.6.x | >= Swift 5.9 | >= Xcode 15.0 |
| swift-system 1.7.0 through 1.8.x | >= Swift 6.1 | >= Xcode 16.3 |
We'd like this package to quickly embrace Swift language and toolchain improvements that are relevant to its mandate. Accordingly, from time to time, new versions of this package require clients to upgrade to a more recent Swift toolchain release. (This allows the package to make use of new language/stdlib features, build on compiler bug fixes, and adopt new package manager functionality as soon as they are available.) Patch (i.e., bugfix) releases will not increase the required toolchain version, but any minor (i.e., new feature) release may do so.
@@ -107,17 +108,19 @@ We maintain separate branches for each active minor version of the package:
| Package version | Branch |
| ----------------------- | ----------- |
| swift-system 1.3.x | release/1.3 |
| swift-system 1.4.x | release/1.4 |
| swift-system 1.5.x | release/1.5 |
| swift-system 1.6.x | release/1.6 |
| swift-system 1.7.x (unreleased) | main |
| swift-system 1.3.x | release/1.3.0 |
| swift-system 1.4.x | release/1.4.0 |
| swift-system 1.5.x | release/1.5.0 |
| swift-system 1.6.x | release/1.6.0 |
| swift-system 1.7.x | release/1.7.0 |
| swift-system 1.8.x | release/1.8.x |
| swift-system 1.9.x (unreleased) | |
Changes must land on the branch corresponding to the earliest release that they will need to ship on. They are periodically propagated to subsequent branches, in the following direction:
`release/1.3` → `release/1.4` → `main`
`release/1.7.0` → `release/1.8.x` → `main`
For example, anything landing on `release/1.3` will eventually appear on `release/1.4` and then `main` too; there is no need to file standalone PRs for each release line. (Change propagation currently requires manual work -- it is performed by project maintainers.)
For example, anything landing on `release/1.6.0` will eventually appear on `release/1.7.0`, then `release/1.8.x` and finally `main` as well. There is no need to file standalone PRs for each release line. (Change propagation currently requires manual work -- it is performed by project maintainers.)
### Code of Conduct
+6 -4
View File
@@ -1,20 +1,22 @@
#[[
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
#]]
add_library(CSystem INTERFACE)
target_include_directories(CSystem INTERFACE
add_library(CSystem STATIC shims.c)
target_include_directories(CSystem PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
$<INSTALL_INTERFACE:include/CSystem>)
install(FILES
include/CSystemLinux.h
include/CSystemWindows.h
include/CSystemShared.h
include/CSystemWASI.h
include/io_uring.h
include/module.modulemap
DESTINATION include/CSystem)
set_property(GLOBAL APPEND PROPERTY SWIFT_SYSTEM_EXPORTS CSystem)
+20 -14
View File
@@ -1,7 +1,7 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
@@ -9,18 +9,24 @@
#ifdef __linux__
#include <sys/epoll.h>
// Glibc doesn't export eventfd, which the tests use.
#include <sys/eventfd.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/sysinfo.h>
#include <sys/timerfd.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <sched.h>
#include <unistd.h>
#include "io_uring.h"
#endif
#if !defined(__ANDROID__)
#include <stddef.h>
#include "io_uring.h"
// Defined in shims.c, which can include the libc headers they need.
extern int csystem_io_uring_setup(unsigned int entries,
struct io_uring_params *p);
extern int csystem_io_uring_enter(int fd, unsigned int to_submit,
unsigned int min_complete,
unsigned int flags, void *sig);
extern int csystem_io_uring_enter2(int fd, unsigned int to_submit,
unsigned int min_complete,
unsigned int flags, void *args, size_t sz);
extern int csystem_io_uring_register(int fd, unsigned int opcode, void *arg,
unsigned int nr_args);
#endif // !defined(__ANDROID__)
#endif // __linux__
@@ -1,17 +1,14 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
#if defined(_WIN32)
#define NOMINMAX
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRA_LEAN
#include <Windows.h>
#if !defined(_WIN32)
extern int csystem_posix_pipe2(int fildes[2], int flag);
#endif
extern int csystem_posix_dup3(int fildes, int fildes2, int flag);
+10 -47
View File
@@ -1,7 +1,6 @@
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/uio.h>
#include <signal.h>
#pragma once
// Types only: the syscall wrappers need libc headers, so they're in shims.c.
#define __SWIFT_IORING_SQE_FALLBACK_STRUCT { \
__u8 opcode; \
@@ -81,7 +80,7 @@
#ifdef IORING_TIMEOUT_BOOTTIME
// Kernel version >= 5.15, io_uring_sqe has file_index
// and all current Swift operations are supported.
#define __SWIFT_IORING_SUPPORTED true
#define __SWIFT_IORING_SUPPORTED 1
typedef struct io_uring_sqe swift_io_uring_sqe;
#else
// io_uring_sqe is missing properties that IORequest expects.
@@ -89,7 +88,7 @@ typedef struct io_uring_sqe swift_io_uring_sqe;
//
// Define a fallback struct to avoid build errors, but IORing
// will throw ENOTSUP on initialization.
#define __SWIFT_IORING_SUPPORTED false
#define __SWIFT_IORING_SUPPORTED 0
typedef struct __SWIFT_IORING_SQE_FALLBACK_STRUCT swift_io_uring_sqe;
#endif
@@ -107,13 +106,14 @@ typedef struct __SWIFT_IORING_SQE_FALLBACK_STRUCT swift_io_uring_sqe;
// Minimal fallback definitions when linux/io_uring.h is not available (e.g. static SDK)
#include <stdint.h>
#define __SWIFT_IORING_SUPPORTED false
#define __SWIFT_IORING_SUPPORTED 0
#define IORING_OFF_SQ_RING 0ULL
#define IORING_OFF_CQ_RING 0x8000000ULL
#define IORING_OFF_SQES 0x10000000ULL
#define IORING_ENTER_GETEVENTS (1U << 0)
#define IORING_ENTER_GETEVENTS (1U << 0)
#define IORING_ENTER_EXT_ARG (1U << 3)
#define IORING_FEAT_SINGLE_MMAP (1U << 0)
#define IORING_FEAT_NODROP (1U << 1)
@@ -134,11 +134,13 @@ typedef struct __SWIFT_IORING_SQE_FALLBACK_STRUCT swift_io_uring_sqe;
#define IORING_FEAT_RW_ATTR (1U << 16)
#define IORING_FEAT_NO_IOWAIT (1U << 17)
#if !defined(_ASM_GENERIC_INT_LL64_H) && !defined(_ASM_GENERIC_INT_L64_H) && !defined(_UAPI_ASM_GENERIC_INT_LL64_H) && !defined(_UAPI_ASM_GENERIC_INT_L64_H)
typedef uint8_t __u8;
typedef uint16_t __u16;
typedef uint32_t __u32;
typedef uint64_t __u64;
typedef int32_t __s32;
#endif
#ifndef __kernel_rwf_t
typedef int __kernel_rwf_t;
@@ -190,19 +192,6 @@ struct io_uring_params {
};
#endif // __has_include(<linux/io_uring.h>)
#ifndef SWIFT_IORING_C_WRAPPER
#define SWIFT_IORING_C_WRAPPER
# ifndef __NR_io_uring_setup
# define __NR_io_uring_setup 425
# endif
# ifndef __NR_io_uring_enter
# define __NR_io_uring_enter 426
# endif
# ifndef __NR_io_uring_register
# define __NR_io_uring_register 427
# endif
/*
struct io_uring_getevents_arg {
__u64 sigmask;
@@ -217,29 +206,3 @@ struct swift_io_uring_getevents_arg {
__u32 min_wait_usec;
__u64 ts;
};
static inline int io_uring_register(int fd, unsigned int opcode, void *arg,
unsigned int nr_args)
{
return syscall(__NR_io_uring_register, fd, opcode, arg, nr_args);
}
static inline int io_uring_setup(unsigned int entries, struct io_uring_params *p)
{
return syscall(__NR_io_uring_setup, entries, p);
}
static inline int io_uring_enter2(int fd, unsigned int to_submit, unsigned int min_complete,
unsigned int flags, void *args, size_t sz)
{
return syscall(__NR_io_uring_enter, fd, to_submit, min_complete,
flags, args, _NSIG / 8);
}
static inline int io_uring_enter(int fd, unsigned int to_submit, unsigned int min_complete,
unsigned int flags, sigset_t *sig)
{
return io_uring_enter2(fd, to_submit, min_complete, flags, sig, _NSIG / 8);
}
#endif
+12 -1
View File
@@ -1,6 +1,17 @@
// System imports CSystem with `internal import`. Don't include a header that
// the platform's C module also includes: CSystem would then co-own its
// declarations, so Swift would limit them to CSystem's import access level and
// could credit their members to CSystem under MemberImportVisibility.
// (CSystemWASI.h still does; see Constants.swift.)
module CSystem {
header "CSystemShared.h"
header "CSystemLinux.h"
header "CSystemWASI.h"
header "CSystemWindows.h"
export *
}
// IORing's inlinable code stores these types, so System imports this module
// with `public import`. Keep libc headers out of it too.
module CSystemIOUring {
header "io_uring.h"
}
+90 -5
View File
@@ -1,18 +1,103 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
#if defined(__FreeBSD__)
#define __BSD_VISIBLE
#endif
#if defined(__FreeBSD__) || defined(__OpenBSD__)
#include <unistd.h>
#endif
#ifdef __linux__
#define _GNU_SOURCE
#include <signal.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <CSystemLinux.h>
#endif
#if defined(_WIN32)
#include <CSystemWindows.h>
#include <errno.h>
#if !defined(_WIN32) && !defined(__wasi__) && !defined(__APPLE__)
#define HAVE_PIPE2_DUP3
#endif
#if defined(__APPLE__)
#include <Availability.h>
#if defined(__MAC_27_0)
#include <unistd.h>
#define HAVE_PIPE2_DUP3
#endif
#endif // defined(__APPLE__)
// Wrappers are required because _GNU_SOURCE causes a conflict with other imports when defined in CSystemLinux.h
#if !defined(_WIN32)
extern int csystem_posix_pipe2(int fildes[2], int flag) {
#if defined(__APPLE__) && defined(HAVE_PIPE2_DUP3)
if (__builtin_available(macOS 27, iOS 27, tvOS 27, watchOS 27, visionOS 27, *))
return pipe2(fildes, flag);
__builtin_trap();
#elif defined(HAVE_PIPE2_DUP3)
return pipe2(fildes, flag);
#else
errno = ENOSYS;
return -1;
#endif
}
#endif // !defined(_WIN32)
extern int csystem_posix_dup3(int fildes, int fildes2, int flag) {
#if defined(__APPLE__) && defined(HAVE_PIPE2_DUP3)
if (__builtin_available(macOS 27, iOS 27, tvOS 27, watchOS 27, visionOS 27, *))
return dup3(fildes, fildes2, flag);
__builtin_trap();
#elif defined(HAVE_PIPE2_DUP3)
return dup3(fildes, fildes2, flag);
#else
errno = ENOSYS;
return -1;
#endif
}
#if defined(__linux__) && !defined(__ANDROID__)
# ifndef __NR_io_uring_setup
# define __NR_io_uring_setup 425
# endif
# ifndef __NR_io_uring_enter
# define __NR_io_uring_enter 426
# endif
# ifndef __NR_io_uring_register
# define __NR_io_uring_register 427
# endif
extern int csystem_io_uring_setup(unsigned int entries,
struct io_uring_params *p) {
return syscall(__NR_io_uring_setup, entries, p);
}
extern int csystem_io_uring_enter2(int fd, unsigned int to_submit,
unsigned int min_complete,
unsigned int flags, void *args, size_t sz) {
return syscall(__NR_io_uring_enter, fd, to_submit, min_complete, flags,
args, sz);
}
extern int csystem_io_uring_enter(int fd, unsigned int to_submit,
unsigned int min_complete,
unsigned int flags, void *sig) {
return csystem_io_uring_enter2(fd, to_submit, min_complete, flags, sig,
_NSIG / 8);
}
extern int csystem_io_uring_register(int fd, unsigned int opcode, void *arg,
unsigned int nr_args) {
return syscall(__NR_io_uring_register, fd, opcode, arg, nr_args);
}
#endif // defined(__linux__) && !defined(__ANDROID__)
+42 -1
View File
@@ -9,6 +9,7 @@ See https://swift.org/LICENSE.txt for license information
add_library(SystemPackage
Errno.swift
ErrnoWindows.swift
FileDescriptor.swift
FileHelpers.swift
FileOperations.swift
@@ -18,9 +19,32 @@ add_library(SystemPackage
SystemString.swift
Util.swift
Util+StringArray.swift
UtilConsumers.swift)
UtilConsumers.swift
WinSDK+Overlay.swift)
set_target_properties(SystemPackage PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
# Availability macro definitions.
# Should stay in sync with the `availability` array in Package.swift,
# matching `sourceAvailability`, which is the minimum Swift availability.
# Availability support for Darwin platforms is omitted.
set(SWIFT_SYSTEM_AVAILABILITY_VERSIONS
0.0.1 0.0.2 0.0.3
1.1.0 1.1.1 1.2.0 1.2.1 1.3.0 1.3.1 1.3.2 1.4.0
1.7.0
199)
set(SWIFT_SYSTEM_SOURCE_AVAILABILITY
"macOS 10.10, iOS 8.0, watchOS 2.0, tvOS 9.0, visionOS 1.0")
set(SWIFT_SYSTEM_AVAILABILITY_MACRO)
foreach(version IN LISTS SWIFT_SYSTEM_AVAILABILITY_VERSIONS)
list(APPEND SWIFT_SYSTEM_AVAILABILITY_MACRO
"SHELL:-enable-experimental-feature \"AvailabilityMacro=System ${version}:${SWIFT_SYSTEM_SOURCE_AVAILABILITY}\"")
endforeach()
target_compile_options(SystemPackage PRIVATE
-enable-experimental-feature Lifetimes
${SWIFT_SYSTEM_AVAILABILITY_MACRO}
"SHELL:-package-name swift-system")
target_sources(SystemPackage PRIVATE
FilePath/FilePath.swift
FilePath/FilePathComponents.swift
@@ -28,7 +52,24 @@ target_sources(SystemPackage PRIVATE
FilePath/FilePathParsing.swift
FilePath/FilePathString.swift
FilePath/FilePathSyntax.swift
FilePath/FilePathTemp.swift
FilePath/FilePathTempPosix.swift
FilePath/FilePathTempWindows.swift
FilePath/FilePathWindows.swift)
target_sources(SystemPackage PRIVATE
FileSystem/FileFlags.swift
FileSystem/FileMode.swift
FileSystem/FileType.swift
FileSystem/Identifiers.swift
FileSystem/Stat.swift)
if(CMAKE_SYSTEM_NAME STREQUAL Linux)
target_sources(SystemPackage PRIVATE
IORing/IOCompletion.swift
IORing/IORequest.swift
IORing/IORing.swift
IORing/IORing+Util.swift
IORing/RawIORequest.swift)
endif()
target_sources(SystemPackage PRIVATE
Internals/Backcompat.swift
Internals/CInterop.swift
+3 -3
View File
@@ -1,7 +1,7 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 - 2024 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2024 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
@@ -160,7 +160,7 @@ public struct Errno: RawRepresentable, Error, Hashable, Codable {
/// No child processes.
///
/// A `wait(2)` or `waitpid(2)` function was executed
/// by a process that dosn't have any existing child processes
/// by a process that doesn't have any existing child processes
/// or whose child processes are all already being waited for.
///
/// The corresponding C error is `ECHILD`.
@@ -961,7 +961,7 @@ public struct Errno: RawRepresentable, Error, Hashable, Codable {
/// Stale NFS file handle.
///
/// You attempted access an open file on an NFS filesystem,
/// You attempted access an open file on an NFS file system,
/// which is now unavailable as referenced by the given file descriptor.
/// This may indicate that the file was deleted on the NFS server
/// or that some other catastrophic event occurred.
+133 -8
View File
@@ -1,7 +1,7 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2021 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
@@ -301,17 +301,14 @@ extension FileDescriptor {
public static var O_EVTONLY: OpenOptions { eventOnly }
#endif
#if !os(Windows)
/// Indicates that executing a program closes the file.
///
/// Normally, file descriptors remain open
/// across calls to the `exec(2)` family of functions.
/// If you specify this option,
/// the file descriptor is closed when replacing this process
/// with another process.
/// If you specify this option, the system closes the file
/// descriptor when replacing this process with another process.
///
/// The state of the file
/// descriptor flags can be inspected using `F_GETFD`,
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOEXEC`.
@@ -321,6 +318,135 @@ extension FileDescriptor {
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnExec")
public static var O_CLOEXEC: OpenOptions { closeOnExec }
#if os(Windows)
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnExec")
public static var O_NOINHERIT: OpenOptions { closeOnExec }
#endif
}
/// Options that specify behavior for a newly-created pipe.
@frozen
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
public struct PipeOptions: OptionSet, Sendable, Hashable, Codable {
/// The raw C options.
@_alwaysEmitIntoClient
public var rawValue: CInt
/// Create a strongly-typed options value from raw C options.
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
#if !os(Windows)
/// Indicates that all subsequent input and output operations
/// on the pipe's file descriptors will be nonblocking.
///
/// The corresponding C constant is `O_NONBLOCK`.
@_alwaysEmitIntoClient
public static var nonBlocking: PipeOptions { .init(rawValue: _O_NONBLOCK) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "nonBlocking")
public static var O_NONBLOCK: PipeOptions { nonBlocking }
#endif // !os(Windows)
/// Indicates that executing a program closes the file.
///
/// Normally, file descriptors remain open
/// across calls to the `exec(2)` family of functions.
/// If you specify this option, the system closes the file
/// descriptor when replacing this process with another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOEXEC`.
@_alwaysEmitIntoClient
public static var closeOnExec: PipeOptions { .init(rawValue: _O_CLOEXEC) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnExec")
public static var O_CLOEXEC: PipeOptions { closeOnExec }
#if os(Windows)
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnExec")
public static var O_NOINHERIT: PipeOptions { closeOnExec }
#endif
#if !os(Windows) && !os(WASI) && !os(Linux) && !os(Android)
/// Indicates that forking a program closes the file.
///
/// Normally, file descriptors remain open
/// across calls to the `fork(2)` function.
/// If you specify this option, the system closes the file
/// descriptor when forking this process into another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOFORK`.
@_alwaysEmitIntoClient
public static var closeOnFork: PipeOptions { .init(rawValue: _O_CLOFORK) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnFork")
public static var O_CLOFORK: PipeOptions { closeOnFork }
#endif
}
/// Options that specify behavior for a duplicated file descriptor.
@frozen
@available(Windows, unavailable)
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
public struct DuplicateOptions: OptionSet, Sendable, Hashable, Codable {
/// The raw C options.
@_alwaysEmitIntoClient
public var rawValue: CInt
/// Create a strongly-typed options value from raw C options.
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
#if !os(Windows)
/// Indicates that executing a program closes the file.
///
/// Normally, file descriptors remain open
/// across calls to the `exec(2)` family of functions.
/// If you specify this option, the system closes the file
/// descriptor when replacing this process with another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOEXEC`.
@_alwaysEmitIntoClient
public static var closeOnExec: DuplicateOptions { .init(rawValue: _O_CLOEXEC) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnExec")
public static var O_CLOEXEC: DuplicateOptions { closeOnExec }
#if !os(WASI) && !os(Linux) && !os(Android)
/// Indicates that forking a program closes the file.
///
/// Normally, file descriptors remain open
/// across calls to the `fork(2)` function.
/// If you specify this option, the system closes the file
/// descriptor when forking this process into another process.
///
/// You can inspect the file descriptor flag state using `F_GETFD`,
/// as described in the `fcntl(2)` man page.
///
/// The corresponding C constant is `O_CLOFORK`.
@_alwaysEmitIntoClient
public static var closeOnFork: DuplicateOptions { .init(rawValue: _O_CLOFORK) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnFork")
public static var O_CLOFORK: DuplicateOptions { closeOnFork }
#endif
#endif
}
@@ -398,7 +524,6 @@ extension FileDescriptor {
@available(*, unavailable, renamed: "nextData")
public static var SEEK_DATA: SeekOrigin { nextData }
#endif
}
}
+136 -17
View File
@@ -1,7 +1,7 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
@@ -16,6 +16,8 @@ extension FileDescriptor {
/// - mode: The read and write access to use.
/// - options: The behavior for opening the file.
/// - permissions: The file permissions to use for created files.
/// This value must not be `nil` when `options` contains `.create`;
/// passing `nil` in that case is a programmer error and traps at runtime.
/// - retryOnInterrupt: Whether to retry the open operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
@@ -55,6 +57,8 @@ extension FileDescriptor {
/// - mode: The read and write access to use.
/// - options: The behavior for opening the file.
/// - permissions: The file permissions to use for created files.
/// This value must not be `nil` when `options` contains `.create`;
/// passing `nil` in that case is a programmer error and traps at runtime.
/// - retryOnInterrupt: Whether to retry the open operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
@@ -88,8 +92,10 @@ extension FileDescriptor {
if let permissions = permissions {
return system_open(path, oFlag, permissions.rawValue)
}
precondition(!options.contains(.create),
"Create must be given permissions")
if options.contains(.create) {
fatalError(
"FileDescriptor.open: 'permissions' must not be nil when 'options' contains '.create'")
}
return system_open(path, oFlag)
}
return descOrError.map { FileDescriptor(rawValue: $0) }
@@ -102,6 +108,8 @@ extension FileDescriptor {
/// - mode: The read and write access to use.
/// - options: The behavior for opening the file.
/// - permissions: The file permissions to use for created files.
/// This value must not be `nil` when `options` contains `.create`;
/// passing `nil` in that case is a programmer error and traps at runtime.
/// - retryOnInterrupt: Whether to retry the open operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
@@ -222,7 +230,7 @@ extension FileDescriptor {
internal func _read(
into buffer: UnsafeMutableRawBufferPointer,
retryOnInterrupt: Bool
) throws -> Result<Int, Errno> {
) -> Result<Int, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_read(self.rawValue, buffer.baseAddress, buffer.count)
}
@@ -370,13 +378,13 @@ extension FileDescriptor {
#if !os(WASI)
@available(System 0.0.2, *)
extension FileDescriptor {
/// Duplicates this file descriptor and return the newly created copy.
/// Duplicates this file descriptor and returns the newly created copy.
///
/// - Parameters:
/// - `target`: The desired target file descriptor, or `nil`, in which case
/// the copy is assigned to the file descriptor with the lowest raw value
/// that is not currently in use by the process.
/// - retryOnInterrupt: Whether to retry the write operation
/// - retryOnInterrupt: Whether to retry the duplicate operation
/// if it throws ``Errno/interrupted``. The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The new file descriptor.
@@ -395,7 +403,6 @@ extension FileDescriptor {
///
/// However, each file descriptor maintains its own close-on-exec flag.
///
///
/// The corresponding C functions are `dup` and `dup2`.
@_alwaysEmitIntoClient
@available(System 0.0.2, *)
@@ -406,17 +413,77 @@ extension FileDescriptor {
try _duplicate(as: target, retryOnInterrupt: retryOnInterrupt).get()
}
/// Duplicate this file descriptor and return the newly created copy.
///
/// - Parameters:
/// - target: The desired target file descriptor.
/// - options: The behavior for creating the target file descriptor.
/// - retryOnInterrupt: Whether to retry the operation
/// if it throws ``Errno/interrupted``. The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The new file descriptor.
///
/// If the `target` descriptor is the same as `self`, then EINVAL is thrown.
/// If the `target` descriptor is already in use, then it is first
/// deallocated as if a close(2) call had been done first.
///
/// NOTE: This overload called with an empty option set is not necessarily
/// equivalent to calling the overload with no options, because `dup3` with
/// no set options is not required to behave identically to `dup2`.
///
/// File descriptors are merely references to some underlying system resource.
/// The system does not distinguish between the original and the new file
/// descriptor in any way. For example, read, write and seek operations on
/// one of them also affect the logical file position in the other, and
/// append mode, non-blocking I/O and asynchronous I/O options are shared
/// between the references. If a separate pointer into the file is desired,
/// a different object reference to the file must be obtained by issuing an
/// additional call to `open`.
///
/// However, each file descriptor maintains its own close-on-exec and
/// close-on-fork flags.
///
/// The corresponding C function is `dup3`.
@available(Windows, unavailable)
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
@_alwaysEmitIntoClient
@discardableResult
public func duplicate(
as target: FileDescriptor,
options: DuplicateOptions,
retryOnInterrupt: Bool = true
) throws(Errno) -> FileDescriptor {
let result = _duplicate(
as: target, options: options.rawValue, retryOnInterrupt: retryOnInterrupt
)
return try result.get()
}
@available(System 0.0.2, *)
@usableFromInline
internal func _duplicate(
as target: FileDescriptor?,
retryOnInterrupt: Bool
) throws -> Result<FileDescriptor, Errno> {
) -> Result<FileDescriptor, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
if let target = target {
return system_dup2(self.rawValue, target.rawValue)
if let target {
system_dup2(self.rawValue, target.rawValue)
} else {
system_dup(self.rawValue)
}
return system_dup(self.rawValue)
}.map(FileDescriptor.init(rawValue:))
}
@available(Windows, unavailable)
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
@usableFromInline
internal func _duplicate(
as target: FileDescriptor,
options: Int32,
retryOnInterrupt: Bool
) -> Result<FileDescriptor, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_dup3(self.rawValue, target.rawValue, options)
}.map(FileDescriptor.init(rawValue:))
}
@@ -431,26 +498,57 @@ extension FileDescriptor {
public func dup2() throws -> FileDescriptor {
fatalError("Not implemented")
}
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "duplicate")
public func dup3() throws -> FileDescriptor {
fatalError("Not implemented")
}
}
#endif
#endif // !os(WASI)
#if !os(WASI)
@available(System 1.1.0, *)
extension FileDescriptor {
/// Creates a unidirectional data channel, which can be used for interprocess communication.
/// Creates a unidirectional data channel, which can be used for
/// interprocess communication.
///
/// - Returns: The pair of file descriptors.
///
/// The corresponding C function is `pipe`.
@_alwaysEmitIntoClient
@available(System 1.1.0, *)
public static func pipe() throws -> (readEnd: FileDescriptor, writeEnd: FileDescriptor) {
public static func pipe(
) throws -> (readEnd: FileDescriptor, writeEnd: FileDescriptor) {
try _pipe().get()
}
/// Creates a unidirectional data channel, which can be used for
/// interprocess communication.
///
/// NOTE: This overload called with an empty option set is not necessarily
/// equivalent to calling the overload with no options. On Windows, the
/// no-parameter `pipe()` overload enables the `.closeOnExec` behaviour,
/// but this overload disables it when called with an empty option set.
///
/// - Parameters:
/// - options: The behavior for creating the pipe.
///
/// - Returns: The pair of file descriptors.
///
/// The corresponding C function is `pipe2`.
@_alwaysEmitIntoClient
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
public static func pipe(
options: PipeOptions
) throws(Errno) -> (readEnd: FileDescriptor, writeEnd: FileDescriptor) {
try _pipe(options: options.rawValue).get()
}
@available(System 1.1.0, *)
@usableFromInline
internal static func _pipe() -> Result<(readEnd: FileDescriptor, writeEnd: FileDescriptor), Errno> {
internal static func _pipe(
) -> Result<(readEnd: FileDescriptor, writeEnd: FileDescriptor), Errno> {
var fds: (Int32, Int32) = (-1, -1)
return withUnsafeMutablePointer(to: &fds) { pointer in
pointer.withMemoryRebound(to: Int32.self, capacity: 2) { fds in
@@ -460,8 +558,29 @@ extension FileDescriptor {
}
}
}
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
@usableFromInline
internal static func _pipe(
options: Int32,
) -> Result<(readEnd: FileDescriptor, writeEnd: FileDescriptor), Errno> {
var fds: (Int32, Int32) = (-1, -1)
return withUnsafeMutablePointer(to: &fds) { pointer in
pointer.withMemoryRebound(to: Int32.self, capacity: 2) { fds in
valueOrErrno(retryOnInterrupt: false) {
system_pipe2(fds, options)
}.map { _ in (.init(rawValue: fds[0]), .init(rawValue: fds[1])) }
}
}
}
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "pipe")
public static func pipe2() throws -> FileDescriptor {
fatalError("Not implemented")
}
}
#endif
#endif // !os(WASI)
@available(System 1.2.0, *)
extension FileDescriptor {
@@ -550,4 +669,4 @@ extension FilePermissions {
return system_umask(mode)
}
}
#endif
#endif // !os(WASI)
@@ -461,7 +461,10 @@ extension String {
public init(decoding path: FilePath) {
self.init(_decoding: path)
}
}
@available(System 0.0.2, *)
extension String {
/// Creates a string from a file path, validating its contents as UTF-8 on
/// Unix and UTF-16 on Windows.
///
@@ -470,6 +473,7 @@ extension String {
///
/// If the contents of the file path isn't a well-formed Unicode string,
/// this initializer returns `nil`.
@available(System 0.0.2, *)
public init?(validating path: FilePath) {
self.init(_validating: path)
}
@@ -9,6 +9,21 @@
#if !os(Windows)
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WASILibc)
internal import CSystem // For the members of system_dirent
import WASILibc
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
/// Get the path to the system temporary directory.
internal func _getTemporaryDirectory() throws -> FilePath {
guard let tmp = system_getenv("TMPDIR") else {
@@ -73,7 +73,7 @@ internal func _recursiveRemove(
) throws {
// First, deal with subdirectories
try forEachFile(at: path) { findData in
if (findData.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY)) != 0 {
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 {
let name = withUnsafeBytes(of: findData.cFileName) {
return SystemString(platformString: $0.assumingMemoryBound(
to: CInterop.PlatformChar.self).baseAddress!)
@@ -94,7 +94,7 @@ internal func _recursiveRemove(
let component = FilePath.Component(name)!
let subpath = path.appending(component)
if (findData.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY)) == 0 {
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 {
try subpath.withPlatformString { subpath in
if try !subpath.withCanonicalPathRepresentation({ DeleteFileW($0) }) {
throw Errno(windowsError: GetLastError())
@@ -517,7 +517,7 @@ fileprivate func HRESULT_CODE(_ hr: HRESULT) -> DWORD {
@inline(__always)
fileprivate func HRESULT_FACILITY(_ hr: HRESULT) -> DWORD {
DWORD(hr << 16) & 0x1fff
DWORD(hr >> 16) & 0x1fff
}
@inline(__always)
@@ -529,7 +529,7 @@ fileprivate func SUCCEEDED(_ hr: HRESULT) -> Bool {
// an HRESULT to a Win32 error code.
@inline(__always)
fileprivate func WIN32_FROM_HRESULT(_ hr: HRESULT) -> DWORD {
if SUCCEEDED(hr) { return DWORD(ERROR_SUCCESS) }
if SUCCEEDED(hr) { return ERROR_SUCCESS }
if HRESULT_FACILITY(hr) == FACILITY_WIN32 {
return HRESULT_CODE(hr)
}
+250
View File
@@ -0,0 +1,250 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 - 2026 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
// |------------------------|
// | Swift API to C Mapping |
// |------------------------------------------------------------------|
// | FileFlags | Darwin | FreeBSD | OpenBSD |
// |------------------|---------------|---------------|---------------|
// | noDump | UF_NODUMP | UF_NODUMP | UF_NODUMP |
// | userImmutable | UF_IMMUTABLE | UF_IMMUTABLE | UF_IMMUTABLE |
// | userAppend | UF_APPEND | UF_APPEND | UF_APPEND |
// | archived | SF_ARCHIVED | SF_ARCHIVED | SF_ARCHIVED |
// | systemImmutable | SF_IMMUTABLE | SF_IMMUTABLE | SF_IMMUTABLE |
// | systemAppend | SF_APPEND | SF_APPEND | SF_APPEND |
// | opaque | UF_OPAQUE | UF_OPAQUE | N/A |
// | hidden | UF_HIDDEN | UF_HIDDEN | N/A |
// | systemNoUnlink | SF_NOUNLINK | SF_NOUNLINK | N/A |
// | compressed | UF_COMPRESSED | N/A | N/A |
// | tracked | UF_TRACKED | N/A | N/A |
// | dataVault | UF_DATAVAULT | N/A | N/A |
// | restricted | SF_RESTRICTED | N/A | N/A |
// | firmlink | SF_FIRMLINK | N/A | N/A |
// | dataless | SF_DATALESS | N/A | N/A |
// | userNoUnlink | N/A | UF_NOUNLINK | N/A |
// | offline | N/A | UF_OFFLINE | N/A |
// | readOnly | N/A | UF_READONLY | N/A |
// | reparse | N/A | UF_REPARSE | N/A |
// | sparse | N/A | UF_SPARSE | N/A |
// | system | N/A | UF_SYSTEM | N/A |
// | snapshot | N/A | SF_SNAPSHOT | N/A |
// |------------------|---------------|---------------|---------------|
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
/// File-specific flags found in the `st_flags` property of a `stat` struct
/// or used as input to `chflags()`.
///
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@frozen
@available(System 1.7.0, *)
public struct FileFlags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
@_alwaysEmitIntoClient
public let rawValue: CInterop.FileFlags
/// Creates a strongly-typed `FileFlags` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.FileFlags) { self.rawValue = rawValue }
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
/// Do not dump the file during backups.
///
/// The corresponding C constant is `UF_NODUMP`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var noDump: FileFlags { FileFlags(rawValue: _UF_NODUMP) }
/// File may not be changed.
///
/// The corresponding C constant is `UF_IMMUTABLE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var userImmutable: FileFlags { FileFlags(rawValue: _UF_IMMUTABLE) }
/// Writes to the file may only append.
///
/// The corresponding C constant is `UF_APPEND`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var userAppend: FileFlags { FileFlags(rawValue: _UF_APPEND) }
/// File has been archived.
///
/// The corresponding C constant is `SF_ARCHIVED`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var archived: FileFlags { FileFlags(rawValue: _SF_ARCHIVED) }
/// File may not be changed.
///
/// The corresponding C constant is `SF_IMMUTABLE`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var systemImmutable: FileFlags { FileFlags(rawValue: _SF_IMMUTABLE) }
/// Writes to the file may only append.
///
/// The corresponding C constant is `SF_APPEND`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var systemAppend: FileFlags { FileFlags(rawValue: _SF_APPEND) }
// MARK: Flags Available on Darwin and FreeBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Directory is opaque when viewed through a union mount.
///
/// The corresponding C constant is `UF_OPAQUE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var opaque: FileFlags { FileFlags(rawValue: _UF_OPAQUE) }
/// File should not be displayed in a GUI.
///
/// The corresponding C constant is `UF_HIDDEN`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var hidden: FileFlags { FileFlags(rawValue: _UF_HIDDEN) }
/// File may not be removed or renamed.
///
/// The corresponding C constant is `SF_NOUNLINK`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var systemNoUnlink: FileFlags { FileFlags(rawValue: _SF_NOUNLINK) }
#endif
// MARK: Flags Available on Darwin only
#if SYSTEM_PACKAGE_DARWIN
/// File is compressed at the file system level.
///
/// The corresponding C constant is `UF_COMPRESSED`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
@_alwaysEmitIntoClient
public static var compressed: FileFlags { FileFlags(rawValue: _UF_COMPRESSED) }
/// File is tracked for the purpose of document IDs.
///
/// The corresponding C constant is `UF_TRACKED`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var tracked: FileFlags { FileFlags(rawValue: _UF_TRACKED) }
/// File requires an entitlement for reading and writing.
///
/// The corresponding C constant is `UF_DATAVAULT`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var dataVault: FileFlags { FileFlags(rawValue: _UF_DATAVAULT) }
/// File requires an entitlement for writing.
///
/// The corresponding C constant is `SF_RESTRICTED`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var restricted: FileFlags { FileFlags(rawValue: _SF_RESTRICTED) }
/// File is a firmlink.
///
/// Firmlinks are used by macOS to create transparent links between
/// the read-only system volume and writable data volume. For example,
/// the `/Applications` folder on the system volume is a firmlink to
/// the `/Applications` folder on the data volume, allowing the user
/// to see both system- and user-installed applications in a single folder.
///
/// The corresponding C constant is `SF_FIRMLINK`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var firmlink: FileFlags { FileFlags(rawValue: _SF_FIRMLINK) }
/// File is a dataless placeholder (content is stored remotely).
///
/// The system will attempt to materialize the file when accessed according to
/// the dataless file materialization policy of the accessing thread or process.
/// See `getiopolicy_np(3)`.
///
/// The corresponding C constant is `SF_DATALESS`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
@_alwaysEmitIntoClient
public static var dataless: FileFlags { FileFlags(rawValue: _SF_DATALESS) }
#endif
// MARK: Flags Available on FreeBSD Only
#if os(FreeBSD)
/// File may not be removed or renamed.
///
/// The corresponding C constant is `UF_NOUNLINK`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var userNoUnlink: FileFlags { FileFlags(rawValue: _UF_NOUNLINK) }
/// File has the Windows offline attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_OFFLINE` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_OFFLINE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var offline: FileFlags { FileFlags(rawValue: _UF_OFFLINE) }
/// File is read-only.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_READONLY` attribute.
///
/// The corresponding C constant is `UF_READONLY`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var readOnly: FileFlags { FileFlags(rawValue: _UF_READONLY) }
/// File contains a Windows reparse point.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_REPARSE_POINT` attribute.
///
/// The corresponding C constant is `UF_REPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var reparse: FileFlags { FileFlags(rawValue: _UF_REPARSE) }
/// File is sparse.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SPARSE_FILE` attribute,
/// or to indicate a sparse file.
///
/// The corresponding C constant is `UF_SPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var sparse: FileFlags { FileFlags(rawValue: _UF_SPARSE) }
/// File has the Windows system attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SYSTEM` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_SYSTEM`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var system: FileFlags { FileFlags(rawValue: _UF_SYSTEM) }
/// File is a snapshot.
///
/// The corresponding C constant is `SF_SNAPSHOT`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var snapshot: FileFlags { FileFlags(rawValue: _SF_SNAPSHOT) }
#endif
}
#endif
+54
View File
@@ -0,0 +1,54 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 - 2026 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
/// A strongly-typed file mode representing a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 1.7.0, *)
public struct FileMode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C mode.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Mode
/// Creates a strongly-typed `FileMode` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Mode) { self.rawValue = rawValue }
/// Creates a `FileMode` from the given file type and permissions.
///
/// - Note: This initializer masks the inputs with their respective bit masks.
@_alwaysEmitIntoClient
public init(type: FileType, permissions: FilePermissions) {
self.rawValue = (type.rawValue & _MODE_FILETYPE_MASK) | (permissions.rawValue & _MODE_PERMISSIONS_MASK)
}
/// The file's type, from the mode's file-type bits.
///
/// Setting this property will mask the `newValue` with the file-type bit mask `S_IFMT`.
@_alwaysEmitIntoClient
public var type: FileType {
get { FileType(rawValue: rawValue & _MODE_FILETYPE_MASK) }
set { rawValue = (rawValue & ~_MODE_FILETYPE_MASK) | (newValue.rawValue & _MODE_FILETYPE_MASK) }
}
/// The file's permissions, from the mode's permission bits.
///
/// Setting this property will mask the `newValue` with the permissions bit mask `ALLPERMS`.
@_alwaysEmitIntoClient
public var permissions: FilePermissions {
get { FilePermissions(rawValue: rawValue & _MODE_PERMISSIONS_MASK) }
set { rawValue = (rawValue & ~_MODE_PERMISSIONS_MASK) | (newValue.rawValue & _MODE_PERMISSIONS_MASK) }
}
}
#endif
+108
View File
@@ -0,0 +1,108 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 - 2026 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
// |------------------------|
// | Swift API to C Mapping |
// |----------------------------------------|
// | FileType | Unix-like Platforms |
// |------------------|---------------------|
// | directory | S_IFDIR |
// | characterSpecial | S_IFCHR |
// | blockSpecial | S_IFBLK |
// | regular | S_IFREG |
// | fifo | S_IFIFO |
// | symbolicLink | S_IFLNK |
// | socket | S_IFSOCK |
// |------------------|---------------------|
//
// |------------------------------------------------------------------|
// | FileType | Darwin | FreeBSD | Other Unix-like Platforms |
// |------------------|---------|---------|---------------------------|
// | whiteout | S_IFWHT | S_IFWHT | N/A |
// |------------------|---------|---------|---------------------------|
#if !os(Windows)
/// A file type matching those contained in a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 1.7.0, *)
public struct FileType: RawRepresentable, Sendable, Hashable, Codable {
/// The raw file-type bits from the C mode.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Mode
/// Creates a strongly-typed file type from the raw C `mode_t`.
///
/// - Note: This initializer stores the `rawValue` directly and **does not**
/// mask the value with `S_IFMT`. If the supplied `rawValue` contains bits
/// outside of the `S_IFMT` mask, the resulting `FileType` will not compare
/// equal to constants like `.directory` and `.symbolicLink`, which may
/// be unexpected.
///
/// If you're unsure whether the `mode_t` contains bits outside of `S_IFMT`,
/// you can use `FileMode(rawValue:)` instead to get a strongly-typed
/// `FileMode`, then call `.type` to get the properly masked `FileType`.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Mode) { self.rawValue = rawValue }
/// Directory
///
/// The corresponding C constant is `S_IFDIR`.
@_alwaysEmitIntoClient
public static var directory: FileType { FileType(rawValue: _S_IFDIR) }
/// Character special device
///
/// The corresponding C constant is `S_IFCHR`.
@_alwaysEmitIntoClient
public static var characterSpecial: FileType { FileType(rawValue: _S_IFCHR) }
/// Block special device
///
/// The corresponding C constant is `S_IFBLK`.
@_alwaysEmitIntoClient
public static var blockSpecial: FileType { FileType(rawValue: _S_IFBLK) }
/// Regular file
///
/// The corresponding C constant is `S_IFREG`.
@_alwaysEmitIntoClient
public static var regular: FileType { FileType(rawValue: _S_IFREG) }
/// FIFO (or named pipe)
///
/// The corresponding C constant is `S_IFIFO`.
@_alwaysEmitIntoClient
public static var fifo: FileType { FileType(rawValue: _S_IFIFO) }
/// Symbolic link
///
/// The corresponding C constant is `S_IFLNK`.
@_alwaysEmitIntoClient
public static var symbolicLink: FileType { FileType(rawValue: _S_IFLNK) }
/// Socket
///
/// The corresponding C constant is `S_IFSOCK`.
@_alwaysEmitIntoClient
public static var socket: FileType { FileType(rawValue: _S_IFSOCK) }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Whiteout file
///
/// The corresponding C constant is `S_IFWHT`.
@_alwaysEmitIntoClient
public static var whiteout: FileType { FileType(rawValue: _S_IFWHT) }
#endif
}
#endif
@@ -0,0 +1,84 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 - 2026 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
/// A Swift wrapper of the C `uid_t` type.
@frozen
@available(System 1.7.0, *)
public struct UserID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `uid_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.UserID
/// Creates a strongly-typed `UserID` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.UserID) { self.rawValue = rawValue }
/// Creates a strongly-typed `UserID` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.UserID) { self.rawValue = rawValue }
}
/// A Swift wrapper of the C `gid_t` type.
@frozen
@available(System 1.7.0, *)
public struct GroupID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `gid_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.GroupID
/// Creates a strongly-typed `GroupID` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.GroupID) { self.rawValue = rawValue }
/// Creates a strongly-typed `GroupID` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.GroupID) { self.rawValue = rawValue }
}
/// A Swift wrapper of the C `dev_t` type.
@frozen
@available(System 1.7.0, *)
public struct DeviceID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `dev_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.DeviceID
/// Creates a strongly-typed `DeviceID` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.DeviceID) { self.rawValue = rawValue }
/// Creates a strongly-typed `DeviceID` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.DeviceID) { self.rawValue = rawValue }
}
/// A Swift wrapper of the C `ino_t` type.
@frozen
@available(System 1.7.0, *)
public struct Inode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `ino_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Inode
/// Creates a strongly-typed `Inode` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Inode) { self.rawValue = rawValue }
/// Creates a strongly-typed `Inode` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.Inode) { self.rawValue = rawValue }
}
#endif // !os(Windows)
+680
View File
@@ -0,0 +1,680 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 - 2026 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
// Must import here to use C stat properties in @_alwaysEmitIntoClient APIs.
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
// MARK: - Stat
/// A Swift wrapper of the C `stat` struct.
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 1.7.0, *)
public struct Stat: RawRepresentable, Sendable {
/// The raw C `stat` struct.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Stat
/// Creates a Swift `Stat` from the raw C struct.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Stat) { self.rawValue = rawValue }
// MARK: Stat.Flags
/// Flags representing those passed to `fstatat()`.
@frozen
public struct Flags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
@_alwaysEmitIntoClient
public let rawValue: CInt
/// Creates a strongly-typed `Stat.Flags` from raw C flags.
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
/// If the path ends with a symbolic link, return information about the link itself.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW`.
@_alwaysEmitIntoClient
public static var symlinkNoFollow: Flags { Flags(rawValue: _AT_SYMLINK_NOFOLLOW) }
#if SYSTEM_PACKAGE_DARWIN
/// If the path ends with a symbolic link, return information about the link itself.
/// If _any_ symbolic link is encountered during path resolution, return an error.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW_ANY`.
/// - Note: Only available on Darwin.
@_alwaysEmitIntoClient
public static var symlinkNoFollowAny: Flags { Flags(rawValue: _AT_SYMLINK_NOFOLLOW_ANY) }
#endif
#if canImport(Darwin, _version: 346) || os(FreeBSD)
/// If the path does not reside in the hierarchy beneath the starting directory, return an error.
///
/// The corresponding C constant is `AT_RESOLVE_BENEATH`.
/// - Note: Only available on Darwin and FreeBSD.
@_alwaysEmitIntoClient
public static var resolveBeneath: Flags { Flags(rawValue: _AT_RESOLVE_BENEATH) }
#endif
}
// MARK: Initializers
/// Creates a `Stat` struct from a `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
@_alwaysEmitIntoClient
public init(
_ path: FilePath,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try path.withPlatformString {
Self._stat(
$0,
followTargetSymlink: followTargetSymlink,
retryOnInterrupt: retryOnInterrupt
)
}.get()
}
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
@_alwaysEmitIntoClient
public init(
_ path: UnsafePointer<CChar>,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._stat(
path,
followTargetSymlink: followTargetSymlink,
retryOnInterrupt: retryOnInterrupt
).get()
}
@usableFromInline
internal static func _stat(
_ ptr: UnsafePointer<CChar>,
followTargetSymlink: Bool,
retryOnInterrupt: Bool
) -> Result<CInterop.Stat, Errno> {
var result = CInterop.Stat()
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
if followTargetSymlink {
system_stat(ptr, &result)
} else {
system_lstat(ptr, &result)
}
}.map { result }
}
/// Creates a `Stat` struct from a `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
@_alwaysEmitIntoClient
public init(
_ fd: FileDescriptor,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._fstat(
fd,
retryOnInterrupt: retryOnInterrupt
).get()
}
@usableFromInline
internal static func _fstat(
_ fd: FileDescriptor,
retryOnInterrupt: Bool
) -> Result<CInterop.Stat, Errno> {
var result = CInterop.Stat()
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_fstat(fd.rawValue, &result)
}.map { result }
}
/// Creates a `Stat` struct from a `FilePath` and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: FilePath,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try path.withPlatformString {
Self._fstatat(
$0,
relativeTo: _AT_FDCWD,
flags: flags,
retryOnInterrupt: retryOnInterrupt
)
}.get()
}
/// Creates a `Stat` struct from a `FilePath` and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: FilePath,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try path.withPlatformString {
Self._fstatat(
$0,
relativeTo: fd.rawValue,
flags: flags,
retryOnInterrupt: retryOnInterrupt
)
}.get()
}
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: UnsafePointer<CChar>,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._fstatat(
path,
relativeTo: _AT_FDCWD,
flags: flags,
retryOnInterrupt: retryOnInterrupt
).get()
}
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: UnsafePointer<CChar>,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._fstatat(
path,
relativeTo: fd.rawValue,
flags: flags,
retryOnInterrupt: retryOnInterrupt
).get()
}
@usableFromInline
internal static func _fstatat(
_ path: UnsafePointer<CChar>,
relativeTo fd: FileDescriptor.RawValue,
flags: Stat.Flags,
retryOnInterrupt: Bool
) -> Result<CInterop.Stat, Errno> {
var result = CInterop.Stat()
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_fstatat(fd, path, &result, flags.rawValue)
}.map { result }
}
// MARK: Properties
/// ID of device containing file
///
/// The corresponding C property is `st_dev`.
@_alwaysEmitIntoClient
public var deviceID: DeviceID {
get { DeviceID(rawValue: numericCast(rawValue.st_dev)) }
set { rawValue.st_dev = numericCast(newValue.rawValue) }
}
/// Inode number
///
/// The corresponding C property is `st_ino`.
@_alwaysEmitIntoClient
public var inode: Inode {
get { Inode(rawValue: numericCast(rawValue.st_ino)) }
set { rawValue.st_ino = numericCast(newValue.rawValue) }
}
/// File mode
///
/// The corresponding C property is `st_mode`.
@_alwaysEmitIntoClient
public var mode: FileMode {
get { FileMode(rawValue: numericCast(rawValue.st_mode)) }
set { rawValue.st_mode = numericCast(newValue.rawValue) }
}
/// File type for the given mode
///
/// - Note: This property is equivalent to `mode.type`. Modifying this
/// property will update the underlying `st_mode` accordingly.
@_alwaysEmitIntoClient
public var type: FileType {
get { mode.type }
set {
var newMode = mode
newMode.type = newValue
mode = newMode
}
}
/// File permissions for the given mode
///
/// - Note: This property is equivalent to `mode.permissions`. Modifying
/// this property will update the underlying `st_mode` accordingly.
@_alwaysEmitIntoClient
public var permissions: FilePermissions {
get { mode.permissions }
set {
var newMode = mode
newMode.permissions = newValue
mode = newMode
}
}
/// Number of hard links
///
/// The corresponding C property is `st_nlink`.
@_alwaysEmitIntoClient
public var linkCount: Int {
get { Int(rawValue.st_nlink) }
set { rawValue.st_nlink = numericCast(newValue) }
}
/// User ID of owner
///
/// The corresponding C property is `st_uid`.
@_alwaysEmitIntoClient
public var userID: UserID {
get { UserID(rawValue: rawValue.st_uid) }
set { rawValue.st_uid = newValue.rawValue }
}
/// Group ID of owner
///
/// The corresponding C property is `st_gid`.
@_alwaysEmitIntoClient
public var groupID: GroupID {
get { GroupID(rawValue: rawValue.st_gid) }
set { rawValue.st_gid = newValue.rawValue }
}
/// Device ID (if special file)
///
/// For character or block special files, the returned `DeviceID` may have
/// meaningful major and minor values. For non-special files, this
/// property is usually meaningless and often set to 0.
///
/// The corresponding C property is `st_rdev`.
@_alwaysEmitIntoClient
public var specialDeviceID: DeviceID {
get { DeviceID(rawValue: numericCast(rawValue.st_rdev)) }
set { rawValue.st_rdev = numericCast(newValue.rawValue) }
}
/// Total size, in bytes
///
/// The semantics of this property are tied to the underlying C `st_size` field,
/// which can have file-system–dependent behavior. For example, this property
/// can return different values for a file's data fork and resource fork, and some
/// file systems report logical size rather than actual disk usage for compressed
/// or cloned files.
///
/// The corresponding C property is `st_size`.
@_alwaysEmitIntoClient
public var size: Int64 {
get { Int64(rawValue.st_size) }
set { rawValue.st_size = numericCast(newValue) }
}
/// Block size for file system I/O, in bytes
///
/// The corresponding C property is `st_blksize`.
@_alwaysEmitIntoClient
public var preferredIOBlockSize: Int {
get { Int(rawValue.st_blksize) }
set { rawValue.st_blksize = numericCast(newValue) }
}
/// Number of 512-byte blocks allocated
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file-system–dependent behavior.
///
/// The corresponding C property is `st_blocks`.
@_alwaysEmitIntoClient
public var blocksAllocated: Int64 {
get { Int64(rawValue.st_blocks) }
set { rawValue.st_blocks = numericCast(newValue) }
}
/// Total size allocated, in bytes
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file-system–dependent behavior.
///
/// - Note: Calculated as `512 * blocksAllocated`.
@_alwaysEmitIntoClient
public var sizeAllocated: Int64 {
512 * blocksAllocated
}
// NOTE: "st_" property names are used for the `timespec` properties so
// we can reserve `accessTime`, `modificationTime`, etc. for potential
// `UTCClock.Instant` properties in the future.
/// Time of last access, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_atim` (or `st_atimespec` on Darwin).
@_alwaysEmitIntoClient
public var st_atim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_atimespec
#else
rawValue.st_atim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_atimespec = newValue
#else
rawValue.st_atim = newValue
#endif
}
}
/// Time of last modification, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_mtim` (or `st_mtimespec` on Darwin).
@_alwaysEmitIntoClient
public var st_mtim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_mtimespec
#else
rawValue.st_mtim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_mtimespec = newValue
#else
rawValue.st_mtim = newValue
#endif
}
}
/// Time of last status (inode) change, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_ctim` (or `st_ctimespec` on Darwin).
@_alwaysEmitIntoClient
public var st_ctim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_ctimespec
#else
rawValue.st_ctim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_ctimespec = newValue
#else
rawValue.st_ctim = newValue
#endif
}
}
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Time of file creation, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_birthtim` (or `st_birthtimespec` on Darwin).
/// - Note: Only available on Darwin and FreeBSD.
@_alwaysEmitIntoClient
public var st_birthtim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_birthtimespec
#else
rawValue.st_birthtim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_birthtimespec = newValue
#else
rawValue.st_birthtim = newValue
#endif
}
}
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
/// File flags
///
/// The corresponding C property is `st_flags`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@_alwaysEmitIntoClient
public var flags: FileFlags {
get { FileFlags(rawValue: rawValue.st_flags) }
set { rawValue.st_flags = newValue.rawValue }
}
/// File generation number
///
/// The file generation number may be used to distinguish between different
/// files that have used the same inode over time.
///
/// The corresponding C property is `st_gen`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD. The underlying C
/// field is 32-bit on Darwin and OpenBSD, and 64-bit on FreeBSD.
@_alwaysEmitIntoClient
public var generationNumber: UInt64 {
get { UInt64(rawValue.st_gen) }
set { rawValue.st_gen = numericCast(newValue) }
}
#endif
}
// MARK: - Equatable and Hashable
@available(System 1.7.0, *)
extension Stat: Equatable {
/// Compares the meaningful file-metadata fields of two `Stat` values.
///
/// Alignment padding and platform reserved/"spare" fields are not compared.
public static func == (lhs: Self, rhs: Self) -> Bool {
guard lhs.rawValue.st_dev == rhs.rawValue.st_dev,
lhs.rawValue.st_ino == rhs.rawValue.st_ino,
lhs.rawValue.st_mode == rhs.rawValue.st_mode,
lhs.rawValue.st_nlink == rhs.rawValue.st_nlink,
lhs.rawValue.st_uid == rhs.rawValue.st_uid,
lhs.rawValue.st_gid == rhs.rawValue.st_gid,
lhs.rawValue.st_rdev == rhs.rawValue.st_rdev,
lhs.rawValue.st_size == rhs.rawValue.st_size,
lhs.rawValue.st_blksize == rhs.rawValue.st_blksize,
lhs.rawValue.st_blocks == rhs.rawValue.st_blocks,
lhs.st_atim.tv_sec == rhs.st_atim.tv_sec,
lhs.st_atim.tv_nsec == rhs.st_atim.tv_nsec,
lhs.st_mtim.tv_sec == rhs.st_mtim.tv_sec,
lhs.st_mtim.tv_nsec == rhs.st_mtim.tv_nsec,
lhs.st_ctim.tv_sec == rhs.st_ctim.tv_sec,
lhs.st_ctim.tv_nsec == rhs.st_ctim.tv_nsec else {
return false
}
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
guard lhs.st_birthtim.tv_sec == rhs.st_birthtim.tv_sec,
lhs.st_birthtim.tv_nsec == rhs.st_birthtim.tv_nsec else {
return false
}
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
guard lhs.rawValue.st_flags == rhs.rawValue.st_flags,
lhs.rawValue.st_gen == rhs.rawValue.st_gen else {
return false
}
#endif
return true
}
}
@available(System 1.7.0, *)
extension Stat: Hashable {
/// Hashes the meaningful file-metadata fields of a `Stat` struct.
///
/// These are the same fields compared by `==`, fed in the same order.
/// Alignment padding and platform reserved/"spare" fields are not hashed.
public func hash(into hasher: inout Hasher) {
hasher.combine(rawValue.st_dev)
hasher.combine(rawValue.st_ino)
hasher.combine(rawValue.st_mode)
hasher.combine(rawValue.st_nlink)
hasher.combine(rawValue.st_uid)
hasher.combine(rawValue.st_gid)
hasher.combine(rawValue.st_rdev)
hasher.combine(rawValue.st_size)
hasher.combine(rawValue.st_blksize)
hasher.combine(rawValue.st_blocks)
hasher.combine(st_atim.tv_sec)
hasher.combine(st_atim.tv_nsec)
hasher.combine(st_mtim.tv_sec)
hasher.combine(st_mtim.tv_nsec)
hasher.combine(st_ctim.tv_sec)
hasher.combine(st_ctim.tv_nsec)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
hasher.combine(st_birthtim.tv_sec)
hasher.combine(st_birthtim.tv_nsec)
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
hasher.combine(rawValue.st_flags)
hasher.combine(rawValue.st_gen)
#endif
}
}
// MARK: - CustomStringConvertible and CustomDebugStringConvertible
// MARK: - FileDescriptor Extensions
@available(System 1.7.0, *)
extension FileDescriptor {
/// Creates a `Stat` struct for the file referenced by this `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
@_alwaysEmitIntoClient
public func stat(
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, retryOnInterrupt: retryOnInterrupt)
}
}
// MARK: - FilePath Extensions
@available(System 1.7.0, *)
extension FilePath {
/// Creates a `Stat` struct for the file referenced by this `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
@_alwaysEmitIntoClient
public func stat(
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, followTargetSymlink: followTargetSymlink, retryOnInterrupt: retryOnInterrupt)
}
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public func stat(
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, flags: flags, retryOnInterrupt: retryOnInterrupt)
}
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public func stat(
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, relativeTo: fd, flags: flags, retryOnInterrupt: retryOnInterrupt)
}
}
#endif // !os(Windows)
+1 -1
View File
@@ -1,7 +1,7 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
public import CSystemIOUring
public extension IORing {
struct Completion: ~Copyable {
+7 -18
View File
@@ -1,7 +1,7 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
public import CSystemIOUring
@usableFromInline
internal enum IORequestCore {
@@ -388,7 +388,9 @@ extension IORing.Request {
}
@inline(__always) @inlinable
internal consuming func makeRawRequest() -> RawIORequest {
internal consuming func makeRawRequest(
pathBuffers: PendingPathBuffers
) -> RawIORequest {
var request = RawIORequest()
switch extractCore() {
case .nop:
@@ -400,27 +402,19 @@ extension IORing.Request {
request.operation = .openAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
}))
UInt(bitPattern: pathBuffers.pin(path)))
request.rawValue.open_flags = UInt32(bitPattern: options.rawValue | mode.rawValue)
request.rawValue.len = permissions?.rawValue ?? 0
request.rawValue.file_index = UInt32(fileSlot.index + 1)
request.path = path
request.rawValue.user_data = context
case .openat(
let atDirectory, let path, let mode, let options, let permissions, let context):
request.operation = .openAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
}))
UInt(bitPattern: pathBuffers.pin(path)))
request.rawValue.open_flags = UInt32(bitPattern: options.rawValue | mode.rawValue)
request.rawValue.len = permissions?.rawValue ?? 0
request.path = path
request.rawValue.user_data = context
case .write(let file, let buffer, let offset, let context):
request.operation = .writeFixed
@@ -466,12 +460,7 @@ extension IORing.Request {
request.operation = .unlinkAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
})
)
request.path = path
UInt(bitPattern: pathBuffers.pin(path)))
request.rawValue.user_data = context
case .cancelContext(let flags, let targetContext):
request.operation = .asyncCancel
+80
View File
@@ -0,0 +1,80 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
internal import CSystem
public import CSystemIOUring
#if canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#endif
/// Throwing wrapper around the `csystem_io_uring_enter2` shim.
///
/// On success returns the syscall's non-negative result (the number of SQEs
/// consumed by the kernel). On failure, reads `errno` and throws the matching
/// `Errno`. `EINTR` is retried automatically.
@usableFromInline
internal func _ioUringEnter2(
ringDescriptor: Int32,
toSubmit: UInt32,
minComplete: UInt32,
flags: UInt32,
args: UnsafeMutablePointer<swift_io_uring_getevents_arg>?,
argsSize: Int
) throws(Errno) -> Int32 {
let result = valueOrErrno(retryOnInterrupt: true) {
csystem_io_uring_enter2(
ringDescriptor, toSubmit, minComplete, flags, args, argsSize
)
}
return try result.get()
}
/// Throwing wrapper around the `csystem_io_uring_enter` shim.
///
/// On success returns the syscall's non-negative result (the number of SQEs
/// consumed by the kernel). On failure, reads `errno` and throws the matching
/// `Errno`. `EINTR` is retried automatically.
@usableFromInline
internal func _ioUringEnter(
ringDescriptor: Int32,
toSubmit: UInt32,
minComplete: UInt32,
flags: UInt32,
sig: UnsafeMutablePointer<sigset_t>?
) throws(Errno) -> Int32 {
let result = valueOrErrno(retryOnInterrupt: true) {
csystem_io_uring_enter(ringDescriptor, toSubmit, minComplete, flags, sig)
}
return try result.get()
}
/// Throwing wrapper around the `csystem_io_uring_register` shim.
///
/// On success returns the syscall's non-negative result. On failure, reads
/// `errno` and throws the matching `Errno`. `EINTR` is retried automatically.
@usableFromInline
internal func _ioUringRegister(
ringDescriptor: Int32,
opcode: UInt32,
arg: UnsafeMutableRawPointer?,
nrArgs: UInt32
) throws(Errno) -> Int32 {
let result = valueOrErrno(retryOnInterrupt: true) {
csystem_io_uring_register(ringDescriptor, opcode, arg, nrArgs)
}
return try result.get()
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+134 -93
View File
@@ -1,7 +1,8 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
internal import CSystem
public import CSystemIOUring
// needed for mmap
#if canImport(Glibc)
import Glibc
@@ -41,6 +42,33 @@ extension UnsafeMutableRawBufferPointer {
}
}
/// Owns the FilePaths whose interior pointers have been written into pending
/// SQEs. The kernel copies SQE-referenced data out during io_uring_enter (due to
/// IORING_FEAT_SUBMIT_STABLE), so the paths only need to live across the prepare->submit gap
/// This is a class purely to avoid making methods calling `pin` mutating, which would be an API break
@usableFromInline
internal final class PendingPathBuffers {
@usableFromInline
var paths: [FilePath] = []
init(reservedCapacity: Int) {
paths.reserveCapacity(reservedCapacity)
}
@usableFromInline
func pin(_ path: FilePath) -> UnsafePointer<CInterop.PlatformChar> {
paths.append(path)
// Safe to escape: `paths` keeps the FilePath (and its underlying
// [SystemChar] buffer) alive until clear() or class deinit.
return paths.last!.withPlatformString { $0 }
}
@usableFromInline
func clear() {
paths.removeAll(keepingCapacity: true)
}
}
// all pointers in this struct reference kernel-visible memory
@usableFromInline struct SQRing: ~Copyable {
@usableFromInline let kernelHead: UnsafePointer<Atomic<UInt32>>
@@ -101,23 +129,30 @@ internal func _enter(
// Ring always needs enter right now;
// TODO: support SQPOLL here
while true {
let ret = io_uring_enter(ringDescriptor, numEvents, minCompletions, flags, nil)
do {
let ret = try _ioUringEnter(
ringDescriptor: ringDescriptor,
toSubmit: numEvents,
minComplete: minCompletions,
flags: flags,
sig: nil
)
if _getSubmissionQueueCount(ring: ring) > 0 {
// See https://github.com/axboe/liburing/issues/309,
// in some cases not all pending requests are submitted
continue
}
return ret
// error handling:
// EAGAIN / EINTR (try again),
// EAGAIN (try again),
// EBADF / EBADFD / EOPNOTSUPP / ENXIO
// (failure in ring lifetime management, fatal),
// EINVAL (bad constant flag?, fatal),
// EFAULT (bad address for argument from library, fatal)
if ret == -EAGAIN || ret == -EINTR {
} catch Errno.resourceTemporarilyUnavailable {
//TODO: should we wait a bit on AGAIN?
//alternatively we could treat EAGAIN the same as EINTR in the wrapper
continue
} else if ret < 0 {
throw(Errno(rawValue: -ret))
} else if _getSubmissionQueueCount(ring: ring) > 0 {
// See https://github.com/axboe/liburing/issues/309, in some cases not all pending requests are submitted
continue
} else {
return ret
}
}
}
@@ -189,7 +224,7 @@ private func setUpRing(
var err: Errno? = nil
let ringDescriptor = withUnsafeMutablePointer(to: &params) {
let result = io_uring_setup(queueDepth, $0)
let result = csystem_io_uring_setup(queueDepth, $0)
if result < 0 {
err = Errno.current
}
@@ -200,7 +235,14 @@ private func setUpRing(
throw err
}
if params.features & IORing.Features.nonDroppingCompletions.rawValue == 0
// We require IORING_FEAT_SUBMIT_STABLE so the kernel copies SQE-referenced
// pathnames (and other inline data) out of userspace before io_uring_enter
// returns; the path-buffer side store on IORing relies on this to free
// path buffers as soon as a submission completes.
let requiredFeatures =
IORing.Features.nonDroppingCompletions.rawValue
| IORing.Features.stableSubmissions.rawValue
if params.features & requiredFeatures != requiredFeatures
{
close(ringDescriptor)
throw Errno.invalidArgument
@@ -324,6 +366,8 @@ public struct IORing: ~Copyable {
@usableFromInline var _registeredFiles: [UInt32]
@usableFromInline var _registeredBuffers: [iovec]
@usableFromInline let _pendingPathBuffers: PendingPathBuffers
var features = Features(rawValue: 0)
/// RegisteredResource is used via its typealiases, RegisteredFile and RegisteredBuffer. Registering file descriptors and buffers with the IORing allows for more efficient access to them.
@@ -444,6 +488,7 @@ public struct IORing: ~Copyable {
self.completionRingSize = tmpCQSize
self._registeredFiles = []
self._registeredBuffers = []
self._pendingPathBuffers = PendingPathBuffers(reservedCapacity: Int(params.sq_entries))
self.submissionRing = submissionRing
self.completionRing = completionRing
self.submissionQueueEntries = submissionQueueEntries
@@ -480,34 +525,44 @@ public struct IORing: ~Copyable {
if count < minimumCount {
while count < minimumCount {
var sz = 0
var flags = IORING_ENTER_GETEVENTS
if extraArgs != nil {
sz = MemoryLayout<swift_io_uring_getevents_arg>.size
flags |= IORING_ENTER_EXT_ARG
}
let res = io_uring_enter2(
ringDescriptor,
0,
minimumCount,
IORING_ENTER_GETEVENTS,
extraArgs,
sz
)
do {
_ = try _ioUringEnter2(
ringDescriptor: ringDescriptor,
toSubmit: 0,
minComplete: minimumCount,
flags: flags,
args: extraArgs,
argsSize: sz
)
break
// error handling:
// EAGAIN / EINTR (try again),
// EAGAIN (try again),
// EBADF / EBADFD / EOPNOTSUPP / ENXIO
// (failure in ring lifetime management, fatal),
// EINVAL (bad constant flag?, fatal),
// EFAULT (bad address for argument from library, fatal)
// EBUSY (not enough space for events; implies events filled
// by kernel between kernelTail load and now)
if res >= 0 || res == -EBUSY {
// ETIME (timeout from extraArgs.ts elapsed before
// minimumCount completions arrived)
} catch Errno.resourceBusy {
break
} else if res == -EAGAIN || res == -EINTR {
} catch Errno.resourceTemporarilyUnavailable {
continue
} catch Errno.timeout {
try consumer(nil, .timeout, true)
return
} catch {
fatalError(
"fatal error in receiving requests: "
+ error.debugDescription
)
}
fatalError(
"fatal error in receiving requests: "
+ Errno(rawValue: -res).debugDescription
)
}
var count = 0
while let completion = _tryConsumeCompletion(ring: completionRing) {
@@ -623,31 +678,22 @@ public struct IORing: ~Copyable {
/// Registers an event monitoring file descriptor with the ring. The file descriptor becomes readable whenever completions are ready to be dequeued. See `man eventfd(2)` for additional information.
public mutating func registerEventFD(_ descriptor: FileDescriptor) throws(Errno) {
var rawfd = descriptor.rawValue
let result = withUnsafePointer(to: &rawfd) { fdptr in
let result = io_uring_register(
ringDescriptor,
RegistrationOps.registerEventFD.rawValue,
UnsafeMutableRawPointer(mutating: fdptr),
1
)
return result >= 0 ? nil : Errno(rawValue: -result)
}
if let result {
throw result
}
_ = try _ioUringRegister(
ringDescriptor: ringDescriptor,
opcode: RegistrationOps.registerEventFD.rawValue,
arg: &rawfd,
nrArgs: 1
)
}
/// Removes a registered event file descriptor from the ring
public mutating func unregisterEventFD() throws(Errno) {
let result = io_uring_register(
ringDescriptor,
RegistrationOps.unregisterEventFD.rawValue,
nil,
0
_ = try _ioUringRegister(
ringDescriptor: ringDescriptor,
opcode: RegistrationOps.unregisterEventFD.rawValue,
arg: nil,
nrArgs: 0
)
if result < 0 {
throw Errno(rawValue: -result)
}
}
/// Registers `count` files with the ring for later use in IO operations
@@ -656,18 +702,13 @@ public struct IORing: ~Copyable {
precondition(count < UInt32.max)
let files = [UInt32](repeating: UInt32.max, count: count)
let regResult = files.withUnsafeBufferPointer { bPtr in
let result = io_uring_register(
self.ringDescriptor,
RegistrationOps.registerFiles.rawValue,
UnsafeMutableRawPointer(mutating: bPtr.baseAddress!),
UInt32(truncatingIfNeeded: count)
try files.withUnsafeBufferPointer { bPtr throws(Errno) in
_ = try _ioUringRegister(
ringDescriptor: self.ringDescriptor,
opcode: RegistrationOps.registerFiles.rawValue,
arg: UnsafeMutableRawPointer(mutating: bPtr.baseAddress),
nrArgs: UInt32(truncatingIfNeeded: count)
)
return result >= 0 ? nil : Errno(rawValue: -result)
}
if let regResult {
throw regResult
}
_registeredFiles = files
@@ -675,16 +716,13 @@ public struct IORing: ~Copyable {
}
/// Removes registered files from the ring
public func unregisterFiles() throws {
let result = io_uring_register(
ringDescriptor,
RegistrationOps.unregisterFiles.rawValue,
nil,
0
public func unregisterFiles() throws(Errno) {
_ = try _ioUringRegister(
ringDescriptor: ringDescriptor,
opcode: RegistrationOps.unregisterFiles.rawValue,
arg: nil,
nrArgs: 0
)
if result < 0 {
throw Errno(rawValue: -result)
}
}
/// Allows access to registered files by index
@@ -700,18 +738,13 @@ public struct IORing: ~Copyable {
precondition(buffers.count < UInt32.max)
precondition(_registeredBuffers.isEmpty)
let iovecs = buffers.map { $0.to_iovec() }
let regResult = iovecs.withUnsafeBufferPointer { bPtr in
let result = io_uring_register(
self.ringDescriptor,
RegistrationOps.registerBuffers.rawValue,
UnsafeMutableRawPointer(mutating: bPtr.baseAddress!),
UInt32(truncatingIfNeeded: buffers.count)
try iovecs.withUnsafeBufferPointer { bPtr throws(Errno) in
_ = try _ioUringRegister(
ringDescriptor: self.ringDescriptor,
opcode: RegistrationOps.registerBuffers.rawValue,
arg: UnsafeMutableRawPointer(mutating: bPtr.baseAddress),
nrArgs: UInt32(truncatingIfNeeded: buffers.count)
)
return result >= 0 ? nil : Errno(rawValue: -result)
}
if let regResult {
throw regResult
}
_registeredBuffers = iovecs
@@ -749,22 +782,23 @@ public struct IORing: ~Copyable {
RegisteredResources(resources: _registeredBuffers)
}
public func unregisterBuffers() throws {
let result = io_uring_register(
self.ringDescriptor,
RegistrationOps.unregisterBuffers.rawValue,
nil,
0
public func unregisterBuffers() throws(Errno) {
_ = try _ioUringRegister(
ringDescriptor: self.ringDescriptor,
opcode: RegistrationOps.unregisterBuffers.rawValue,
arg: nil,
nrArgs: 0
)
guard result >= 0 else {
throw Errno(rawValue: -result)
}
}
/// Sends all prepared requests to the kernel for processing. Results will be delivered as completions, which can be dequeued from the ring.
@inlinable
public func submitPreparedRequests() throws(Errno) {
try _submitRequests(ring: submissionRing, ringDescriptor: ringDescriptor)
// IORING_FEAT_SUBMIT_STABLE guarantees the kernel has copied any
// SQE-referenced data (e.g. openat/unlinkAt pathnames) before
// io_uring_enter returns; safe to release path storage now.
_pendingPathBuffers.clear()
}
/// Sends all prepared requests to the kernel for processing, and then dequeues at least `minimumCount` completions, waiting up to `timeout` for them to become available. `consumer` is called to process each completed IO operation as it becomes available.
@@ -790,9 +824,14 @@ public struct IORing: ~Copyable {
/// Attempts to prepare an IO request for submission to the kernel. Returns false if no space is available to enqueue the request
@inlinable
public mutating func prepare(request: __owned Request) -> Bool {
var raw: RawIORequest? = request.makeRawRequest()
return _tryWriteRequest(
guard _getRemainingSubmissionQueueCapacity(ring: submissionRing) >= 1 else {
return false
}
var raw: RawIORequest? = request.makeRawRequest(pathBuffers: _pendingPathBuffers)
let ok = _tryWriteRequest(
raw.take()!, ring: &submissionRing, submissionQueueEntries: submissionQueueEntries)
assert(ok)
return ok
}
/// Attempts to prepare a chain of linked IO requests for submission to the kernel. Returns false if not enough space is available to enqueue the request. If any linked operation fails, subsequent operations will be canceled. Linked operations always execute in order.
@@ -806,18 +845,20 @@ public struct IORing: ~Copyable {
return false
}
let last = linkedRequests.last!
var allAdded = true
for req in linkedRequests.dropLast() {
var raw = req.makeRawRequest()
var raw = req.makeRawRequest(pathBuffers: _pendingPathBuffers)
raw.linkToNextRequest()
let successfullyAdded = _tryWriteRequest(
raw, ring: &submissionRing, submissionQueueEntries: submissionQueueEntries)
assert(successfullyAdded)
allAdded = allAdded && successfullyAdded
}
let successfullyAdded = _tryWriteRequest(
last.makeRawRequest(), ring: &submissionRing,
last.makeRawRequest(pathBuffers: _pendingPathBuffers), ring: &submissionRing,
submissionQueueEntries: submissionQueueEntries)
assert(successfullyAdded)
return true
return allAdded && successfullyAdded
}
/// Prepares a sequence of requests for submission to the ring. Returns false if the submission queue doesn't have enough available space.
+13 -9
View File
@@ -1,14 +1,18 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
public import CSystemIOUring
#if canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#endif
@usableFromInline
internal struct RawIORequest: ~Copyable {
// swift_io_uring_sqe is a typedef of io_uring_sqe on platforms where
// IORing is supported (currently requires kernel version >= 5.15).
@usableFromInline var rawValue: swift_io_uring_sqe
@usableFromInline var path: FilePath? //buffer owner for the path pointer that the sqe may have
@inlinable public init() {
self.rawValue = swift_io_uring_sqe()
@@ -177,20 +181,20 @@ extension RawIORequest {
}
@inlinable
static func withTimeoutRequest<R>(
static func withTimeoutRequest<R, E: Error>(
linkedTo opEntry: UnsafeMutablePointer<swift_io_uring_sqe>,
in timeoutEntry: UnsafeMutablePointer<swift_io_uring_sqe>,
duration: Duration,
flags: TimeOutFlags,
work: () throws -> R) rethrows -> R {
duration: Duration,
flags: TimeOutFlags,
work: () throws(E) -> R) throws(E) -> R {
opEntry.pointee.flags |= Flags.linkRequest.rawValue
opEntry.pointee.off = 1
var ts = timespec(
tv_sec: Int(duration.components.seconds),
tv_sec: Int(duration.components.seconds),
tv_nsec: Int(duration.components.attoseconds / 1_000_000_000)
)
return try withUnsafePointer(to: &ts) { tsPtr in
return try withUnsafePointer(to: &ts) { tsPtr throws(E) -> R in
var req: RawIORequest = RawIORequest()
req.operation = .link_timeout
req.rawValue.timeout_flags = flags.rawValue
+42 -8
View File
@@ -1,28 +1,24 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
*/
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif os(Windows)
import CSystem
import ucrt
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Bionic)
@_implementationOnly import CSystem
import Bionic
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
@@ -79,3 +75,41 @@ public enum CInterop {
public typealias PlatformUnicodeEncoding = UTF8
#endif
}
#if !os(Windows)
@available(System 0.0.2, *) // Original availability of CInterop
extension CInterop {
/// The C `stat` struct.
public typealias Stat = stat
/// Calls the C `stat()` function.
///
/// This is a direct wrapper around the C `stat()` system call.
/// For a more ergonomic Swift API, use `Stat` instead.
///
/// - Warning: This API is primarily intended for migration purposes when
/// supporting older deployment targets. If your deployment target supports
/// it, prefer using the `Stat` API introduced in SYS-0006, which provides
/// type-safe, ergonomic access to file metadata in Swift.
///
/// - Parameters:
/// - path: A null-terminated C string representing the file path.
/// - s: An `inout` reference to a `CInterop.Stat` struct to populate.
/// - Returns: 0 on success, -1 on error (check `Errno.current`).
@_alwaysEmitIntoClient
public static func stat(_ path: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
system_stat(path, &s)
}
}
@available(System 1.7.0, *)
extension CInterop {
public typealias DeviceID = dev_t
public typealias Inode = ino_t
public typealias UserID = uid_t
public typealias GroupID = gid_t
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
public typealias FileFlags = UInt32
#endif
}
#endif
+170 -7
View File
@@ -1,11 +1,11 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
*/
// For platform constants redefined in Swift. We define them here so that
// they can be used anywhere without imports and without confusion to
@@ -14,15 +14,13 @@
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif os(Windows)
import CSystem
import ucrt
import WinSDK
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import CSystem
import Musl
#elseif canImport(WASILibc)
import CSystem
import WASILibc
#elseif canImport(Android)
import Android
@@ -30,6 +28,11 @@ import Android
#error("Unsupported Platform")
#endif
// Some WASI constants come from CSystem and are inlined into clients.
#if os(WASI)
public import CSystem
#endif
// MARK: errno
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
@@ -438,7 +441,7 @@ internal var _ENOSR: CInt { ENOSR }
@_alwaysEmitIntoClient
internal var _ENOSTR: CInt { ENOSTR }
#endif
#endif
#endif
@_alwaysEmitIntoClient
@@ -618,9 +621,26 @@ internal var _O_DIRECTORY: CInt {
internal var _O_SYMLINK: CInt { O_SYMLINK }
#endif
@_alwaysEmitIntoClient
internal var _O_CLOEXEC: CInt {
#if os(Windows)
O_NOINHERIT
#else
O_CLOEXEC
#endif
}
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _O_CLOEXEC: CInt { O_CLOEXEC }
internal var _O_CLOFORK: CInt {
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
0x0800_0000 // O_CLOFORK, which SDKs before macOS 27 and older FreeBSD lack
#elseif !os(WASI) && !os(Linux) && !os(Android)
O_CLOFORK
#else
0
#endif
}
#endif
@_alwaysEmitIntoClient
@@ -639,3 +659,146 @@ internal var _SEEK_HOLE: CInt { SEEK_HOLE }
@_alwaysEmitIntoClient
internal var _SEEK_DATA: CInt { SEEK_DATA }
#endif
// MARK: - File System
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _AT_FDCWD: CInt { AT_FDCWD }
// MARK: - fstatat Flags
@_alwaysEmitIntoClient
internal var _AT_SYMLINK_NOFOLLOW: CInt { AT_SYMLINK_NOFOLLOW }
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _AT_SYMLINK_NOFOLLOW_ANY: CInt { AT_SYMLINK_NOFOLLOW_ANY }
#endif
#if canImport(Darwin, _version: 346) || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _AT_RESOLVE_BENEATH: CInt { AT_RESOLVE_BENEATH }
#endif
// MARK: - File Mode / File Type
@_alwaysEmitIntoClient
internal var _MODE_FILETYPE_MASK: mode_t { S_IFMT }
@_alwaysEmitIntoClient
internal var _MODE_PERMISSIONS_MASK: mode_t { 0o7777 }
@_alwaysEmitIntoClient
internal var _S_IFDIR: mode_t { S_IFDIR }
@_alwaysEmitIntoClient
internal var _S_IFCHR: mode_t { S_IFCHR }
@_alwaysEmitIntoClient
internal var _S_IFBLK: mode_t { S_IFBLK }
@_alwaysEmitIntoClient
internal var _S_IFREG: mode_t { S_IFREG }
@_alwaysEmitIntoClient
internal var _S_IFIFO: mode_t { S_IFIFO }
@_alwaysEmitIntoClient
internal var _S_IFLNK: mode_t { S_IFLNK }
@_alwaysEmitIntoClient
internal var _S_IFSOCK: mode_t { S_IFSOCK }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
// `S_IFWHT` is `Int32` on FreeBSD.
@_alwaysEmitIntoClient
internal var _S_IFWHT: mode_t { .init(S_IFWHT) }
#endif
// MARK: - stat/chflags File Flags
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
@_alwaysEmitIntoClient
internal var _UF_NODUMP: UInt32 { UInt32(bitPattern: UF_NODUMP) }
@_alwaysEmitIntoClient
internal var _UF_IMMUTABLE: UInt32 { UInt32(bitPattern: UF_IMMUTABLE) }
@_alwaysEmitIntoClient
internal var _UF_APPEND: UInt32 { UInt32(bitPattern: UF_APPEND) }
@_alwaysEmitIntoClient
internal var _SF_ARCHIVED: UInt32 { UInt32(bitPattern: SF_ARCHIVED) }
@_alwaysEmitIntoClient
internal var _SF_IMMUTABLE: UInt32 { UInt32(bitPattern: SF_IMMUTABLE) }
@_alwaysEmitIntoClient
internal var _SF_APPEND: UInt32 { UInt32(bitPattern: SF_APPEND) }
#endif
// MARK: Flags Available on Darwin and FreeBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _UF_OPAQUE: UInt32 { UInt32(bitPattern: UF_OPAQUE) }
@_alwaysEmitIntoClient
internal var _UF_HIDDEN: UInt32 { UInt32(bitPattern: UF_HIDDEN) }
@_alwaysEmitIntoClient
internal var _SF_NOUNLINK: UInt32 { UInt32(bitPattern: SF_NOUNLINK) }
#endif
// MARK: Flags Available on Darwin Only
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _UF_COMPRESSED: UInt32 { UInt32(bitPattern: UF_COMPRESSED) }
@_alwaysEmitIntoClient
internal var _UF_TRACKED: UInt32 { UInt32(bitPattern: UF_TRACKED) }
@_alwaysEmitIntoClient
internal var _UF_DATAVAULT: UInt32 { UInt32(bitPattern: UF_DATAVAULT) }
@_alwaysEmitIntoClient
internal var _SF_RESTRICTED: UInt32 { UInt32(bitPattern: SF_RESTRICTED) }
@_alwaysEmitIntoClient
internal var _SF_FIRMLINK: UInt32 { UInt32(bitPattern: SF_FIRMLINK) }
@_alwaysEmitIntoClient
internal var _SF_DATALESS: UInt32 { UInt32(bitPattern: SF_DATALESS) }
#endif
// MARK: Flags Available on FreeBSD Only
#if os(FreeBSD)
@_alwaysEmitIntoClient
internal var _UF_NOUNLINK: UInt32 { UInt32(bitPattern: UF_NOUNLINK) }
@_alwaysEmitIntoClient
internal var _UF_OFFLINE: UInt32 { UInt32(bitPattern: UF_OFFLINE) }
@_alwaysEmitIntoClient
internal var _UF_READONLY: UInt32 { UInt32(bitPattern: UF_READONLY) }
@_alwaysEmitIntoClient
internal var _UF_REPARSE: UInt32 { UInt32(bitPattern: UF_REPARSE) }
@_alwaysEmitIntoClient
internal var _UF_SPARSE: UInt32 { UInt32(bitPattern: UF_SPARSE) }
@_alwaysEmitIntoClient
internal var _UF_SYSTEM: UInt32 { UInt32(bitPattern: UF_SYSTEM) }
@_alwaysEmitIntoClient
internal var _SF_SNAPSHOT: UInt32 { UInt32(bitPattern: SF_SNAPSHOT) }
#endif
#endif // !os(Windows)
+34 -18
View File
@@ -1,32 +1,27 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
*/
// Internal wrappers and typedefs which help reduce #if littering in System's
// code base.
// TODO: Should CSystem just include all the header files we need?
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif os(Windows)
import CSystem
import ucrt
import WinSDK
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Android)
@_implementationOnly import CSystem
import Android
#else
#error("Unsupported Platform")
@@ -90,6 +85,26 @@ internal func system_strlen(_ s: UnsafeMutablePointer<CChar>) -> Int {
strlen(s)
}
#if !os(Windows)
@available(System 0.0.2, *)
@_alwaysEmitIntoClient
internal func system_stat(_ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
stat(p, &s)
}
@available(System 1.7.0, *)
internal func system_lstat(_ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
lstat(p, &s)
}
@available(System 1.7.0, *)
internal func system_fstat(_ fd: CInt, _ s: inout CInterop.Stat) -> Int32 {
fstat(fd, &s)
}
@available(System 1.7.0, *)
internal func system_fstatat(_ fd: CInt, _ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat, _ flags: CInt) -> Int32 {
fstatat(fd, p, &s, flags)
}
#endif
// Convention: `system_platform_foo` is a
// platform-representation-abstracted wrapper around `foo`-like functionality.
// Type and layout differences such as the `char` vs `wchar` are abstracted.
@@ -140,7 +155,7 @@ extension String {
return
#else
self.init(validatingUTF8: platformString)
self.init(validatingCString: platformString)
#endif
}
@@ -164,23 +179,24 @@ extension String {
// TLS
#if os(Windows)
internal typealias _PlatformTLSKey = DWORD
#elseif os(WASI) && (swift(<6.1) || !_runtime(_multithreaded))
// Mock TLS storage for single-threaded WASI
internal final class _PlatformTLSKey {
fileprivate init() {}
#elseif os(WASI) && !_runtime(_multithreaded)
// Mock TLS storage for single-threaded WASI.
// Carries no state of its own, and only used to index `sharedTLSStorage`.
internal final class _PlatformTLSKey: @unchecked Sendable {
fileprivate init() {}
}
private final class TLSStorage: @unchecked Sendable {
var storage = [ObjectIdentifier: UnsafeMutableRawPointer]()
var storage = [ObjectIdentifier: UnsafeMutableRawPointer]()
}
private let sharedTLSStorage = TLSStorage()
func pthread_setspecific(_ key: _PlatformTLSKey, _ p: UnsafeMutableRawPointer?) -> Int {
sharedTLSStorage.storage[ObjectIdentifier(key)] = p
return 0
sharedTLSStorage.storage[ObjectIdentifier(key)] = p
return 0
}
func pthread_getspecific(_ key: _PlatformTLSKey) -> UnsafeMutableRawPointer? {
sharedTLSStorage.storage[ObjectIdentifier(key)]
sharedTLSStorage.storage[ObjectIdentifier(key)]
}
#else
internal typealias _PlatformTLSKey = pthread_key_t
@@ -193,7 +209,7 @@ internal func makeTLSKey() -> _PlatformTLSKey {
fatalError("Unable to create key")
}
return raw
#elseif os(WASI) && (swift(<6.1) || !_runtime(_multithreaded))
#elseif os(WASI) && !_runtime(_multithreaded)
return _PlatformTLSKey()
#else
var raw = pthread_key_t()
+21 -5
View File
@@ -1,12 +1,13 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
internal import CSystem
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
@@ -14,7 +15,6 @@ import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WASILibc)
import CSystem
import WASILibc
#elseif os(Windows)
import ucrt
@@ -139,7 +139,15 @@ internal func system_dup2(_ fd: Int32, _ fd2: Int32) -> Int32 {
#endif
return dup2(fd, fd2)
}
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
internal func system_dup3(_ fd: Int32, _ fd2: Int32, _ oflag: Int32) -> Int32 {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(fd, fd2, oflag) }
#endif
return csystem_posix_dup3(fd, fd2, oflag)
}
#endif // !os(WASI)
#if !os(WASI)
internal func system_pipe(_ fds: UnsafeMutablePointer<Int32>) -> CInt {
@@ -148,7 +156,15 @@ internal func system_pipe(_ fds: UnsafeMutablePointer<Int32>) -> CInt {
#endif
return pipe(fds)
}
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
internal func system_pipe2(_ fds: UnsafeMutablePointer<Int32>, _ oflag: Int32) -> CInt {
#if ENABLE_MOCKING
if mockingEnabled { return _mock(fds, oflag) }
#endif
return csystem_posix_pipe2(fds, oflag)
}
#endif // !os(WASI)
internal func system_ftruncate(_ fd: Int32, _ length: off_t) -> Int32 {
#if ENABLE_MOCKING
@@ -186,7 +202,7 @@ internal func system_confstr(
) -> Int {
return confstr(name, buf, len)
}
#endif
#endif // SYSTEM_PACKAGE_DARWIN
#if !os(Windows)
internal let SYSTEM_AT_REMOVE_DIR = AT_REMOVEDIR
@@ -254,7 +270,7 @@ internal func system_openat(
#endif
return openat(fd, path, oflag)
}
#endif
#endif // !os(Windows)
#if !os(WASI) // WASI has no umask
internal func system_umask(
@@ -262,7 +278,7 @@ internal func system_umask(
) -> CInterop.Mode {
return umask(mode)
}
#endif
#endif // !os(WASI)
internal func system_getenv(
_ name: UnsafePointer<CChar>
@@ -11,16 +11,15 @@
import ucrt
import WinSDK
import Synchronization
fileprivate var _umask: CInterop.Mode = 0o22
private let _umask = Atomic<CInterop.Mode>(0o22)
@inline(__always)
func umask(
_ mode: CInterop.Mode
) -> CInterop.Mode {
let oldMask = _umask
_umask = mode
return oldMask
_umask.exchange(mode, ordering: .relaxed)
}
@inline(__always)
@@ -38,9 +37,9 @@ internal func open(
guard let hFile = try? path.withCanonicalPathRepresentation({ path in
CreateFileW(path,
decodedFlags.dwDesiredAccess,
DWORD(FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE),
FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE,
&saAttrs,
decodedFlags.dwCreationDisposition,
decodedFlags.dwFlagsAndAttributes,
@@ -58,7 +57,7 @@ internal func open(
_ path: UnsafePointer<CInterop.PlatformChar>, _ oflag: Int32,
_ mode: CInterop.Mode
) -> CInt {
let actualMode = mode & ~_umask
let actualMode = mode & ~_umask.load(ordering: .relaxed)
guard let pSD = _createSecurityDescriptor(from: actualMode, for: .file) else {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
@@ -80,9 +79,9 @@ internal func open(
guard let hFile = try? path.withCanonicalPathRepresentation({ path in
CreateFileW(path,
decodedFlags.dwDesiredAccess,
DWORD(FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE),
FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE,
&saAttrs,
decodedFlags.dwCreationDisposition,
decodedFlags.dwFlagsAndAttributes,
@@ -135,7 +134,11 @@ internal func dup(_ fd: Int32) -> Int32 {
@inline(__always)
internal func dup2(_ fd: Int32, _ fd2: Int32) -> Int32 {
_dup2(fd, fd2)
// _dup2 returns 0 to indicate success.
if _dup2(fd, fd2) == 0 {
return fd2
}
return -1
}
@inline(__always)
@@ -145,6 +148,12 @@ internal func pread(
let handle: intptr_t = _get_osfhandle(fd)
if handle == /* INVALID_HANDLE_VALUE */ -1 { ucrt._set_errno(EBADF); return -1 }
// Windows ReadFile accepts DWORD (32-bit) for buffer size, so validate nbyte doesn't exceed it
if nbyte > Int(DWORD.max) {
ucrt._set_errno(EINVAL)
return -1
}
// NOTE: this is a non-owning handle, do *not* call CloseHandle on it
let hFile: HANDLE = HANDLE(bitPattern: handle)!
@@ -167,6 +176,12 @@ internal func pwrite(
let handle: intptr_t = _get_osfhandle(fd)
if handle == /* INVALID_HANDLE_VALUE */ -1 { ucrt._set_errno(EBADF); return -1 }
// Windows WriteFile accepts DWORD (32-bit) for buffer size, so validate nbyte doesn't exceed it
if nbyte > Int(DWORD.max) {
ucrt._set_errno(EINVAL)
return -1
}
// NOTE: this is a non-owning handle, do *not* call CloseHandle on it
let hFile: HANDLE = HANDLE(bitPattern: handle)!
@@ -185,11 +200,18 @@ internal func pwrite(
@inline(__always)
internal func pipe(
_ fds: UnsafeMutablePointer<Int32>, bytesReserved: UInt32 = 4096
_ fds: UnsafeMutablePointer<Int32>, bytesReserved: UInt32 = 0
) -> CInt {
return _pipe(fds, bytesReserved, _O_BINARY | _O_NOINHERIT);
}
@inline(__always)
internal func csystem_posix_pipe2(
_ fds: UnsafeMutablePointer<Int32>, bytesReserved: UInt32 = 0, _ oflag: Int32
) -> CInt {
return _pipe(fds, bytesReserved, _O_BINARY | oflag)
}
@inline(__always)
internal func ftruncate(_ fd: Int32, _ length: off_t) -> Int32 {
let handle: intptr_t = _get_osfhandle(fd)
@@ -202,16 +224,16 @@ internal func ftruncate(_ fd: Int32, _ length: off_t) -> Int32 {
// Save the current position and restore it when we're done
if !SetFilePointerEx(hFile, liCurrentOffset, &liCurrentOffset,
DWORD(FILE_CURRENT)) {
FILE_CURRENT) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
defer {
_ = SetFilePointerEx(hFile, liCurrentOffset, nil, DWORD(FILE_BEGIN));
_ = SetFilePointerEx(hFile, liCurrentOffset, nil, FILE_BEGIN);
}
// Truncate (or extend) the file
if !SetFilePointerEx(hFile, liDesiredLength, nil, DWORD(FILE_BEGIN))
if !SetFilePointerEx(hFile, liDesiredLength, nil, FILE_BEGIN)
|| !SetEndOfFile(hFile) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
@@ -225,7 +247,7 @@ internal func mkdir(
_ path: UnsafePointer<CInterop.PlatformChar>,
_ mode: CInterop.Mode
) -> CInt {
let actualMode = mode & ~_umask
let actualMode = mode & ~_umask.load(ordering: .relaxed)
guard let pSD = _createSecurityDescriptor(from: actualMode,
for: .directory) else {
@@ -263,7 +285,7 @@ internal func rmdir(
}
internal func _mapWindowsErrorToErrno(_ errorCode: DWORD) -> CInt {
switch Int32(errorCode) {
switch errorCode {
case ERROR_SUCCESS:
return 0
case ERROR_INVALID_FUNCTION,
@@ -342,28 +364,28 @@ fileprivate func rightsFromModeBits(
var rights: DWORD = 0
if (bits & 0o4) != 0 {
rights |= DWORD(FILE_READ_ATTRIBUTES
| FILE_READ_DATA
| FILE_READ_EA
| STANDARD_RIGHTS_READ
| SYNCHRONIZE)
rights |= (FILE_READ_ATTRIBUTES
| FILE_READ_DATA
| FILE_READ_EA
| STANDARD_RIGHTS_READ
| SYNCHRONIZE)
}
if (bits & 0o2) != 0 {
rights |= DWORD(FILE_APPEND_DATA
| FILE_WRITE_ATTRIBUTES
| FILE_WRITE_DATA
| FILE_WRITE_EA
| STANDARD_RIGHTS_WRITE
| SYNCHRONIZE)
rights |= (FILE_APPEND_DATA
| FILE_WRITE_ATTRIBUTES
| FILE_WRITE_DATA
| FILE_WRITE_EA
| STANDARD_RIGHTS_WRITE
| SYNCHRONIZE)
if fileOrDirectory == .directory && !sticky {
rights |= DWORD(FILE_DELETE_CHILD)
rights |= FILE_DELETE_CHILD
}
}
if (bits & 0o1) != 0 {
rights |= DWORD(FILE_EXECUTE
| FILE_READ_ATTRIBUTES
| STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE)
rights |= (FILE_EXECUTE
| FILE_READ_ATTRIBUTES
| STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE)
}
return rights
@@ -431,7 +453,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
var everyone: PSID? = nil
guard AllocateAndInitializeSid(&SIDAuthWorld, 1,
DWORD(SECURITY_WORLD_RID),
SECURITY_WORLD_RID,
0, 0, 0, 0, 0, 0, 0,
&everyone) else {
return nil
@@ -472,7 +494,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: ownerRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -485,7 +507,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: groupRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -498,7 +520,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: otherRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -515,7 +537,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: ownerDenyRights,
grfAccessMode: DENY_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -533,7 +555,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: groupDenyRights,
grfAccessMode: DENY_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -562,13 +584,13 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
var descriptor = SECURITY_DESCRIPTOR()
guard InitializeSecurityDescriptor(&descriptor,
DWORD(SECURITY_DESCRIPTOR_REVISION)) else {
SECURITY_DESCRIPTOR_REVISION) else {
return nil
}
guard SetSecurityDescriptorControl(&descriptor,
SECURITY_DESCRIPTOR_CONTROL(SE_DACL_PROTECTED),
SECURITY_DESCRIPTOR_CONTROL(SE_DACL_PROTECTED))
SE_DACL_PROTECTED,
SE_DACL_PROTECTED)
&& SetSecurityDescriptorOwner(&descriptor, user, false)
&& SetSecurityDescriptorGroup(&descriptor, group, false)
&& SetSecurityDescriptorDacl(&descriptor,
@@ -608,15 +630,15 @@ fileprivate struct DecodedOpenFlags {
init(_ oflag: Int32) {
switch oflag & (_O_CREAT | _O_EXCL | _O_TRUNC) {
case _O_CREAT | _O_EXCL, _O_CREAT | _O_EXCL | _O_TRUNC:
dwCreationDisposition = DWORD(CREATE_NEW)
dwCreationDisposition = CREATE_NEW
case _O_CREAT:
dwCreationDisposition = DWORD(OPEN_ALWAYS)
dwCreationDisposition = OPEN_ALWAYS
case _O_CREAT | _O_TRUNC:
dwCreationDisposition = DWORD(CREATE_ALWAYS)
dwCreationDisposition = CREATE_ALWAYS
case _O_TRUNC:
dwCreationDisposition = DWORD(TRUNCATE_EXISTING)
dwCreationDisposition = TRUNCATE_EXISTING
default:
dwCreationDisposition = DWORD(OPEN_EXISTING)
dwCreationDisposition = OPEN_EXISTING
}
// The _O_RDONLY, _O_WRONLY and _O_RDWR flags are non-overlapping
@@ -625,11 +647,11 @@ fileprivate struct DecodedOpenFlags {
dwDesiredAccess = 0
switch (oflag & (_O_RDONLY|_O_WRONLY|_O_RDWR)) {
case _O_RDONLY:
dwDesiredAccess |= DWORD(GENERIC_READ)
dwDesiredAccess |= GENERIC_READ
case _O_WRONLY:
dwDesiredAccess |= DWORD(GENERIC_WRITE)
dwDesiredAccess |= GENERIC_WRITE
case _O_RDWR:
dwDesiredAccess |= DWORD(GENERIC_READ) | DWORD(GENERIC_WRITE)
dwDesiredAccess |= GENERIC_READ | GENERIC_WRITE
default:
break
}
@@ -638,19 +660,19 @@ fileprivate struct DecodedOpenFlags {
dwFlagsAndAttributes = 0
if (oflag & _O_SEQUENTIAL) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_SEQUENTIAL_SCAN)
dwFlagsAndAttributes |= FILE_FLAG_SEQUENTIAL_SCAN
}
if (oflag & _O_RANDOM) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_RANDOM_ACCESS)
dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS
}
if (oflag & _O_TEMPORARY) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_DELETE_ON_CLOSE)
dwFlagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE
}
if (oflag & _O_SHORT_LIVED) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_ATTRIBUTE_TEMPORARY)
dwFlagsAndAttributes |= FILE_ATTRIBUTE_TEMPORARY
} else {
dwFlagsAndAttributes |= DWORD(FILE_ATTRIBUTE_NORMAL)
dwFlagsAndAttributes |= FILE_ATTRIBUTE_NORMAL
}
}
}
+6 -3
View File
@@ -9,7 +9,11 @@
#if SYSTEM_PACKAGE_DARWIN
#if canImport(Darwin, _version: 310)
import Darwin.Mach
#else
@preconcurrency import Darwin.Mach
#endif
@available(System 1.4.0, *)
public protocol MachPortRight {}
@@ -145,6 +149,7 @@ extension Mach.Port where RightType == Mach.ReceiveRight {
///
/// The underlying port right will be automatically deallocated when
/// the Mach.Port object is destroyed.
@available(System 1.4.0, *)
public init(name: mach_port_name_t, context: mach_port_context_t) {
precondition(name != mach_port_name_t(MACH_PORT_NULL),
"Mach.Port cannot be initialized with MACH_PORT_NULL")
@@ -180,7 +185,6 @@ extension Mach.Port where RightType == Mach.ReceiveRight {
///
/// After this function completes, the Mach.Port is destroyed and no longer
/// usable.
@inlinable
@available(System 1.4.0, *)
public consuming func relinquish(
) -> (name: mach_port_name_t, context: mach_port_context_t) {
@@ -322,7 +326,7 @@ extension Mach.Port where RightType == Mach.SendRight {
///
/// After this function completes, the Mach.Port is destroyed and no longer
/// usable.
@inlinable
@available(System 1.4.0, *)
public consuming func relinquish() -> mach_port_name_t {
let name = _name
discard self
@@ -365,7 +369,6 @@ extension Mach.Port where RightType == Mach.SendOnceRight {
///
/// After this function completes, the Mach.Port is destroyed and no longer
/// usable.
@inlinable
@available(System 1.4.0, *)
public consuming func relinquish() -> mach_port_name_t {
let name = _name
+439
View File
@@ -0,0 +1,439 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
#if os(Windows)
import WinSDK
@_transparent
internal var CREATE_ALWAYS: DWORD {
DWORD(WinSDK.CREATE_ALWAYS)
}
@_transparent
internal var CREATE_NEW: DWORD {
DWORD(WinSDK.CREATE_NEW)
}
@_transparent
internal var ERROR_ACCESS_DENIED: DWORD {
DWORD(WinSDK.ERROR_ACCESS_DENIED)
}
@_transparent
internal var ERROR_ALREADY_EXISTS: DWORD {
DWORD(WinSDK.ERROR_ALREADY_EXISTS)
}
@_transparent
internal var ERROR_ARENA_TRASHED: DWORD {
DWORD(WinSDK.ERROR_ARENA_TRASHED)
}
@_transparent
internal var ERROR_BAD_ENVIRONMENT: DWORD {
DWORD(WinSDK.ERROR_BAD_ENVIRONMENT)
}
@_transparent
internal var ERROR_BAD_FORMAT: DWORD {
DWORD(WinSDK.ERROR_BAD_FORMAT)
}
@_transparent
internal var ERROR_BAD_NET_NAME: DWORD {
DWORD(WinSDK.ERROR_BAD_NET_NAME)
}
@_transparent
internal var ERROR_BAD_NETPATH: DWORD {
DWORD(WinSDK.ERROR_BAD_NETPATH)
}
@_transparent
internal var ERROR_BAD_PATHNAME: DWORD {
DWORD(WinSDK.ERROR_BAD_PATHNAME)
}
@_transparent
internal var ERROR_BROKEN_PIPE: DWORD {
DWORD(WinSDK.ERROR_BROKEN_PIPE)
}
@_transparent
internal var ERROR_CANNOT_MAKE: DWORD {
DWORD(WinSDK.ERROR_CANNOT_MAKE)
}
@_transparent
internal var ERROR_CHILD_NOT_COMPLETE: DWORD {
DWORD(WinSDK.ERROR_CHILD_NOT_COMPLETE)
}
@_transparent
internal var ERROR_CURRENT_DIRECTORY: DWORD {
DWORD(WinSDK.ERROR_CURRENT_DIRECTORY)
}
@_transparent
internal var ERROR_DIR_NOT_EMPTY: DWORD {
DWORD(WinSDK.ERROR_DIR_NOT_EMPTY)
}
@_transparent
internal var ERROR_DISK_FULL: DWORD {
DWORD(WinSDK.ERROR_DISK_FULL)
}
@_transparent
internal var ERROR_DRIVE_LOCKED: DWORD {
DWORD(WinSDK.ERROR_DRIVE_LOCKED)
}
@_transparent
internal var ERROR_DIRECT_ACCESS_HANDLE: DWORD {
DWORD(WinSDK.ERROR_DIRECT_ACCESS_HANDLE)
}
@_transparent
internal var ERROR_FILE_EXISTS: DWORD {
DWORD(WinSDK.ERROR_FILE_EXISTS)
}
@_transparent
internal var ERROR_FILE_NOT_FOUND: DWORD {
DWORD(WinSDK.ERROR_FILE_NOT_FOUND)
}
@_transparent
internal var ERROR_FAIL_I24: DWORD {
DWORD(WinSDK.ERROR_FAIL_I24)
}
@_transparent
internal var ERROR_FILENAME_EXCED_RANGE: DWORD {
DWORD(WinSDK.ERROR_FILENAME_EXCED_RANGE)
}
@_transparent
internal var ERROR_NEGATIVE_SEEK: DWORD {
DWORD(WinSDK.ERROR_NEGATIVE_SEEK)
}
@_transparent
internal var ERROR_NO_MORE_FILES: DWORD {
DWORD(WinSDK.ERROR_NO_MORE_FILES)
}
@_transparent
internal var ERROR_NO_UNICODE_TRANSLATION: DWORD {
DWORD(WinSDK.ERROR_NO_UNICODE_TRANSLATION)
}
@_transparent
internal var ERROR_NOT_ENOUGH_MEMORY: DWORD {
DWORD(WinSDK.ERROR_NOT_ENOUGH_MEMORY)
}
@_transparent
internal var ERROR_INVALID_ACCESS: DWORD {
DWORD(WinSDK.ERROR_INVALID_ACCESS)
}
@_transparent
internal var ERROR_INVALID_BLOCK: DWORD {
DWORD(WinSDK.ERROR_INVALID_BLOCK)
}
@_transparent
internal var ERROR_INVALID_DATA: DWORD {
DWORD(WinSDK.ERROR_INVALID_DATA)
}
@_transparent
internal var ERROR_INVALID_DRIVE: DWORD {
DWORD(WinSDK.ERROR_INVALID_DRIVE)
}
@_transparent
internal var ERROR_INVALID_FUNCTION: DWORD {
DWORD(WinSDK.ERROR_INVALID_FUNCTION)
}
@_transparent
internal var ERROR_INVALID_HANDLE: DWORD {
DWORD(WinSDK.ERROR_INVALID_HANDLE)
}
@_transparent
internal var ERROR_INFLOOP_IN_RELOC_CHAIN: DWORD {
DWORD(WinSDK.ERROR_INFLOOP_IN_RELOC_CHAIN)
}
@_transparent
internal var ERROR_INVALID_PARAMETER: DWORD {
DWORD(WinSDK.ERROR_INVALID_PARAMETER)
}
@_transparent
internal var ERROR_INVALID_STARTING_CODESEG: DWORD {
DWORD(WinSDK.ERROR_INVALID_STARTING_CODESEG)
}
@_transparent
internal var ERROR_INVALID_TARGET_HANDLE: DWORD {
DWORD(WinSDK.ERROR_INVALID_TARGET_HANDLE)
}
@_transparent
internal var ERROR_LOCK_FAILED: DWORD {
DWORD(WinSDK.ERROR_LOCK_FAILED)
}
@_transparent
internal var ERROR_LOCK_VIOLATION: DWORD {
DWORD(WinSDK.ERROR_LOCK_VIOLATION)
}
@_transparent
internal var ERROR_MAX_THRDS_REACHED: DWORD {
DWORD(WinSDK.ERROR_MAX_THRDS_REACHED)
}
@_transparent
internal var ERROR_NESTING_NOT_ALLOWED: DWORD {
DWORD(WinSDK.ERROR_NESTING_NOT_ALLOWED)
}
@_transparent
internal var ERROR_NETWORK_ACCESS_DENIED: DWORD {
DWORD(WinSDK.ERROR_NETWORK_ACCESS_DENIED)
}
@_transparent
internal var ERROR_NO_PROC_SLOTS: DWORD {
DWORD(WinSDK.ERROR_NO_PROC_SLOTS)
}
@_transparent
internal var ERROR_NOT_ENOUGH_QUOTA: DWORD {
DWORD(WinSDK.ERROR_NOT_ENOUGH_QUOTA)
}
@_transparent
internal var ERROR_NOT_LOCKED: DWORD {
DWORD(WinSDK.ERROR_NOT_LOCKED)
}
@_transparent
internal var ERROR_NOT_SAME_DEVICE: DWORD {
DWORD(WinSDK.ERROR_NOT_SAME_DEVICE)
}
@_transparent
internal var ERROR_PATH_NOT_FOUND: DWORD {
DWORD(WinSDK.ERROR_PATH_NOT_FOUND)
}
@_transparent
internal var ERROR_SEEK_ON_DEVICE: DWORD {
DWORD(WinSDK.ERROR_SEEK_ON_DEVICE)
}
@_transparent
internal var ERROR_SHARING_BUFFER_EXCEEDED: DWORD {
DWORD(WinSDK.ERROR_SHARING_BUFFER_EXCEEDED)
}
@_transparent
internal var ERROR_SUCCESS: DWORD {
DWORD(WinSDK.ERROR_SUCCESS)
}
@_transparent
internal var ERROR_WAIT_NO_CHILDREN: DWORD {
DWORD(WinSDK.ERROR_WAIT_NO_CHILDREN)
}
@_transparent
internal var ERROR_WRITE_PROTECT: DWORD {
DWORD(WinSDK.ERROR_WRITE_PROTECT)
}
@_transparent
internal var ERROR_TOO_MANY_OPEN_FILES: DWORD {
DWORD(WinSDK.ERROR_TOO_MANY_OPEN_FILES)
}
@_transparent
internal var FILE_APPEND_DATA: DWORD {
DWORD(WinSDK.FILE_APPEND_DATA)
}
@_transparent
internal var FILE_ATTRIBUTE_DIRECTORY: DWORD {
DWORD(WinSDK.FILE_ATTRIBUTE_DIRECTORY)
}
@_transparent
internal var FILE_ATTRIBUTE_NORMAL: DWORD {
DWORD(WinSDK.FILE_ATTRIBUTE_NORMAL)
}
@_transparent
internal var FILE_ATTRIBUTE_TEMPORARY: DWORD {
DWORD(WinSDK.FILE_ATTRIBUTE_TEMPORARY)
}
@_transparent
internal var FILE_BEGIN: DWORD {
DWORD(WinSDK.FILE_BEGIN)
}
@_transparent
internal var FILE_CURRENT: DWORD {
DWORD(WinSDK.FILE_CURRENT)
}
@_transparent
internal var FILE_DELETE_CHILD: DWORD {
DWORD(WinSDK.FILE_DELETE_CHILD)
}
@_transparent
package var FILE_EXECUTE: DWORD {
DWORD(WinSDK.FILE_EXECUTE)
}
@_transparent
internal var FILE_FLAG_DELETE_ON_CLOSE: DWORD {
DWORD(WinSDK.FILE_FLAG_DELETE_ON_CLOSE)
}
@_transparent
internal var FILE_FLAG_RANDOM_ACCESS: DWORD {
DWORD(WinSDK.FILE_FLAG_RANDOM_ACCESS)
}
@_transparent
internal var FILE_FLAG_SEQUENTIAL_SCAN: DWORD {
DWORD(WinSDK.FILE_FLAG_SEQUENTIAL_SCAN)
}
@_transparent
package var FILE_READ_ATTRIBUTES: DWORD {
DWORD(WinSDK.FILE_READ_ATTRIBUTES)
}
@_transparent
internal var FILE_READ_DATA: DWORD {
DWORD(WinSDK.FILE_READ_DATA)
}
@_transparent
internal var FILE_READ_EA: DWORD {
DWORD(WinSDK.FILE_READ_EA)
}
@_transparent
internal var FILE_SHARE_DELETE: DWORD {
DWORD(WinSDK.FILE_SHARE_DELETE)
}
@_transparent
internal var FILE_SHARE_READ: DWORD {
DWORD(WinSDK.FILE_SHARE_READ)
}
@_transparent
internal var FILE_SHARE_WRITE: DWORD {
DWORD(WinSDK.FILE_SHARE_WRITE)
}
@_transparent
package var FILE_WRITE_ATTRIBUTES: DWORD {
DWORD(WinSDK.FILE_WRITE_ATTRIBUTES)
}
@_transparent
internal var FILE_WRITE_DATA: DWORD {
DWORD(WinSDK.FILE_WRITE_DATA)
}
@_transparent
internal var FILE_WRITE_EA: DWORD {
DWORD(WinSDK.FILE_WRITE_EA)
}
@_transparent
internal var GENERIC_READ: DWORD {
DWORD(WinSDK.GENERIC_READ)
}
@_transparent
internal var GENERIC_WRITE: DWORD {
DWORD(WinSDK.GENERIC_WRITE)
}
@_transparent
internal var NO_INHERITANCE: DWORD {
DWORD(WinSDK.NO_INHERITANCE)
}
@_transparent
internal var OPEN_ALWAYS: DWORD {
DWORD(WinSDK.OPEN_ALWAYS)
}
@_transparent
internal var OPEN_EXISTING: DWORD {
DWORD(WinSDK.OPEN_EXISTING)
}
@_transparent
internal var SE_DACL_PROTECTED: SECURITY_DESCRIPTOR_CONTROL {
SECURITY_DESCRIPTOR_CONTROL(WinSDK.SE_DACL_PROTECTED)
}
@_transparent
internal var SECURITY_DESCRIPTOR_REVISION: DWORD {
DWORD(WinSDK.SECURITY_DESCRIPTOR_REVISION)
}
@_transparent
internal var SECURITY_WORLD_RID: DWORD {
DWORD(WinSDK.SECURITY_WORLD_RID)
}
@_transparent
internal var STANDARD_RIGHTS_READ: DWORD {
DWORD(WinSDK.STANDARD_RIGHTS_READ)
}
@_transparent
internal var STANDARD_RIGHTS_EXECUTE: DWORD {
DWORD(WinSDK.STANDARD_RIGHTS_EXECUTE)
}
@_transparent
internal var STANDARD_RIGHTS_WRITE: DWORD {
DWORD(WinSDK.STANDARD_RIGHTS_WRITE)
}
@_transparent
internal var SYNCHRONIZE: DWORD {
DWORD(WinSDK.SYNCHRONIZE)
}
@_transparent
internal var TRUNCATE_EXISTING: DWORD {
DWORD(WinSDK.TRUNCATE_EXISTING)
}
#endif
+50
View File
@@ -0,0 +1,50 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
// Compile-only canary for MemberImportVisibility regressions: this file fails
// to build if a C member of a type SystemPackage vends is attributed to the
// private CSystem module.
//
// For new type wrappers introduced to System, access their C members here:
// - Import the platform overlay (Glibc/Musl/Android), as consumers do.
// - Access raw C members of vended types (e.g. CInterop.Stat) as a downstream
// consumer would. Don't go through the Swift (e.g. Stat) wrapper since its
// accesses happen inside System, where importing CSystem is fine.
// - Touch every direct member the public API exposes, and the members of C
// types it exposes through them (e.g. timespec). One field is not always a
// safe proxy for the rest.
#if canImport(Glibc) || canImport(Musl) || canImport(Android)
#if canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(Android)
import Android
#endif
import SystemPackage
func _mivProbe(_ s: CInterop.Stat) {
_ = s.st_dev
_ = s.st_ino
_ = s.st_mode
_ = s.st_nlink
_ = s.st_uid
_ = s.st_gid
_ = s.st_rdev
_ = s.st_size
_ = s.st_blksize
_ = s.st_blocks
_ = s.st_atim
_ = s.st_mtim
_ = s.st_ctim
_ = s.st_atim.tv_sec
_ = s.st_atim.tv_nsec
}
#endif
+136
View File
@@ -0,0 +1,136 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 - 2026 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
import Testing
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@Suite("FileMode")
private struct FileModeTests {
@available(System 1.7.0, *)
@Test func basics() async throws {
var mode = FileMode(rawValue: S_IFREG | 0o644) // Regular file, rw-r--r--
#expect(mode.type == .regular)
#expect(mode.permissions == [.ownerReadWrite, .groupRead, .otherRead])
mode.type = .directory // Directory, rw-r--r--
#expect(mode.type == .directory)
#expect(mode.permissions == [.ownerReadWrite, .groupRead, .otherRead])
mode.permissions.insert([.ownerExecute, .groupExecute, .otherExecute]) // Directory, rwxr-xr-x
#expect(mode.type == .directory)
#expect(mode.permissions == [.ownerReadWriteExecute, .groupReadExecute, .otherReadExecute])
mode.type = .symbolicLink // Symbolic link, rwxr-xr-x
#expect(mode.type == .symbolicLink)
#expect(mode.permissions == [.ownerReadWriteExecute, .groupReadExecute, .otherReadExecute])
let mode1 = FileMode(rawValue: S_IFLNK | 0o755) // Symbolic link, rwxr-xr-x
let mode2 = FileMode(type: .symbolicLink, permissions: [.ownerReadWriteExecute, .groupReadExecute, .otherReadExecute])
#expect(mode == mode1)
#expect(mode1 == mode2)
mode.permissions.remove([.otherReadExecute]) // Symbolic link, rwxr-x---
#expect(mode.permissions == [.ownerReadWriteExecute, .groupReadExecute])
#expect(mode != mode1)
#expect(mode != mode2)
#expect(mode.type == mode1.type)
#expect(mode.type == mode2.type)
}
@available(System 1.7.0, *)
@Test func invalidInput() async throws {
// No permissions, all other bits set
var invalidMode = FileMode(rawValue: ~0o7777)
#expect(invalidMode.permissions.isEmpty)
#expect(invalidMode.type != .directory)
#expect(invalidMode.type != .characterSpecial)
#expect(invalidMode.type != .blockSpecial)
#expect(invalidMode.type != .regular)
#expect(invalidMode.type != .fifo)
#expect(invalidMode.type != .symbolicLink)
#expect(invalidMode.type != .socket)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(invalidMode.type != .whiteout)
#endif
// All file-type bits set
invalidMode = FileMode(rawValue: S_IFMT)
#expect(invalidMode.type != .directory)
#expect(invalidMode.type != .characterSpecial)
#expect(invalidMode.type != .blockSpecial)
#expect(invalidMode.type != .regular)
#expect(invalidMode.type != .fifo)
#expect(invalidMode.type != .symbolicLink)
#expect(invalidMode.type != .socket)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(invalidMode.type != .whiteout)
#endif
// FileMode(type:permissions:) masks its inputs so
// they don't accidentally modify the other bits.
let emptyPermissions = FileMode(type: FileType(rawValue: ~0), permissions: [])
#expect(emptyPermissions.permissions.isEmpty)
#expect(emptyPermissions.type == FileType(rawValue: S_IFMT))
#expect(emptyPermissions == invalidMode)
let regularFile = FileMode(type: .regular, permissions: FilePermissions(rawValue: ~0))
#expect(regularFile.type == .regular)
#expect(regularFile.permissions == FilePermissions(rawValue: 0o7777))
#expect(regularFile.permissions == [
.ownerReadWriteExecute,
.groupReadWriteExecute,
.otherReadWriteExecute,
.setUserID, .setGroupID, .saveText
])
// Setting properties should not modify the other bits, either.
var mode = FileMode(rawValue: 0)
mode.type = FileType(rawValue: ~0)
#expect(mode.type == FileType(rawValue: S_IFMT))
#expect(mode.permissions.isEmpty)
mode.type.rawValue = 0
#expect(mode.type == FileType(rawValue: 0))
#expect(mode.permissions.isEmpty)
mode.permissions = FilePermissions(rawValue: ~0)
#expect(mode.permissions == FilePermissions(rawValue: 0o7777))
#expect(mode.type == FileType(rawValue: 0))
mode.permissions = []
#expect(mode.permissions.isEmpty)
#expect(mode.type == FileType(rawValue: 0))
}
}
#endif
+120 -2
View File
@@ -1,7 +1,7 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
@@ -157,7 +157,8 @@ final class FileOperationsTest: XCTestCase {
// TODO: Test writeAll, writeAll(toAbsoluteOffset), closeAfter
}
#if !os(WASI) // WASI has no pipe
#if !os(WASI) // WASI has no pipe
@available(System 1.1.0, *)
func testAdHocPipe() throws {
// Ad-hoc test testing `Pipe` functionality.
// We cannot test `Pipe` using `MockTestCase` because it calls `pipe` with a pointer to an array local to the `Pipe`, the address of which we do not know prior to invoking `Pipe`.
@@ -176,7 +177,123 @@ final class FileOperationsTest: XCTestCase {
}
}
}
func testAdHocPipeWithOptions() throws {
guard #available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *) else {
throw XCTSkip("pipe2 and PipeOptions require Darwin 27 or newer")
}
// Ad-hoc test testing `Pipe` functionality.
// We cannot test `Pipe` using `MockTestCase` because it calls `pipe` with a pointer to an array local to the `Pipe`, the address of which we do not know prior to invoking `Pipe`.
let options: FileDescriptor.PipeOptions = [.closeOnExec]
let pipe: (readEnd: FileDescriptor, writeEnd: FileDescriptor)
pipe = try FileDescriptor.pipe(options: options)
try pipe.readEnd.closeAfter {
try pipe.writeEnd.closeAfter {
var abc = "abc"
try abc.withUTF8 {
_ = try pipe.writeEnd.write(UnsafeRawBufferPointer($0))
}
let readLen = 3
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { buf, count in
count = try pipe.readEnd.read(into: UnsafeMutableRawBufferPointer(buf))
}
XCTAssertEqual(readBytes, Array(abc.utf8))
}
}
}
#if canImport(Darwin, _version: 428) // The macOS 27 SDK defines O_CLOFORK.
func testAdHocPipeCloseOnFork() throws {
guard #available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *) else {
throw XCTSkip("pipe2 and PipeOptions require anyAppleOS 27 or newer")
}
// System spells O_CLOFORK as a literal on Darwin.
XCTAssertEqual(FileDescriptor.PipeOptions.closeOnFork.rawValue, O_CLOFORK)
let pipe = try FileDescriptor.pipe(options: .closeOnFork)
try pipe.readEnd.closeAfter {
try pipe.writeEnd.closeAfter {
XCTAssertEqual(fcntl(pipe.readEnd.rawValue, F_GETFD) & FD_CLOFORK, FD_CLOFORK)
}
}
}
#endif
#endif // !os(WASI)
#if !os(Windows)
func testAdHocDuplicate2() throws {
try withTemporaryFilePath(basename: "test") {
let path = $0.appending("foo2.txt")
let fd1 = try FileDescriptor.open(path, .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite)
let fd2 = FileDescriptor(rawValue: 731)
let fd3 = try fd1.duplicate(as: fd2)
XCTAssertEqual(fd2, fd3)
try fd2.close()
do {
try fd3.close()
XCTFail("Should be unreachable")
} catch {
if let error = try? XCTUnwrap(error as? Errno) {
XCTAssertEqual(error, .badFileDescriptor)
}
}
// dup2() accepts two equal parameters.
let fd4 = try fd1.duplicate(as: fd1)
XCTAssertEqual(fd4, fd1)
try fd1.close()
do {
try fd4.close()
XCTFail("Should be unreachable")
} catch {
if let error = try? XCTUnwrap(error as? Errno) {
XCTAssertEqual(error, .badFileDescriptor)
}
}
}
}
func testAdHocDuplicate3() throws {
guard #available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *) else {
throw XCTSkip("dup3 and DuplicateOptions require Darwin 27 or newer")
}
try withTemporaryFilePath(basename: "test") {
let path = $0.appending("foo3.txt")
let fd1 = try FileDescriptor.open(path, .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite)
let fd2 = FileDescriptor(rawValue: 731)
let fd3 = try fd1.duplicate(as: fd2, options: [.closeOnExec])
XCTAssertEqual(fd2, fd3)
try fd2.close()
do {
try fd3.close()
} catch {
if let error = try? XCTUnwrap(error as? Errno) {
XCTAssertEqual(error, .badFileDescriptor)
}
}
// dup3() does not accept two equal parameters.
do {
_ = try fd1.duplicate(as: fd1, options: [])
XCTFail("Should be unreachable")
} catch {
if let error = try? XCTUnwrap(error as? Errno) {
XCTAssertEqual(error, .invalidArgument)
}
}
}
}
#endif // !os(Windows)
func testAdHocOpen() {
// Ad-hoc test touching a file system.
@@ -236,6 +353,7 @@ final class FileOperationsTest: XCTestCase {
}
#endif // ENABLE_MOCKING
@available(System 1.2.0, *)
func testResizeFile() throws {
try withTemporaryFilePath(basename: "testResizeFile") { path in
let fd = try FileDescriptor.open(path.appending("\(UUID().uuidString).txt"), .readWrite, options: [.create, .truncate], permissions: .ownerReadWrite)
+112 -26
View File
@@ -18,6 +18,11 @@ import XCTest
#endif
import WinSDK
import ucrt
private let FILE_APPEND_DATA = DWORD(WinSDK.FILE_APPEND_DATA)
private let FILE_EXECUTE = DWORD(WinSDK.FILE_EXECUTE)
private let FILE_READ_ATTRIBUTES = DWORD(WinSDK.FILE_READ_ATTRIBUTES)
@available(iOS 8, *)
final class FileOperationsTestWindows: XCTestCase {
@@ -43,6 +48,8 @@ final class FileOperationsTestWindows: XCTestCase {
| SYNCHRONIZE
)
private let none = ACCESS_MASK(0)
private struct Test {
var permissions: CModeT
var ownerAccess: ACCESS_MASK
@@ -72,7 +79,7 @@ final class FileOperationsTestWindows: XCTestCase {
var psidEveryone: PSID? = nil
XCTAssert(AllocateAndInitializeSid(&SIDAuthWorld, 1,
DWORD(SECURITY_WORLD_RID),
SECURITY_WORLD_RID,
0, 0, 0, 0, 0, 0, 0,
&psidEveryone))
defer {
@@ -106,7 +113,7 @@ final class FileOperationsTestWindows: XCTestCase {
&psidGroup,
&pDacl,
nil,
&pSD), DWORD(ERROR_SUCCESS))
&pSD), ERROR_SUCCESS)
defer {
LocalFree(pSD)
}
@@ -135,15 +142,15 @@ final class FileOperationsTestWindows: XCTestCase {
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&owner,
&ownerAccess), DWORD(ERROR_SUCCESS))
&ownerAccess), ERROR_SUCCESS)
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&group,
&groupAccess), DWORD(ERROR_SUCCESS))
&groupAccess), ERROR_SUCCESS)
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&everyone,
&otherAccess), DWORD(ERROR_SUCCESS))
&otherAccess), ERROR_SUCCESS)
return (ownerAccess, groupAccess, otherAccess)
}
@@ -182,9 +189,9 @@ final class FileOperationsTestWindows: XCTestCase {
try withTemporaryFilePath(basename: "testUmask") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r|x, 0),
Test(0o000, none, none, none),
Test(0o700, r|w|x, none, none),
Test(0o770, r|w|x, r|x, none),
Test(0o777, r|w|x, r|x, r|x)
]
@@ -195,9 +202,9 @@ final class FileOperationsTestWindows: XCTestCase {
.otherWrite, .otherExecute]) {
try withTemporaryFilePath(basename: "testUmask") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r, 0),
Test(0o000, none, none, none),
Test(0o700, r|w|x, none, none),
Test(0o770, r|w|x, r, none),
Test(0o777, r|w|x, r, r)
]
@@ -214,34 +221,113 @@ final class FileOperationsTestWindows: XCTestCase {
try FilePermissions.withCreationMask([]) {
try withTemporaryFilePath(basename: "testPermissions") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o000, none, none, none),
Test(0o400, r, 0, 0),
Test(0o200, w, 0, 0),
Test(0o100, x, 0, 0),
Test(0o040, 0, r, 0),
Test(0o020, 0, w, 0),
Test(0o010, 0, x, 0),
Test(0o004, 0, 0, r),
Test(0o002, 0, 0, w),
Test(0o001, 0, 0, x),
Test(0o400, r, none, none),
Test(0o200, w, none, none),
Test(0o100, x, none, none),
Test(0o040, none, r, none),
Test(0o020, none, w, none),
Test(0o010, none, x, none),
Test(0o004, none, none, r),
Test(0o002, none, none, w),
Test(0o001, none, none, x),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r|w|x, 0),
Test(0o700, r|w|x, none, none),
Test(0o770, r|w|x, r|w|x, none),
Test(0o777, r|w|x, r|w|x, r|w|x),
Test(0o755, r|w|x, r|x, r|x),
Test(0o644, r|w, r, r),
Test(0o007, 0, 0, r|w|x),
Test(0o070, 0, r|w|x, 0),
Test(0o077, 0, r|w|x, r|w|x),
Test(0o007, none, none, r|w|x),
Test(0o070, none, r|w|x, none),
Test(0o077, none, r|w|x, r|w|x),
]
try runTests(tests, at: path)
}
}
}
/// Test that buffer sizes exceeding DWORD.max (4GB) are properly rejected
func testBufferSizeLimit() throws {
try withTemporaryFilePath(basename: "testBufferSizeLimit") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"),
.readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
defer { try? fd.close() }
// Write some data first
try fd.writeAll("test data".utf8)
// Allocate a small buffer for testing
let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 1024, alignment: 1)
defer { buffer.deallocate() }
// Test that a count exceeding DWORD.max (UInt32.max = 4,294,967,295) returns EINVAL
// We use a buffer pointer but pass a count > DWORD.max
let oversizedCount = Int(DWORD.max) + 1
let oversizedBuffer = UnsafeMutableRawBufferPointer(
start: buffer.baseAddress,
count: oversizedCount
)
// pread should fail with EINVAL
do {
_ = try fd.read(fromAbsoluteOffset: 0, into: oversizedBuffer)
XCTFail("Expected EINVAL for buffer size exceeding DWORD.max")
} catch let err as Errno {
XCTAssertEqual(err, .invalidArgument, "Expected EINVAL, got \(err)")
}
// pwrite should also fail with EINVAL
do {
_ = try fd.write(toAbsoluteOffset: 0, UnsafeRawBufferPointer(oversizedBuffer))
XCTFail("Expected EINVAL for buffer size exceeding DWORD.max")
} catch let err as Errno {
XCTAssertEqual(err, .invalidArgument, "Expected EINVAL, got \(err)")
}
// Verify that exactly DWORD.max works (if we had a buffer that large)
// We can't easily test this without allocating 4GB, but the boundary is correct
}
}
func testCloseOnExecOpenOption() throws {
try withTemporaryFilePath(basename: "testCloseOnExec") { path in
func hasInheritFlag(of fd: FileDescriptor) throws -> Bool {
let osfHandle = _get_osfhandle(fd.rawValue)
let handle = try XCTUnwrap(HANDLE(bitPattern: osfHandle))
var flags: DWORD = 0
XCTAssertTrue(GetHandleInformation(handle, &flags))
return flags & DWORD(HANDLE_FLAG_INHERIT) == DWORD(HANDLE_FLAG_INHERIT)
}
var fd: FileDescriptor
fd = try FileDescriptor.open(
path.appending("wontinherit.txt"), .readWrite,
options: [.create, .truncate, .closeOnExec],
permissions: .ownerReadWrite
)
try fd.closeAfter {
XCTAssertEqual(try hasInheritFlag(of: fd), false)
}
fd = try FileDescriptor.open(
path.appending("inheritable.txt"), .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
try fd.closeAfter {
XCTAssertEqual(try hasInheritFlag(of: fd), true)
}
}
}
}
#endif // os(Windows)
@@ -107,7 +107,7 @@ final class FilePathComponentsTest: XCTestCase {
func expect(
_ s: String,
_ file: StaticString = #file,
_ file: StaticString = #filePath,
_ line: UInt = #line
) {
if path == FilePath(s) { return }
@@ -850,7 +850,7 @@ final class FilePathSyntaxTest: XCTestCase {
func expect(
_ s: String,
_ file: StaticString = #file,
_ file: StaticString = #filePath,
_ line: UInt = #line
) {
if path == FilePath(s) { return }
+2 -1
View File
@@ -22,7 +22,8 @@ func requestBytes(_ request: consuming RawIORequest) -> [UInt8] {
// which are known to work correctly.
final class IORequestTests: XCTestCase {
func testNop() {
let req = IORing.Request.nop().makeRawRequest()
let req = IORing.Request.nop().makeRawRequest(
pathBuffers: PendingPathBuffers(reservedCapacity: 0))
let sourceBytes = requestBytes(req)
// convenient property of nop: it's all zeros!
// for some unknown reason, liburing sets the fd field to -1.
+200 -16
View File
@@ -2,7 +2,13 @@
#if os(Linux)
import XCTest
import CSystem //for eventfd
import CSystem // for eventfd and csystem_io_uring_setup
import CSystemIOUring
#if canImport(Glibc)
import Glibc // for errno
#elseif canImport(Musl)
import Musl // for errno
#endif
#if SYSTEM_PACKAGE
import SystemPackage
@@ -10,29 +16,80 @@ import SystemPackage
import System
#endif
func uringEnabled() throws -> Bool {
// Cache `isUringEnabled()`. The probe is complex and the answer doesn't change
// during a test run.
let uringEnabled: Bool = {
do {
let procPath = FilePath("/proc/sys/kernel/io_uring_disabled")
let fd = try FileDescriptor.open(procPath, .readOnly)
let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 1024, alignment: 0)
_ = try fd.read(into: buffer)
if buffer.load(fromByteOffset: 0, as: Int.self) == 0 {
return true
}
} catch (_) {
return try isUringEnabled()
} catch {
return false
}
return false
}()
func isUringEnabled() throws -> Bool {
// Even if the kernel supports io_uring, the SystemPackage build may have
// been compiled against older kernel headers that lack features it needs
// (gated on IORING_TIMEOUT_BOOTTIME in io_uring.h); in that configuration
// IORing.init throws ENOTSUP. Treat that as disabled so tests skip cleanly
// instead of failing.
do throws(Errno) {
_ = try IORing(queueDepth: 1, flags: [])
} catch {
switch error {
case .notSupported, .noFunction, .invalidArgument,
.notPermitted, .permissionDenied:
return false
default:
throw error
}
}
// The ideal test uses /proc/sys/kernel/io_uring_disabled (Linux >= 6.6).
if let fd = try? FileDescriptor.open(
"/proc/sys/kernel/io_uring_disabled", .readOnly)
{
defer { try? fd.close() }
let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 1, alignment: 1)
defer { buffer.deallocate() }
let n = try fd.read(into: buffer)
return n == 1 && (buffer.load(as: UInt8.self) == UInt8(ascii: "0"))
}
// Fallback for older kernels: simply attempt io_uring_setup.
// - ENOSYS -> syscall doesn't exist (Linux < 5.1) -> disabled.
// - EPERM or EACCES -> treat as disabled
// - propagate any other error.
var params = io_uring_params()
let raw = csystem_io_uring_setup(1, &params)
if raw < 0 {
let err = Errno(rawValue: errno)
switch err {
case .noFunction, .notPermitted, .permissionDenied:
return false
default:
throw err
}
}
try? FileDescriptor(rawValue: raw).close()
return true
}
final class IORingTests: XCTestCase {
func testIsUringEnabled() throws {
// If `isUringEnabled()` throws, it is incomplete in some way.
let enabled = try isUringEnabled()
if !enabled {
print("IORing tests will be skipped.")
}
}
func testInit() throws {
guard try uringEnabled() else { return }
guard uringEnabled else { return }
_ = try IORing(queueDepth: 32, flags: [])
}
func testNop() throws {
guard try uringEnabled() else { return }
guard uringEnabled else { return }
var ring = try IORing(queueDepth: 32, flags: [])
_ = try ring.submit(linkedRequests: .nop())
let completion = try ring.blockingConsumeCompletion()
@@ -68,7 +125,7 @@ final class IORingTests: XCTestCase {
}
func testUndersizedSubmissionQueue() throws {
guard try uringEnabled() else { return }
guard uringEnabled else { return }
var ring: IORing = try IORing(queueDepth: 1)
let enqueued = ring.prepare(linkedRequests: .nop(), .nop())
XCTAssertFalse(enqueued)
@@ -76,7 +133,7 @@ final class IORingTests: XCTestCase {
// Exercises opening, reading, closing, registered files, registered buffers, and eventfd
func testOpenReadAndWriteFixedFile() throws {
guard try uringEnabled() else { return }
guard uringEnabled else { return }
let (parent, path) = try makeHelloWorldFile()
let rawBuffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 13, alignment: 16)
var ring = try setupTestRing(depth: 6, fileSlots: 1, buffers: [rawBuffer])
@@ -117,7 +174,6 @@ final class IORingTests: XCTestCase {
_ = try ring.blockingConsumeCompletion() //close
memset(rawBuffer.baseAddress!, 0, rawBuffer.count)
//Verify using a non-ring IO method that what we wrote matches our expectations
print("about to open")
let nonRingFD = try FileDescriptor.open(path, .readOnly)
let bytesRead = try nonRingFD.read(into: rawBuffer)
XCTAssert(bytesRead == 13)
@@ -127,6 +183,134 @@ final class IORingTests: XCTestCase {
efdBuf.deallocate()
rawBuffer.deallocate()
}
// Prior to the fix this is testing, prepare() escaped a pointer obtained
// inside `path.withPlatformString { ... }` into the SQE and dropped the
// owning FilePath before submit, so io_uring_enter handed the kernel a
// dangling pointer. Here we deliberately let the FilePath go out of scope
// between prepare and submit, then churn the heap to make UAFs observable.
func testPathBufferLifetimeAcrossPrepareSubmit() throws {
guard uringEnabled else { return }
let (parent, _) = try makeHelloWorldFile()
var ring = try IORing(queueDepth: 6)
func enqueueOpen() {
let path: FilePath = "/tmp/IORingTests/test.txt"
let ok = ring.prepare(request: .open(path, in: parent, mode: .readOnly))
XCTAssertTrue(ok)
}
enqueueOpen()
var churn: [UnsafeMutableRawBufferPointer] = []
for _ in 0..<256 {
let buf = UnsafeMutableRawBufferPointer.allocate(byteCount: 64, alignment: 1)
memset(buf.baseAddress!, 0x41, 64)
churn.append(buf)
}
for buf in churn { buf.deallocate() }
churn.removeAll()
try ring.submitPreparedRequests()
let completion = try ring.blockingConsumeCompletion()
XCTAssertGreaterThanOrEqual(
completion.result, 0,
"open should succeed; got \(completion.result)")
if completion.result >= 0 {
let fd = FileDescriptor(rawValue: Int32(completion.result))
try fd.close()
}
try cleanUpHelloWorldFile(parent)
}
func testPathBufferLifetimeAcrossLinkedRequests() throws {
guard uringEnabled else { return }
let (parent, _) = try makeHelloWorldFile()
let rawBuffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 13, alignment: 16)
var ring = try setupTestRing(depth: 6, fileSlots: 1, buffers: [rawBuffer])
func enqueueLinkedReadback() {
let path: FilePath = "/tmp/IORingTests/test.txt"
let ok = ring.prepare(linkedRequests:
.open(path, in: parent, into: ring.registeredFileSlots[0], mode: .readOnly),
.read(ring.registeredFileSlots[0], into: ring.registeredBuffers[0]),
.close(ring.registeredFileSlots[0]))
XCTAssertTrue(ok)
}
enqueueLinkedReadback()
var churn: [UnsafeMutableRawBufferPointer] = []
for _ in 0..<256 {
let buf = UnsafeMutableRawBufferPointer.allocate(byteCount: 64, alignment: 1)
memset(buf.baseAddress!, 0x41, 64)
churn.append(buf)
}
for buf in churn { buf.deallocate() }
try ring.submitPreparedRequests()
_ = try ring.blockingConsumeCompletion() // open
_ = try ring.blockingConsumeCompletion() // read
_ = try ring.blockingConsumeCompletion() // close
let result = String(cString: rawBuffer.assumingMemoryBound(to: CChar.self).baseAddress!)
XCTAssertEqual(result, "Hello, World!")
try cleanUpHelloWorldFile(parent)
rawBuffer.deallocate()
}
// Timeout test for `blockingConsumeCompletion(timeout:)`:
func testBlockingConsumeCompletionWithTimeoutOnIdleRing() throws {
guard uringEnabled else { return }
let ring = try IORing(queueDepth: 4, flags: [])
guard ring.supportedFeatures.contains(.extendedArguments) else {
// Kernel < 5.11: timeouts in io_uring_enter aren't supported.
return
}
let clock = ContinuousClock()
let start = clock.now
var thrown: Errno? = nil
do throws(Errno) {
_ = try ring.blockingConsumeCompletion(timeout: .milliseconds(100))
XCTFail("expected timeout, got a completion on an idle ring")
} catch {
thrown = error
}
let elapsed = start.duration(to: clock.now)
XCTAssertEqual(thrown, .timeout)
XCTAssertGreaterThanOrEqual(elapsed, .milliseconds(50))
}
func testRegisterEventFDTwiceThrows() throws {
guard uringEnabled else { return }
var ring = try IORing(queueDepth: 4)
let efd = FileDescriptor(rawValue: eventfd(0, Int32(EFD_SEMAPHORE)))
defer { try? efd.close() }
try ring.registerEventFD(efd)
do throws(Errno) {
try ring.registerEventFD(efd) // second registration -> EBUSY
XCTFail("expected second registerEventFD to throw")
} catch {
XCTAssertEqual(error, .resourceBusy)
}
}
func testSubmitOnDisabledRingThrows() throws {
guard uringEnabled else { return }
var ring = try IORing(queueDepth: 4, flags: [.startDisabled])
do throws(Errno) {
_ = try ring.submit(linkedRequests: .nop())
XCTFail("expected submit on a disabled ring to throw")
} catch {
XCTAssertEqual(error, Errno(rawValue: EBADFD))
}
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+453
View File
@@ -0,0 +1,453 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 - 2026 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
import Testing
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WASILibc)
import CSystem
import WASILibc
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@Suite("Stat")
private struct StatTests {
@available(System 1.7.0, *)
@Test func basics() async throws {
try withTemporaryFilePath(basename: "Stat_basics") { tempDir in
let dirStatFromFilePath = try tempDir.stat()
#expect(dirStatFromFilePath.type == .directory)
let dirFD = try FileDescriptor.open(tempDir, .readOnly)
defer {
try? dirFD.close()
}
let dirStatFromFD = try dirFD.stat()
#expect(dirStatFromFD.type == .directory)
let dirStatFromCString = try tempDir.withPlatformString { try Stat($0) }
#expect(dirStatFromCString.type == .directory)
#expect(dirStatFromFilePath == dirStatFromFD)
#expect(dirStatFromFD == dirStatFromCString)
let tempFile = tempDir.appending("test.txt")
let fileFD = try FileDescriptor.open(tempFile, .readWrite, options: .create, permissions: [.ownerReadWrite, .groupRead, .otherRead])
defer {
try? fileFD.close()
}
try fileFD.writeAll("Hello, world!".utf8)
let fileStatFromFD = try fileFD.stat()
#expect(fileStatFromFD.type == .regular)
#expect(fileStatFromFD.permissions == [.ownerReadWrite, .groupRead, .otherRead])
#expect(fileStatFromFD.size == "Hello, world!".utf8.count)
let fileStatFromFilePath = try tempFile.stat()
#expect(fileStatFromFilePath.type == .regular)
let fileStatFromCString = try tempFile.withPlatformString { try Stat($0) }
#expect(fileStatFromCString.type == .regular)
#expect(fileStatFromFD == fileStatFromFilePath)
#expect(fileStatFromFilePath == fileStatFromCString)
}
}
@available(System 1.7.0, *)
@Test func followSymlinkInits() async throws {
try withTemporaryFilePath(basename: "Stat_followSymlinkInits") { tempDir in
let targetFilePath = tempDir.appending("target.txt")
let symlinkPath = tempDir.appending("symlink")
let targetFD = try FileDescriptor.open(targetFilePath, .readWrite, options: .create, permissions: .ownerReadWrite)
defer {
try? targetFD.close()
}
try targetFD.writeAll(Array(repeating: UInt8(ascii: "A"), count: 1025))
try targetFilePath.withPlatformString { targetPtr in
try symlinkPath.withPlatformString { symlinkPtr in
try #require(symlink(targetPtr, symlinkPtr) == 0, "\(Errno.current)")
}
}
// Can't open an fd to a symlink on WASI (no O_PATH)
// On non-Darwin, we need O_PATH | O_NOFOLLOW to open the symlink
// directly, but O_PATH requires _GNU_SOURCE be defined (TODO).
#if SYSTEM_PACKAGE_DARWIN
let symlinkFD = try FileDescriptor.open(symlinkPath, .readOnly, options: .symlink)
defer {
try? symlinkFD.close()
}
#endif
let targetStat = try targetFilePath.stat()
let originalTargetAccessTime = targetStat.st_atim
let symlinkStat = try symlinkPath.stat(followTargetSymlink: false)
let originalSymlinkAccessTime = symlinkStat.st_atim
#expect(targetStat != symlinkStat)
#expect(targetStat.type == .regular)
#expect(symlinkStat.type == .symbolicLink)
#expect(symlinkStat.size < targetStat.size)
#expect(symlinkStat.sizeAllocated <= targetStat.sizeAllocated)
// Set each .st_atim back to its original value for comparison
// FileDescriptor Extensions
var stat = try targetFD.stat()
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
#if SYSTEM_PACKAGE_DARWIN
stat = try symlinkFD.stat()
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
#endif
// Initializing Stat with FileDescriptor
stat = try Stat(targetFD)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
#if SYSTEM_PACKAGE_DARWIN
stat = try Stat(symlinkFD)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
#endif
// FilePath Extensions
stat = try symlinkPath.stat(followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try symlinkPath.stat(followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
// Initializing Stat with UnsafePointer<CChar>
try symlinkPath.withPlatformString { pathPtr in
stat = try Stat(pathPtr, followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try Stat(pathPtr, followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
}
// Initializing Stat with FilePath
stat = try Stat(symlinkPath, followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try Stat(symlinkPath, followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
// Initializing Stat with String
stat = try Stat(symlinkPath.string, followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try Stat(symlinkPath.string, followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
}
}
@available(System 1.7.0, *)
@Test func permissions() async throws {
try withTemporaryFilePath(basename: "Stat_permissions") { tempDir in
let testFile = tempDir.appending("test.txt")
let fd = try FileDescriptor.open(testFile, .writeOnly, options: .create, permissions: [.ownerReadWrite, .groupRead, .otherRead])
try fd.close()
let stat = try testFile.stat()
#expect(stat.type == .regular)
#expect(stat.permissions == [.ownerReadWrite, .groupRead, .otherRead])
var newMode = stat.mode
newMode.permissions.insert(.ownerExecute)
try testFile.withPlatformString { pathPtr in
try #require(chmod(pathPtr, newMode.permissions.rawValue) == 0, "\(Errno.current)")
}
let updatedStat = try testFile.stat()
#expect(updatedStat.permissions == newMode.permissions)
newMode.permissions.remove(.ownerWriteExecute)
try testFile.withPlatformString { pathPtr in
try #require(chmod(pathPtr, newMode.permissions.rawValue) == 0, "\(Errno.current)")
}
let readOnlyStat = try testFile.stat()
#expect(readOnlyStat.permissions == newMode.permissions)
}
}
@available(System 1.7.0, *)
@Test func times() async throws {
// This test pauses with `usleep` between some measurements to ensure that
// the timestamp used by the filesystem will advance. On Linux and Android
// the granularity of that clock may be as much as 10ms. We use 50ms
// in order to have a comfortable margin.
let timestampSleep: useconds_t = 50_000
var start = timespec()
try #require(clock_gettime(CLOCK_REALTIME, &start) == 0, "\(Errno.current)")
start.tv_sec -= 1 // A little wiggle room
try withTemporaryFilePath(basename: "Stat_times") { tempDir in
var dirStat = try tempDir.stat()
let dirAccessTime0 = dirStat.st_atim
let dirModificationTime0 = dirStat.st_mtim
let dirChangeTime0 = dirStat.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let dirCreationTime0 = dirStat.st_birthtim
#endif
var startUpperBound = start
startUpperBound.tv_sec += 5
#expect(dirAccessTime0 >= start)
#expect(dirAccessTime0 < startUpperBound)
#expect(dirModificationTime0 >= start)
#expect(dirModificationTime0 < startUpperBound)
#expect(dirChangeTime0 >= start)
#expect(dirChangeTime0 < startUpperBound)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirCreationTime0 >= start)
#expect(dirCreationTime0 < startUpperBound)
#endif
usleep(timestampSleep)
let file1 = tempDir.appending("test1.txt")
let fd1 = try FileDescriptor.open(file1, .writeOnly, options: .create, permissions: .ownerReadWrite)
defer {
try? fd1.close()
}
dirStat = try tempDir.stat()
let dirAccessTime1 = dirStat.st_atim
let dirModificationTime1 = dirStat.st_mtim
let dirChangeTime1 = dirStat.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let dirCreationTime1 = dirStat.st_birthtim
#endif
// Creating a file updates directory modification and change time.
// Access time may not be updated depending on mount options like NOATIME.
#expect(dirModificationTime1 > dirModificationTime0)
#expect(dirChangeTime1 > dirChangeTime0)
#expect(dirAccessTime1 >= dirAccessTime0)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirCreationTime1 == dirCreationTime0)
#endif
usleep(timestampSleep)
// Changing permissions only updates directory change time
try tempDir.withPlatformString { pathPtr in
var newMode = dirStat.mode
// tempDir only starts with .ownerReadWriteExecute
newMode.permissions.insert(.groupReadWriteExecute)
try #require(chmod(pathPtr, newMode.rawValue) == 0, "\(Errno.current)")
}
dirStat = try tempDir.stat()
let dirChangeTime2 = dirStat.st_ctim
#expect(dirChangeTime2 > dirChangeTime1)
#expect(dirStat.st_atim == dirAccessTime1)
#expect(dirStat.st_mtim == dirModificationTime1)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirStat.st_birthtim == dirCreationTime1)
#endif
var stat1 = try file1.stat()
let file1AccessTime1 = stat1.st_atim
let file1ModificationTime1 = stat1.st_mtim
let file1ChangeTime1 = stat1.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let file1CreationTime1 = stat1.st_birthtim
#endif
usleep(timestampSleep)
try fd1.writeAll("Hello, world!".utf8)
stat1 = try file1.stat()
let file1AccessTime2 = stat1.st_atim
let file1ModificationTime2 = stat1.st_mtim
let file1ChangeTime2 = stat1.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let file1CreationTime2 = stat1.st_birthtim
#endif
#expect(file1AccessTime2 >= file1AccessTime1)
#expect(file1ModificationTime2 > file1ModificationTime1)
#expect(file1ChangeTime2 > file1ChangeTime1)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(file1CreationTime2 == file1CreationTime1)
#endif
// Changing file metadata or content does not update directory times
dirStat = try tempDir.stat()
#expect(dirStat.st_ctim == dirChangeTime2)
#expect(dirStat.st_atim == dirAccessTime1)
#expect(dirStat.st_mtim == dirModificationTime1)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirStat.st_birthtim == dirCreationTime1)
#endif
usleep(timestampSleep)
let file2 = tempDir.appending("test2.txt")
let fd2 = try FileDescriptor.open(file2, .writeOnly, options: .create, permissions: .ownerReadWrite)
defer {
try? fd2.close()
}
let stat2 = try file2.stat()
#expect(stat2.st_atim >= file1AccessTime2)
#expect(stat2.st_mtim >= file1ModificationTime2)
#expect(stat2.st_ctim >= file1ChangeTime2)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(stat2.st_birthtim > file1CreationTime2)
#endif
}
}
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
@available(System 1.7.0, *)
@Test func flags() async throws {
try withTemporaryFilePath(basename: "Stat_flags") { tempDir in
let filePath = tempDir.appending("test.txt")
let fd = try FileDescriptor.open(filePath, .writeOnly, options: .create, permissions: .ownerReadWrite)
defer {
try? fd.close()
}
var stat = try fd.stat()
var flags = stat.flags
#if SYSTEM_PACKAGE_DARWIN
let userSettableFlags: FileFlags = [
.noDump, .userImmutable, .userAppend,
.opaque, .tracked, .hidden,
/* .dataVault (throws EPERM when testing) */
]
#elseif os(FreeBSD)
let userSettableFlags: FileFlags = [
.noDump, .hidden, .offline,
.readOnly, .sparse, .system
// The following flags throw EPERM on ZFS.
// .userImmutable, .userAppend, .opaque,
// .userNoUnlink, .reparse,
]
#else // os(OpenBSD)
let userSettableFlags: FileFlags = [
.noDump, .userImmutable, .userAppend
]
#endif
flags.insert(userSettableFlags)
// On FreeBSD, the second argument of `fchflags` requires `UInt` instead of`UInt32`.
try #require(fchflags(fd.rawValue, .init(flags.rawValue)) == 0, "\(Errno.current)")
stat = try fd.stat()
#expect(stat.flags == flags)
flags.remove(userSettableFlags)
// On FreeBSD, the second argument of `fchflags` requires `UInt` instead of`UInt32`.
try #require(fchflags(fd.rawValue, .init(flags.rawValue)) == 0, "\(Errno.current)")
stat = try fd.stat()
#expect(stat.flags == flags)
}
}
#endif
@available(System 1.7.0, *)
@Test func equalityAndHashing() async throws {
try withTemporaryFilePath(basename: "Stat_equality") { tempDir in
let file = tempDir.appending("test.txt")
let fd = try FileDescriptor.open(
file, .writeOnly, options: .create, permissions: .ownerReadWrite)
defer { try? fd.close() }
// Two stats of the same, unchanged file compare equal and hash equal,
// so they coalesce in a Set.
let stat1 = try file.stat()
var stat2 = try file.stat()
stat2.st_atim = stat1.st_atim // stat() can bump access time
#expect(stat1 == stat2)
#expect(stat1.hashValue == stat2.hashValue)
#expect(Set([stat1, stat2]).count == 1)
// Reserved/"spare" and padding bytes must not affect equality.
// Poke a reserved field and confirm equality/hashing are stable.
#if SYSTEM_PACKAGE_DARWIN
var stat3 = stat1
stat3.rawValue.st_lspare = stat1.rawValue.st_lspare &+ 1
#expect(stat1 == stat3)
#expect(stat1.hashValue == stat3.hashValue)
#endif
// A stat of a different file (the containing directory) is not equal.
let dirStat = try tempDir.stat()
#expect(stat1 != dirStat)
}
}
}
// Comparison operators for timespec until UTCClock.Instant properties are available
private func >= (lhs: timespec, rhs: timespec) -> Bool {
(lhs.tv_sec, lhs.tv_nsec) >= (rhs.tv_sec, rhs.tv_nsec)
}
private func < (lhs: timespec, rhs: timespec) -> Bool {
(lhs.tv_sec, lhs.tv_nsec) < (rhs.tv_sec, rhs.tv_nsec)
}
private func > (lhs: timespec, rhs: timespec) -> Bool {
(lhs.tv_sec, lhs.tv_nsec) > (rhs.tv_sec, rhs.tv_nsec)
}
private func == (lhs: timespec, rhs: timespec) -> Bool {
lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec
}
#endif
@@ -37,7 +37,7 @@ extension Trace.Entry {
#endif // ENABLE_MOCKING
// To aid debugging, force failures to fatal error
internal var forceFatalFailures = false
internal let forceFatalFailures = false
internal protocol TestCase {
// TODO: want a source location stack, more fidelity, kinds of stack entries, etc
+1 -1
View File
@@ -34,7 +34,7 @@ class UtilTests: XCTestCase {
func testCStringArray() {
func check(
_ array: [String],
file: StaticString = #file,
file: StaticString = #filePath,
line: UInt = #line
) {
array._withCStringArray { carray in