Compare commits

...
Author SHA1 Message Date
Franz Busch 95ed6aa2a4 Address review comments 2026-10-06 10:21:52 +02:00
Franz Busch cbf57d4575 [IO_URING] Keep the completion of failed IORing operations
When an operation failed, the blocking consume methods dropped its completion and only reported the `Errno`. The caller could not tell which request failed, since the `context` was lost. This breaks any user that matches completions to requests.

This PR makes `blockingConsumeCompletions` pass the completion of a failed operation together with its error. Errors of the ring itself, such as `.timeout`, are still passed without a completion. Additionally, `blockingConsumeCompletion(timeout:)` now returns the completion of a failed operation instead of throwing. It only throws errors of the ring itself.

I also added `Completion.error`, which is `nil` on success and the decoded `Errno` otherwise to make it easy to get to the error of a completion.

Fixes #364
Fixes #395
2026-10-05 20:59:39 +02:00
Jonathan Flat c3b7f2a48e Merge pull request #393 from jrflat/ioring-consume-completions-undone
Fix missing `done` in `IORing.blockingConsumeCompletions`
2026-10-02 10:36:45 -06:00
Jonathan Flat 74a7b6f618 Fix missing done in IORing.blockingConsumeCompletions 2026-09-30 15:59:05 -06:00
Guillaume Lessard e6796eb47d Merge branch 'release/1.8.x' into main 2026-09-25 15:03:14 -07:00
Guillaume Lessard b0d4217c8c [ci] update github actions (#389)
* [ci] update version of workflows dependencies
2026-09-25 14:58:42 -07:00
Paris 85e911cd30 Merge pull request #388 from apple/ospobot/code-of-conduct
Housekeeping: replace repo-level CODE_OF_CONDUCT
2026-09-25 12:22:16 -07:00
apple-ospo[bot] 65f43f5d57 Replace repo-level CODE_OF_CONDUCT file with the inherited org-wide Code of Conduct in .github repo. 2026-09-25 17:42:48 +00:00
Franz Busch b62bce1bc4 Merge pull request #273 from apple/fb-io-uring-poll-add
[IO_URING] Add support for `pollAdd` operation
2026-09-25 10:52:31 +02:00
Jonathan Flat 6843adad5a Add missing @inlinable 2026-09-24 19:38:24 -06:00
Jonathan Flat 4699556133 Add unavailable/renamed hints for C names 2026-09-24 19:37:41 -06:00
Jonathan Flat 1c80f27aef Remove PollEvents.allEvents and use internal Event enum for testing 2026-09-24 19:37:41 -06:00
Jonathan Flat 59b5659a1e Make internal isMultiShot default match public API 2026-09-24 19:37:38 -06:00
Jonathan Flat dc65a924d9 Doc comment updates 2026-09-24 19:36:21 -06:00
Franz Busch 3b8124e350 Smaller touch ups 2026-09-22 10:18:47 +02:00
Franz Busch 241fedcbbd Address review feedback 2026-09-22 10:07:05 +02:00
Guillaume Lessard 1b452c2996 Merge pull request #375 from apple/dev/enable-member-import-visibility 2026-08-17 11:27:16 -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 6dc13544bb Merge branch 'release/1.8.x' into ‘main’ 2026-08-11 13:49:06 -07:00
Guillaume Lessard d0ef8d091d [readme] update for 1.8.x branch 2026-08-11 13:46:15 -07:00
Guillaume Lessard 79b7490ae9 Hoist “import CSystem” above the platform-specific imports 2026-08-07 15:43:00 -07:00
Guillaume Lessard c5c1a835d6 Explicitly import CSystem for wasi 2026-08-07 15:42:10 -07:00
Guillaume Lessard 27bc5e7e8d Enable “MemberImportVisibility” 2026-08-07 14:40:11 -07:00
Guillaume Lessard c49268ed91 Merge branch 'release/1.8.x' into dev/forward-merge-1.8.x 2026-08-06 09:52:52 -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 6e3259aec3 Better explain a skip condition 2026-07-28 16:51:19 -07:00
Guillaume Lessard d4373e36f6 Clarify .pollNval and add test reading from an invalid descriptor 2026-07-28 16:46:33 -07:00
Guillaume Lessard a6d4c153b7 Add test to demonstrate a POLLERR result 2026-07-28 16:46:33 -07:00
Guillaume Lessard 4df226b098 Fix copyright notices 2026-07-28 16:46:33 -07:00
Guillaume Lessard a2ca84e281 Round out PollEvents 2026-07-28 16:46:33 -07:00
Guillaume Lessard 980a71f20c Add test to show that PollEvents has too few values 2026-07-28 16:46:33 -07:00
Guillaume Lessard bd49600d62 Prevent tests from hanging in the wrong conditions 2026-07-28 16:46:32 -07:00
Guillaume Lessard 0ecb080d5c Test ready events in a better way 2026-07-28 16:46:32 -07:00
Guillaume Lessard bed8e28860 Clean up permissively 2026-07-28 16:46:32 -07:00
Guillaume Lessard 2e81d94142 Add a test similar to the example in the pollAdd doc-comment 2026-07-28 16:46:32 -07:00
Guillaume Lessard 75c85d47e7 Account for big-endian architectures for poll event encoding 2026-07-28 16:46:32 -07:00
Guillaume Lessard 5b7e24a6b1 Define a constant in Swift rather than in C 2026-07-28 16:46:31 -07:00
Guillaume Lessard 6baba54adb Reflow or improve some doc-comments 2026-07-28 16:46:31 -07:00
Guillaume Lessard 27b4a4a03a Use XCTSkipIf to guard IORing tests 2026-07-28 16:46:31 -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 dd5313284d [cmake] add new file to configuration 2026-07-27 16:26:22 -07:00
Franz Busch 2a069e401b Update Sources/System/IORing/IORequest.swift 2026-07-27 16:26:21 -07:00
Franz BuschandMartin e775d1bf59 Apply suggestion from @MarSe32m
Co-authored-by: Martin <sebastian.toivonen@gmail.com>
2026-07-27 16:26:21 -07:00
Guillaume Lessard e4b352c650 [test] fix spelling error 2026-07-27 16:26:21 -07:00
Franz Busch ab11b74b39 [IO_URING] Add support for pollAdd operation
To observe events on file descriptors IO_URING supports the `pollAdd` operation. This is useful when you want to observe a file descriptor becoming ready to read or write

This PR adds a new `IORing.Request.PollEvents` option set to model the poll masks. Furthermore, it adds a new `static func pollAdd` to the `IORing.Request`.

We can now use IO_URING to poll for events on file descriptors.
2026-07-27 16:26:21 -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
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 c6cc06d24d Merge pull request #306 from kkebo/enable-freebsd-ci
[CI] Enable FreeBSD testing
2026-06-05 15:06:13 -07: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
42 changed files with 1589 additions and 399 deletions

No files matched your search

+44 -3
View File
@@ -10,7 +10,7 @@ on:
jobs:
tests:
name: Test
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.10
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.15
with:
swift_flags: "-Xbuild-tools-swiftc -DSYSTEM_CI"
enable_linux_checks: true
@@ -24,6 +24,8 @@ jobs:
{"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
@@ -42,6 +44,8 @@ jobs:
{"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
@@ -51,14 +55,17 @@ jobs:
{"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@0.0.10
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.15
with:
enable_linux_checks: false
enable_macos_checks: true
@@ -69,9 +76,43 @@ jobs:
# 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@0.0.10
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)
-38
View File
@@ -1,38 +0,0 @@
# Code of Conduct
To be a truly great community, Swift.org needs to welcome developers from all walks of life, with different backgrounds, and with a wide range of experience. A diverse and friendly community will have more great ideas, more unique perspectives, and produce more great code. We will work diligently to make the Swift community welcoming to everyone.
To give clarity of what is expected of our members, this code of conduct is based on [contributor-covenant.org](http://contributor-covenant.org). This document is used across many open source communities, and we think it articulates our values well.
### Contributor Code of Conduct v1.4
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to make participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language (e.g., prefer non-gendered words like “folks” to “guys”, non-ableist words like “soundness check” to “sanity check”, etc.)
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others’ private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
This Code of Conduct applies within all project spaces managed by Swift.org, including (but not limited to) source code repositories, bug trackers, web sites, documentation, and online forums. It also applies when an individual is representing the project or its community in public spaces. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting a member of the [Swift Core Team](https://swift.org/community/#community-structure) or by flagging the behavior for moderation (e.g., in the Forums), whether you are the target of that behavior or not. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. Maintainers are obligated to maintain confidentiality with regard to the reporter of an incident. The site of the disputed behavior is usually not an acceptable place to discuss moderation decisions, and moderators may move or remove any such discussion.
Project maintainers are held to a higher standard, and project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project’s leadership.
If you disagree with a moderation action, you can appeal to the Core Team (or individual Core Team members) privately.
This policy is adapted from the Contributor Code of Conduct [version 1.4](https://www.contributor-covenant.org/version/1/4/code-of-conduct/).
+4 -7
View File
@@ -59,13 +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("99", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("199", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
]
let swiftSettingsAvailability = availability.map(\.swiftSetting)
@@ -85,6 +81,7 @@ let swiftSettings = swiftSettingsAvailability + swiftSettingsCI + [
.define("SYSTEM_PACKAGE"),
.define("ENABLE_MOCKING", .when(configuration: .debug)),
.enableExperimentalFeature("Lifetimes"),
.enableUpcomingFeature("MemberImportVisibility"),
]
let cSettings: [CSetting] = [
@@ -148,5 +145,5 @@ let package = Package(
dependencies: ["SystemPackage"],
swiftSettings: [.enableUpcomingFeature("MemberImportVisibility")]),
],
swiftLanguageModes: [.v5]
swiftLanguageModes: [.v6]
)
+10 -7
View File
@@ -79,7 +79,7 @@ These initializers use a typed `throws(Errno)` and require Swift 6.0 or later.
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.
All API are marked `@_alwaysEmitIntoClient` for performance and back-dating of availability, except `Stat`'s `==` and `hash(into:)`, which are ordinary `public` API.
### FileType
@@ -693,24 +693,27 @@ public struct Stat: RawRepresentable, Sendable {
/// File generation number
///
/// The file generation number is used to distinguish between different files
/// that have used the same inode over time.
/// 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.
public var generationNumber: Int { get set }
/// - 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 raw bytes of two `Stat` structs for equality.
/// 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 raw bytes of this `Stat` struct.
/// Hashes the meaningful file-metadata fields of a `Stat` struct.
public func hash(into hasher: inout Hasher)
}
```
+18 -10
View File
@@ -1,31 +1,31 @@
# Add support for `dup3` and `pipe2` POSIX API to `FileDescriptor`
* Proposal: SYS-0007
- Author(s): Jake Petroules <jake.petroules@apple.com>, Guillaume Lessard <guillaume.lessard@apple.com>
* 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
#### Revision history
* **v1** Initial version
- **v2** Add Windows version of `pipe(options:)`
* **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 and Android.
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 this 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`.
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 defence in depth with respect to opened file descriptors.
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
@@ -38,7 +38,7 @@ import System
let fd0 = try FileDescriptor.open("/tmp/test.txt", .readOnly)
let fd1 = FileDescriptor(rawValue: 731)
let fd2 = fd0.duplicate(as: fd1, options: [.closeOnFork, .closeOnExec])
let fd2 = try fd0.duplicate(as: fd1, options: [.closeOnFork, .closeOnExec])
```
## Detailed design
@@ -50,6 +50,11 @@ 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.
///
@@ -70,9 +75,14 @@ struct FileDescriptor {
/// 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
@@ -167,8 +177,6 @@ struct FileDescriptor {
}
```
These API additions are unavailable on Darwin, as the underlying `dup3` and `pipe2` APIs do not exist.
`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.
+9 -8
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.7.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.7.1"),
.package(url: "https://github.com/apple/swift-system", from: "1.8.0"),
// other dependencies
],
targets: [
@@ -87,8 +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.7.x | >= Swift 6.1 | >= Xcode 16.3 |
| 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.
@@ -113,16 +113,17 @@ We maintain separate branches for each active minor version of the package:
| 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 (unreleased) | main |
| 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.6.0` → `release/1.7.0` → `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
Like all Swift.org projects, we would like the Swift System project to foster a diverse and friendly community. We expect contributors to adhere to the [Swift.org Code of Conduct](https://swift.org/code-of-conduct/). A copy of this document is [available in this repository][coc].
[coc]: CODE_OF_CONDUCT.md
[coc]: https://github.com/apple/.github/blob/main/CODE_OF_CONDUCT.md
+3
View File
@@ -13,10 +13,13 @@ target_include_directories(CSystem PUBLIC
$<INSTALL_INTERFACE:include/CSystem>)
install(FILES
include/CSystemDarwin.h
include/CSystemLinux.h
include/CSystemShared.h
include/CSystemWASI.h
include/CSystemWindows.h
include/CSystemFreeBSD.h
include/io_uring.h
include/module.modulemap
DESTINATION include/CSystem)
set_property(GLOBAL APPEND PROPERTY SWIFT_SYSTEM_EXPORTS CSystem)
+20
View File
@@ -0,0 +1,20 @@
/*
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 defined(__APPLE__)
#include <fcntl.h>
#ifdef O_CLOFORK
#define COMPATIBILITY_O_CLOFORK O_CLOFORK
#else
#define COMPATIBILITY_O_CLOFORK 0
#endif
#endif // defined(__APPLE__)
+3 -4
View File
@@ -12,10 +12,9 @@
#include <fcntl.h>
#ifdef O_CLOFORK
#define FREEBSD_O_CLOFORK O_CLOFORK
#define COMPATIBILITY_O_CLOFORK O_CLOFORK
#else
#define FREEBSD_O_CLOFORK 0
#endif
#define COMPATIBILITY_O_CLOFORK 0
#endif
#endif // defined(__FreeBSD__)
+6 -5
View File
@@ -81,7 +81,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 +89,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 +107,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)
@@ -235,7 +236,7 @@ static inline int io_uring_enter2(int fd, unsigned int to_submit, unsigned int m
unsigned int flags, void *args, size_t sz)
{
return syscall(__NR_io_uring_enter, fd, to_submit, min_complete,
flags, args, _NSIG / 8);
flags, args, sz);
}
static inline int io_uring_enter(int fd, unsigned int to_submit, unsigned int min_complete,
+1
View File
@@ -1,5 +1,6 @@
module CSystem {
header "CSystemShared.h"
header "CSystemDarwin.h"
header "CSystemLinux.h"
header "CSystemWASI.h"
header "CSystemWindows.h"
+29 -11
View File
@@ -7,8 +7,10 @@
See https://swift.org/LICENSE.txt for license information
*/
#if defined(__FreeBSD__) || defined(__OpenBSD__)
#if defined(__FreeBSD__)
#define __BSD_VISIBLE
#endif
#if defined(__FreeBSD__) || defined(__OpenBSD__)
#include <unistd.h>
#endif
@@ -31,24 +33,40 @@
#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) {
#ifdef HAVE_PIPE2_DUP3
#if defined(__APPLE__) && defined(HAVE_PIPE2_DUP3)
if (__builtin_available(macOS 27, iOS 27, tvOS 27, watchOS 27, visionOS 27, *))
return pipe2(fildes, flag);
#else
errno = ENOSYS;
return -1;
#endif
__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) {
#ifdef HAVE_PIPE2_DUP3
#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);
#else
errno = ENOSYS;
return -1;
#endif
__builtin_trap();
#elif defined(HAVE_PIPE2_DUP3)
return dup3(fildes, fildes2, flag);
#else
errno = ENOSYS;
return -1;
#endif
}
+43 -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,25 @@ 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/PollEvents.swift
IORing/RawIORequest.swift)
endif()
target_sources(SystemPackage PRIVATE
Internals/Backcompat.swift
Internals/CInterop.swift
+1 -1
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
+7 -12
View File
@@ -301,7 +301,6 @@ 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
@@ -319,16 +318,17 @@ 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, unavailable)
@available(iOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
@available(visionOS, unavailable)
@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
@@ -399,11 +399,7 @@ extension FileDescriptor {
/// Options that specify behavior for a duplicated file descriptor.
@frozen
@available(Windows, unavailable)
@available(macOS, unavailable)
@available(iOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
@available(visionOS, 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
@@ -528,7 +524,6 @@ extension FileDescriptor {
@available(*, unavailable, renamed: "nextData")
public static var SEEK_DATA: SeekOrigin { nextData }
#endif
}
}
+30 -35
View File
@@ -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.
@@ -415,7 +423,7 @@ extension FileDescriptor {
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The new file descriptor.
///
/// If the `target` descriptor the same as `self`, then EINVAL is thrown.
/// 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.
///
@@ -436,20 +444,19 @@ extension FileDescriptor {
/// close-on-fork flags.
///
/// The corresponding C function is `dup3`.
@discardableResult
@_alwaysEmitIntoClient
@available(Windows, unavailable)
@available(macOS, unavailable)
@available(iOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
@available(visionOS, 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 {
try _duplicate(as: target, options: options.rawValue, retryOnInterrupt: retryOnInterrupt).get()
let result = _duplicate(
as: target, options: options.rawValue, retryOnInterrupt: retryOnInterrupt
)
return try result.get()
}
@available(System 0.0.2, *)
@@ -468,11 +475,7 @@ extension FileDescriptor {
}
@available(Windows, unavailable)
@available(macOS, unavailable)
@available(iOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
@available(visionOS, unavailable)
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
@usableFromInline
internal func _duplicate(
as target: FileDescriptor,
@@ -502,7 +505,7 @@ extension FileDescriptor {
fatalError("Not implemented")
}
}
#endif
#endif // !os(WASI)
#if !os(WASI)
@available(System 1.1.0, *)
@@ -524,9 +527,9 @@ extension FileDescriptor {
/// interprocess communication.
///
/// NOTE: This overload called with an empty option set is not necessarily
/// equivalent to calling the overload with no options. On Windows, this
/// overload with empty options disables the `closeOnExec` behaviour,
/// which is enabled by the overload without options.
/// 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.
@@ -535,11 +538,7 @@ extension FileDescriptor {
///
/// The corresponding C function is `pipe2`.
@_alwaysEmitIntoClient
@available(macOS, unavailable)
@available(iOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
@available(visionOS, unavailable)
@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) {
@@ -560,11 +559,7 @@ extension FileDescriptor {
}
}
@available(macOS, unavailable)
@available(iOS, unavailable)
@available(tvOS, unavailable)
@available(watchOS, unavailable)
@available(visionOS, unavailable)
@available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *)
@usableFromInline
internal static func _pipe(
options: Int32,
@@ -585,7 +580,7 @@ extension FileDescriptor {
fatalError("Not implemented")
}
}
#endif
#endif // !os(WASI)
@available(System 1.2.0, *)
extension FileDescriptor {
@@ -674,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,18 +9,16 @@
#if !os(Windows)
import CSystem
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import CSystem
import Glibc
#elseif canImport(Musl)
import CSystem
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Android)
import CSystem
import Android
#else
#error("Unsupported Platform")
+2 -2
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// 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
@@ -45,7 +45,7 @@
///
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct FileFlags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
+2 -2
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// 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
@@ -14,7 +14,7 @@
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct FileMode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C mode.
+2 -2
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// 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
@@ -34,7 +34,7 @@
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct FileType: RawRepresentable, Sendable, Hashable, Codable {
/// The raw file-type bits from the C mode.
+5 -5
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// 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
@@ -12,7 +12,7 @@
#if !os(Windows)
/// A Swift wrapper of the C `uid_t` type.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct UserID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `uid_t`.
@@ -30,7 +30,7 @@ public struct UserID: RawRepresentable, Sendable, Hashable, Codable {
/// A Swift wrapper of the C `gid_t` type.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct GroupID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `gid_t`.
@@ -48,7 +48,7 @@ public struct GroupID: RawRepresentable, Sendable, Hashable, Codable {
/// A Swift wrapper of the C `dev_t` type.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct DeviceID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `dev_t`.
@@ -66,7 +66,7 @@ public struct DeviceID: RawRepresentable, Sendable, Hashable, Codable {
/// A Swift wrapper of the C `ino_t` type.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct Inode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `ino_t`.
+74 -23
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// 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
@@ -35,7 +35,7 @@ import Android
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 99, *)
@available(System 1.7.0, *)
public struct Stat: RawRepresentable, Sendable {
/// The raw C `stat` struct.
@@ -521,42 +521,93 @@ public struct Stat: RawRepresentable, Sendable {
/// File generation number
///
/// The file generation number is used to distinguish between different files
/// that have used the same inode over time.
/// 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.
/// - 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: Int {
get { Int(rawValue.st_gen) }
set { rawValue.st_gen = numericCast(newValue)}
public var generationNumber: UInt64 {
get { UInt64(rawValue.st_gen) }
set { rawValue.st_gen = numericCast(newValue) }
}
#endif
}
// MARK: - Equatable and Hashable
@available(System 99, *)
@available(System 1.7.0, *)
extension Stat: Equatable {
@_alwaysEmitIntoClient
/// Compares the raw bytes of two `Stat` structs for equality.
/// 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 {
return withUnsafeBytes(of: lhs.rawValue) { lhsBytes in
withUnsafeBytes(of: rhs.rawValue) { rhsBytes in
lhsBytes.elementsEqual(rhsBytes)
}
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 99, *)
@available(System 1.7.0, *)
extension Stat: Hashable {
@_alwaysEmitIntoClient
/// Hashes the raw bytes of this `Stat` struct.
/// 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) {
withUnsafeBytes(of: rawValue) { bytes in
hasher.combine(bytes: bytes)
}
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
}
}
@@ -564,7 +615,7 @@ extension Stat: Hashable {
// MARK: - FileDescriptor Extensions
@available(System 99, *)
@available(System 1.7.0, *)
extension FileDescriptor {
/// Creates a `Stat` struct for the file referenced by this `FileDescriptor`.
@@ -580,7 +631,7 @@ extension FileDescriptor {
// MARK: - FilePath Extensions
@available(System 99, *)
@available(System 1.7.0, *)
extension FilePath {
/// Creates a `Stat` struct for the file referenced by this `FilePath`.
+24
View File
@@ -1,3 +1,12 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2023 - 2025 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)
@@ -45,12 +54,27 @@ public extension IORing.Completion {
}
}
/// The result of the completed operation.
///
/// A non-negative value is the operation's success result: a byte count
/// for a read or a write, an event mask for a poll, and so on.
///
/// A negative value is an `errno` code multiplied by -1. Recover the error
/// by negating it again: `Errno(rawValue: -completion.result)`, or use
/// ``error``.
@inlinable var result: Int32 {
get {
rawValue.res
}
}
/// The error of the completed operation, or `nil` if the operation succeeded.
@inlinable var error: Errno? {
get {
rawValue.res < 0 ? Errno(rawValue: -rawValue.res) : nil
}
}
@inlinable var flags: IORing.Completion.Flags {
get {
Flags(rawValue: rawValue.flags & 0x0000FFFF)
+174 -17
View File
@@ -1,3 +1,12 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2023 - 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)
@@ -23,6 +32,12 @@ internal enum IORequestCore {
intoSlot: IORing.RegisteredFile,
context: UInt64 = 0
)
case pollAdd(
file: FileDescriptor,
events: IORing.Request.PollEvents,
isMultiShot: Bool = false,
context: UInt64 = 0
)
case read(
file: FileDescriptor,
buffer: IORing.RegisteredBuffer,
@@ -187,6 +202,118 @@ extension IORing.Request {
.init(core: .nop)
}
// Poll
/// Multishot poll: the poll handler continues to report CQEs on behalf
/// of the same SQE, each flagged with
/// ``IORing/Completion/Flags/moreCompletions``.
///
/// Corresponds to `IORING_POLL_ADD_MULTI`. Note that since
/// `sqe->poll_events` is the event space, the command flags for
/// `POLL_ADD` are stored in `sqe->len`.
@_alwaysEmitIntoClient
internal static var SWIFT_IORING_POLL_ADD_MULTI: UInt32 { 1 << 0 }
/// Adds a poll operation to monitor a file descriptor for specific I/O
/// events.
///
/// This method creates an `io_uring` poll operation that monitors the
/// specified file descriptor for I/O readiness events. The operation
/// completes when any of the requested events occur on the file
/// descriptor, such as data becoming available for reading or the
/// descriptor becoming ready for writing.
///
/// Poll operations are useful for implementing efficient I/O
/// multiplexing, allowing you to monitor multiple file descriptors
/// concurrently within a single `io_uring` instance. When used with
/// multishot mode, a single poll operation can deliver multiple
/// completion events without needing to be resubmitted.
///
/// Poll requests on a ring created with
/// ``IORing/SetupFlags/pollCompletions`` fail with
/// ``Errno/invalidArgument``.
///
/// ## Multishot Behavior
///
/// When `isMultiShot` is `true`, the poll operation automatically rearms
/// after each completion event, continuing to monitor the file descriptor
/// for subsequent events. This reduces submission overhead for long-lived
/// monitoring operations. The poll stays armed until it's canceled or the
/// kernel ends it; its last completion is the one without
/// ``IORing/Completion/Flags/moreCompletions``. Neither a hangup nor
/// closing the descriptor ends the poll, and the request keeps the file
/// open until the poll ends.
///
/// When `isMultiShot` is `false`, the poll operation completes once after
/// the first matching event occurs, requiring resubmission to continue
/// monitoring.
///
/// ## Example Usage
///
/// ```swift
/// // Monitor a socket for incoming connections
/// var ring = try IORing(queueDepth: 32)
/// let pollRequest = IORing.Request.pollAdd(
/// listenSocket,
/// events: .readable,
/// isMultiShot: true,
/// context: 1
/// )
/// guard try ring.submit(linkedRequests: pollRequest) else {
/// // The submission queue was full; retry or drain completions first.
/// return
/// }
///
/// // Process completions. A multishot poll stays armed while its
/// // completions contain `.moreCompletions`.
/// var armed = true
/// while armed {
/// let completion = try ring.blockingConsumeCompletion()
/// guard completion.context == 1 else {
/// // Handle completions for other requests.
/// continue
/// }
/// armed = completion.flags.contains(.moreCompletions)
/// if let error = completion.error {
/// // The poll ended with an error, such as `.canceled`.
/// throw error
/// }
/// // Handle incoming connection
/// }
/// ```
///
/// If the poll ends with an error, such as ``Errno/canceled``, its last
/// completion carries that error in ``IORing/Completion/error`` and
/// doesn't contain `.moreCompletions`.
///
/// - Parameters:
/// - file: The file descriptor to monitor for I/O events.
/// - events: The I/O events to monitor on the file descriptor.
/// - isMultiShot: If `true`, the poll operation automatically rearms
/// after each event, continuing to monitor the file descriptor. If
/// `false`, the operation completes after the first matching event.
/// Defaults to `false`.
/// - context: An application-specific value passed through to the
/// completion event, allowing you to identify which operation
/// completed. Defaults to `0`.
///
/// - Returns: An I/O ring request that monitors the file descriptor for
/// the specified events.
///
/// ## See Also
///
/// - ``PollEvents``: The events that can be monitored.
/// - ``IORing/Request/cancel(_:matching:)-(_,FileDescriptor)``:
/// Canceling poll operations.
@inlinable public static func pollAdd(
_ file: FileDescriptor,
events: PollEvents,
isMultiShot: Bool = false,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .pollAdd(file: file, events: events, isMultiShot: isMultiShot, context: context))
}
@inlinable public static func read(
_ file: IORing.RegisteredFile,
into buffer: IORing.RegisteredBuffer,
@@ -316,24 +443,46 @@ extension IORing.Request {
// Cancel
/*
* ASYNC_CANCEL flags.
*
* IORING_ASYNC_CANCEL_ALL Cancel all requests that match the given key
* IORING_ASYNC_CANCEL_FD Key off 'fd' for cancellation rather than the
* request 'user_data'
* IORING_ASYNC_CANCEL_ANY Match any request
* IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor
* IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key
* IORING_ASYNC_CANCEL_OP Match request based on opcode
*/
/// Cancel every request matching the given key.
///
/// Corresponds to `IORING_ASYNC_CANCEL_ALL`.
@_alwaysEmitIntoClient
internal static var SWIFT_IORING_ASYNC_CANCEL_ALL: UInt32 { 1 << 0 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_ALL: UInt32 { 1 << 0 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_FD: UInt32 { 1 << 1 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_ANY: UInt32 { 1 << 2 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_FD_FIXED: UInt32 { 1 << 3 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_USERDATA: UInt32 { 1 << 4 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_OP: UInt32 { 1 << 5 }
/// Cancel any request matching the given file descriptor.
///
/// Corresponds to `IORING_ASYNC_CANCEL_FD`. Cannot be combined with
/// ``SWIFT_IORING_ASYNC_CANCEL_ANY``.
@_alwaysEmitIntoClient
internal static var SWIFT_IORING_ASYNC_CANCEL_FD: UInt32 { 1 << 1 }
/// Cancel any matching request, disregarding every other key.
///
/// Corresponds to `IORING_ASYNC_CANCEL_ANY`. Cannot be combined with
/// ``SWIFT_IORING_ASYNC_CANCEL_FD`` or ``SWIFT_IORING_ASYNC_CANCEL_OP``.
@_alwaysEmitIntoClient
internal static var SWIFT_IORING_ASYNC_CANCEL_ANY: UInt32 { 1 << 2 }
/// Cancel any request matching a registered file.
///
/// Corresponds to `IORING_ASYNC_CANCEL_FD_FIXED`, and accompanies
/// ``SWIFT_IORING_ASYNC_CANCEL_FD``.
@_alwaysEmitIntoClient
internal static var SWIFT_IORING_ASYNC_CANCEL_FD_FIXED: UInt32 { 1 << 3 }
/// Cancel requests matching the `user_data`. This is the default when no other
/// key is given.
///
/// Corresponds to `IORING_ASYNC_CANCEL_USERDATA`.
@_alwaysEmitIntoClient
internal static var SWIFT_IORING_ASYNC_CANCEL_USERDATA: UInt32 { 1 << 4 }
/// Cancel requests matching the operation.
///
/// Corresponds to `IORING_ASYNC_CANCEL_OP`. Cannot be combined with
/// ``SWIFT_IORING_ASYNC_CANCEL_ANY``.
@_alwaysEmitIntoClient
internal static var SWIFT_IORING_ASYNC_CANCEL_OP: UInt32 { 1 << 5 }
public enum CancellationMatch {
case all
@@ -477,6 +626,14 @@ extension IORing.Request {
case .cancel(let flags):
request.operation = .asyncCancel
request.cancel_flags = flags
case .pollAdd(let file, let events, let isMultiShot, let context):
request.operation = .pollAdd
request.fileDescriptor = file
request.rawValue.user_data = context
if isMultiShot {
request.rawValue.len = Self.SWIFT_IORING_POLL_ADD_MULTI
}
request.pollEvents = events
}
return request
+79
View File
@@ -0,0 +1,79 @@
/*
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)
import CSystem
#if canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#endif
/// Throwing wrapper around the `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) {
io_uring_enter2(
ringDescriptor, toSubmit, minComplete, flags, args, argsSize
)
}
return try result.get()
}
/// Throwing wrapper around the `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) {
io_uring_enter(ringDescriptor, toSubmit, minComplete, flags, sig)
}
return try result.get()
}
/// Throwing wrapper around the `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) {
io_uring_register(ringDescriptor, opcode, arg, nrArgs)
}
return try result.get()
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+125 -108
View File
@@ -1,3 +1,12 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2023 - 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)
@@ -42,8 +51,8 @@ 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
/// 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 {
@@ -128,23 +137,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
}
}
}
@@ -503,11 +519,10 @@ public struct IORing: ~Copyable {
var count = 0
while let completion = _tryConsumeCompletion(ring: completionRing) {
count += 1
if completion.result < 0 {
try consumer(nil, Errno(rawValue: -completion.result), false)
} else {
try consumer(completion, nil, false)
}
// We still return the completion for a failed operation so that the
// caller can tell which request failed through its `context`.
let error = completion.error
try consumer(completion, error, false)
if count == maximumCount {
try consumer(nil, nil, true)
return
@@ -517,49 +532,56 @@ 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) {
count += 1
if completion.result < 0 {
try consumer(nil, Errno(rawValue: -completion.result), false)
} else {
try consumer(completion, nil, false)
}
let error = completion.error
try consumer(completion, error, false)
if count == maximumCount {
break
}
}
try consumer(nil, nil, true)
}
try consumer(nil, nil, true)
}
@inlinable
@@ -569,17 +591,23 @@ public struct IORing: ~Copyable {
var result: Completion? = nil
try _blockingConsumeCompletionGuts(minimumCount: 1, maximumCount: 1, extraArgs: extraArgs) {
(completion: consuming Completion?, error, done) throws(Errno) in
if let error {
throw error
}
if let completion {
result = consume completion
} else if let error {
throw error
}
}
return result.take()!
}
/// Synchronously waits for an operation to complete for up to `timeout` (or forever if not specified)
///
/// The completion is returned even if its operation failed. Check
/// ``IORing/Completion/error`` to find out whether it did, and
/// ``IORing/Completion/context`` to find out which request it belongs to.
///
/// - Throws: An error of the ring itself, such as ``Errno/timeout`` when
/// no operation completed within `timeout`.
@inlinable
public func blockingConsumeCompletion(
timeout: Duration? = nil
@@ -603,7 +631,17 @@ public struct IORing: ~Copyable {
}
}
/// Synchronously waits for `minimumCount` or more operations to complete for up to `timeout` (or forever if not specified). For each completed operation found, `consumer` is called to handle processing it
/// Synchronously waits for `minimumCount` or more operations to complete for up to `timeout`
/// (or forever if not specified). For each completed operation found, `consumer` is called to handle
/// processing it.
///
/// `consumer` receives a completion, an error, and whether consuming is done:
/// - For each completed operation, it receives the completion. If the
/// operation failed, it receives the operation's error alongside the
/// completion.
/// - If the ring itself fails, such as with ``Errno/timeout``, it receives
/// the error without a completion.
/// - Once consuming is done, it is called a final time with `done` set to `true`.
@inlinable
public func blockingConsumeCompletions<Err: Error>(
minimumCount: UInt32 = 1,
@@ -632,10 +670,6 @@ public struct IORing: ~Copyable {
}
}
// public func peekNextCompletion() -> IOCompletion {
// }
/// Takes a completed operation from the ring and returns it, if one is ready. Otherwise, returns nil.
@inlinable
public func tryConsumeCompletion() -> Completion? {
@@ -660,31 +694,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
@@ -693,18 +718,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
@@ -712,16 +732,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
@@ -737,18 +754,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
@@ -786,16 +798,13 @@ 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.
@@ -809,6 +818,14 @@ public struct IORing: ~Copyable {
}
/// 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.
///
/// `consumer` receives a completion, an error, and whether consuming is done:
/// - For each completed operation, it receives the completion. If the
/// operation failed, it receives the operation's error alongside the
/// completion.
/// - If submitting the requests or waiting for completions fails, such as
/// with ``Errno/timeout``, it receives the error without a completion.
/// - Once consuming is done, it is called a final time with `done` set to `true`.
@inlinable
public func submitPreparedRequestsAndConsumeCompletions<Err: Error>(
minimumCount: UInt32 = 1,
@@ -884,7 +901,7 @@ public struct IORing: ~Copyable {
return true
}
/// Describes which io_uring features are supported by the kernel this program is running on
/// Describes which `io_uring` features are supported by the kernel this program is running on
public struct Features: OptionSet, RawRepresentable, Hashable {
public let rawValue: UInt32
@@ -910,7 +927,7 @@ public struct IORing: ~Copyable {
@inlinable public static var bundledSendReceive: Features { .init(rawValue: UInt32(1) << 14) } //IORING_FEAT_RECVSEND_BUNDLE
}
/// Describes which io_uring features are supported by the kernel this program is running on
/// Describes which `io_uring` features are supported by the kernel this program is running on
public var supportedFeatures: Features {
return features
}
+168
View File
@@ -0,0 +1,168 @@
/*
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)
extension IORing.Request {
/// A set of I/O events that can be monitored on a file descriptor.
///
/// `PollEvents` represents the event mask used with `io_uring` poll
/// operations to specify which I/O conditions to monitor on a file
/// descriptor. These events correspond to the standard POSIX poll events
/// defined in the kernel's `poll.h` header.
///
/// Use `PollEvents` with
/// ``IORing/Request/pollAdd(_:events:isMultiShot:context:)`` to
/// register interest in specific I/O events. The poll operation completes
/// when any of the specified events become active on the file descriptor.
///
/// ## Usage
///
/// ```swift
/// // Monitor a socket for incoming data
/// let request = IORing.Request.pollAdd(
/// socketFD,
/// events: .readable,
/// isMultiShot: true
/// )
/// ```
public struct PollEvents: OptionSet, Hashable, Codable {
public let rawValue: UInt32
@inlinable
public init(rawValue: UInt32) {
self.rawValue = rawValue
}
@usableFromInline
init(_ event: Event) {
self.rawValue = event.rawValue
}
@usableFromInline
enum Event: UInt32, RawRepresentable, Hashable, CaseIterable {
case readable = 0x0001
case priorityData = 0x0002
case writable = 0x0004
case error = 0x0008
case hangUp = 0x0010
case invalidDescriptor = 0x0020
case peerClosed = 0x2000
}
/// An event indicating data is available for reading.
///
/// This event becomes active when data arrives on the file descriptor
/// and can be read without blocking. For sockets, this includes when
/// a new connection is available on a listening socket. Corresponds
/// to the POSIX `POLLIN` event flag.
@inlinable
public static var readable: PollEvents { PollEvents(.readable) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "readable")
public static var POLLIN: PollEvents { readable }
/// An event indicating out-of-band data is available for reading.
///
/// For sockets this signals urgent data; it is also used to report
/// exceptional conditions on descriptors that have no other way to
/// signal them, such as a `sysfs` attribute that has changed value.
/// Corresponds to the POSIX `POLLPRI` event flag.
@inlinable
public static var priorityData: PollEvents { PollEvents(.priorityData) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "priorityData")
public static var POLLPRI: PollEvents { priorityData }
/// An event indicating the file descriptor is ready for writing.
///
/// This event becomes active when writing to the file descriptor will
/// not block. For sockets, this indicates that send buffer space is
/// available. Corresponds to the POSIX `POLLOUT` event flag.
@inlinable
public static var writable: PollEvents { PollEvents(.writable) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "writable")
public static var POLLOUT: PollEvents { writable }
/// An event indicating an error condition on the file descriptor.
///
/// The kernel reports this event whether or not it was requested, so
/// it can appear in a completion's result mask even when the poll
/// asked only for ``readable`` or ``writable``. Requesting it
/// explicitly has no effect. Corresponds to the POSIX `POLLERR` event
/// flag.
@inlinable
public static var error: PollEvents { PollEvents(.error) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "error")
public static var POLLERR: PollEvents { error }
/// An event indicating the peer closed its end of the channel.
///
/// For a pipe this means the writing end was closed; for a socket, that
/// the connection was shut down.
///
/// The kernel reports this event whether or not it was requested, and
/// requesting it explicitly has no effect. Corresponds to the POSIX
/// `POLLHUP` event flag.
@inlinable
public static var hangUp: PollEvents { PollEvents(.hangUp) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "hangUp")
public static var POLLHUP: PollEvents { hangUp }
/// An event indicating that the object a descriptor refers to is no
/// longer valid.
///
/// This arises when the descriptor itself resolves, but the thing it
/// refers to has since become invalid. For example, the disconnection
/// of a sound device could cause this event.
///
/// A descriptor that doesn't resolve at all would make the request
/// fail with ``Errno/badFileDescriptor`` instead.
///
/// The kernel reports this event whether or not it was requested, and
/// requesting it explicitly has no effect. Corresponds to the POSIX
/// `POLLNVAL` event flag.
@inlinable
public static var invalidDescriptor: PollEvents {
PollEvents(.invalidDescriptor)
}
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "invalidDescriptor")
public static var POLLNVAL: PollEvents { invalidDescriptor }
/// An event indicating the peer closed its writing end of a stream
/// socket, or shut it down for writing.
///
/// Unlike ``hangUp``, this event can arrive while the connection is
/// still half-open: data already in flight can still be read, and the
/// local end can still write. Once both directions are shut down,
/// ``hangUp`` is reported alongside this event.
///
/// Unlike `poll(2)`, `io_uring` reports this event whether or not it
/// was requested, and requesting it explicitly has no effect.
/// Corresponds to the Linux `POLLRDHUP` event flag.
@inlinable
public static var peerClosed: PollEvents { PollEvents(.peerClosed) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "peerClosed")
public static var POLLRDHUP: PollEvents { peerClosed }
}
}
#endif
#endif
+42 -7
View File
@@ -1,8 +1,22 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2023 - 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)
import CSystem
#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
@@ -75,6 +89,27 @@ extension RawIORequest {
set { rawValue.addr = newValue }
}
/// The poll event mask, stored in `sqe->poll32_events`.
///
/// Big-endian kernels swap the halfwords of this field before reading it.
/// Equivalent to liburing's `__io_uring_prep_poll_mask`.
@_alwaysEmitIntoClient var pollEvents: IORing.Request.PollEvents {
get { .init(rawValue: Self._applyPollMask(rawValue.poll32_events)) }
set { rawValue.poll32_events = Self._applyPollMask(newValue.rawValue) }
}
/// Converts a poll event mask between its in-memory and `sqe` encodings.
///
/// This is a halfword rotate (`swahw32` from `<linux/swab.h>`), which keeps
/// the byte order within each half.
@_alwaysEmitIntoClient static func _applyPollMask(_ mask: UInt32) -> UInt32 {
#if _endian(big)
return (mask &<< 16) | (mask &>> 16)
#else
return mask
#endif
}
@inlinable public var flags: Flags {
get { Flags(rawValue: rawValue.flags) }
set { rawValue.flags = newValue.rawValue }
@@ -176,20 +211,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
+4 -4
View File
@@ -1,7 +1,7 @@
/*
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
@@ -13,10 +13,10 @@ import Darwin
import CSystem
import ucrt
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import CSystem
import Musl
#elseif canImport(WASILibc)
import WASILibc
@@ -106,7 +106,7 @@ extension CInterop {
}
}
@available(System 99, *)
@available(System 1.7.0, *)
extension CInterop {
public typealias DeviceID = dev_t
public typealias Inode = ino_t
+4 -7
View File
@@ -11,19 +11,16 @@
// they can be used anywhere without imports and without confusion to
// unavailable local decls.
import CSystem
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif os(Windows)
import CSystem
import ucrt
#elseif canImport(Glibc)
import CSystem
import Glibc
#elseif canImport(Musl)
import CSystem
import Musl
#elseif canImport(WASILibc)
import CSystem
import WASILibc
#elseif canImport(Android)
import Android
@@ -631,10 +628,10 @@ internal var _O_CLOEXEC: CInt {
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _O_CLOFORK: CInt {
#if !os(WASI) && !os(Linux) && !os(Android) && !canImport(Darwin) && !os(FreeBSD)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
COMPATIBILITY_O_CLOFORK
#elseif !os(WASI) && !os(Linux) && !os(Android)
O_CLOFORK
#elseif os(FreeBSD)
FREEBSD_O_CLOFORK
#else
0
#endif
+12 -11
View File
@@ -1,7 +1,7 @@
/*
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
@@ -18,15 +18,15 @@ import Darwin
import CSystem
import ucrt
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import CSystem
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Android)
@_implementationOnly import CSystem
import CSystem
import Android
#else
#error("Unsupported Platform")
@@ -96,15 +96,15 @@ internal func system_strlen(_ s: UnsafeMutablePointer<CChar>) -> Int {
internal func system_stat(_ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
stat(p, &s)
}
@available(System 99, *)
@available(System 1.7.0, *)
internal func system_lstat(_ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
lstat(p, &s)
}
@available(System 99, *)
@available(System 1.7.0, *)
internal func system_fstat(_ fd: CInt, _ s: inout CInterop.Stat) -> Int32 {
fstat(fd, &s)
}
@available(System 99, *)
@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)
}
@@ -184,9 +184,10 @@ 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 {
#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 {
@@ -213,7 +214,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()
+10 -9
View File
@@ -7,6 +7,7 @@
See https://swift.org/LICENSE.txt for license information
*/
import CSystem
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
@@ -23,8 +24,6 @@ import Android
#error("Unsupported Platform")
#endif
import CSystem
// Interacting with the mocking system, tracing, etc., is a potentially significant
// amount of code size, so we hand outline that code for every syscall
@@ -141,13 +140,14 @@ internal func system_dup2(_ fd: Int32, _ fd2: Int32) -> Int32 {
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 ENABLE_MOCKING
if mockingEnabled { return _mock(fd, fd2, oflag) }
#endif
#endif
return csystem_posix_dup3(fd, fd2, oflag)
}
#endif
#endif // !os(WASI)
#if !os(WASI)
internal func system_pipe(_ fds: UnsafeMutablePointer<Int32>) -> CInt {
@@ -157,13 +157,14 @@ internal func system_pipe(_ fds: UnsafeMutablePointer<Int32>) -> CInt {
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
#endif // !os(WASI)
internal func system_ftruncate(_ fd: Int32, _ length: off_t) -> Int32 {
#if ENABLE_MOCKING
@@ -201,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
@@ -269,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(
@@ -277,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)
@@ -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()))
@@ -248,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 {
+4
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 {}
+4 -2
View File
@@ -12,18 +12,20 @@
// private CSystem module.
//
// For new type wrappers introduced to System, access their C members here:
// - Import the platform overlay (Glibc/Musl), as consumers do.
// - 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. One field is not always
// a safe proxy for the rest.
#if canImport(Glibc) || canImport(Musl)
#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
+3 -3
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// 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
@@ -36,7 +36,7 @@ import Android
@Suite("FileMode")
private struct FileModeTests {
@available(System 99, *)
@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)
@@ -67,7 +67,7 @@ private struct FileModeTests {
#expect(mode.type == mode2.type)
}
@available(System 99, *)
@available(System 1.7.0, *)
@Test func invalidInput() async throws {
// No permissions, all other bits set
var invalidMode = FileMode(rawValue: ~0o7777)
+13 -9
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`.
@@ -177,8 +178,10 @@ final class FileOperationsTest: XCTestCase {
}
}
#if !SYSTEM_PACKAGE_DARWIN
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]
@@ -198,10 +201,9 @@ final class FileOperationsTest: XCTestCase {
}
}
}
#endif // !SYSTEM_PACKAGE_DARWIN
#endif // !os(WASI)
#endif // !os(WASI)
#if !os(Windows)
#if !os(Windows)
func testAdHocDuplicate2() throws {
try withTemporaryFilePath(basename: "test") {
let path = $0.appending("foo2.txt")
@@ -238,10 +240,11 @@ final class FileOperationsTest: XCTestCase {
}
}
}
#endif // !os(Windows)
#if !SYSTEM_PACKAGE_DARWIN && !os(Windows)
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")
@@ -274,7 +277,7 @@ final class FileOperationsTest: XCTestCase {
}
}
}
#endif // !SYSTEM_PACKAGE_DARWIN && !os(Windows)
#endif // !os(Windows)
func testAdHocOpen() {
// Ad-hoc test touching a file system.
@@ -334,6 +337,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)
@@ -18,6 +18,7 @@ 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)
@@ -295,6 +296,38 @@ final class FileOperationsTestWindows: XCTestCase {
// 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)
+515 -23
View File
@@ -3,36 +3,94 @@
import XCTest
import CSystem //for eventfd
#if SYSTEM_PACKAGE
import SystemPackage
#else
import System
#if canImport(Glibc)
import Glibc // for errno
#elseif canImport(Musl)
import Musl // for errno
#endif
func uringEnabled() throws -> Bool {
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
// 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
}()
let failureMessage = "Runtime environment does not support IORing."
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 CSystem); 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 = 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 }
try XCTSkipIf(!uringEnabled, failureMessage)
_ = try IORing(queueDepth: 32, flags: [])
}
func testNop() throws {
guard try uringEnabled() else { return }
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 32, flags: [])
_ = try ring.submit(linkedRequests: .nop())
let completion = try ring.blockingConsumeCompletion()
@@ -68,7 +126,7 @@ final class IORingTests: XCTestCase {
}
func testUndersizedSubmissionQueue() throws {
guard try uringEnabled() else { return }
try XCTSkipIf(!uringEnabled, failureMessage)
var ring: IORing = try IORing(queueDepth: 1)
let enqueued = ring.prepare(linkedRequests: .nop(), .nop())
XCTAssertFalse(enqueued)
@@ -76,7 +134,7 @@ final class IORingTests: XCTestCase {
// Exercises opening, reading, closing, registered files, registered buffers, and eventfd
func testOpenReadAndWriteFixedFile() throws {
guard try uringEnabled() else { return }
try XCTSkipIf(!uringEnabled, failureMessage)
let (parent, path) = try makeHelloWorldFile()
let rawBuffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 13, alignment: 16)
var ring = try setupTestRing(depth: 6, fileSlots: 1, buffers: [rawBuffer])
@@ -117,12 +175,11 @@ 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)
let result2 = String(cString: rawBuffer.assumingMemoryBound(to: CChar.self).baseAddress!)
XCTAssertEqual(result2, "Hello, World!")
XCTAssertEqual(result2, "Hello, World!")
try cleanUpHelloWorldFile(parent)
efdBuf.deallocate()
rawBuffer.deallocate()
@@ -134,7 +191,7 @@ final class IORingTests: XCTestCase {
// 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 try uringEnabled() else { return }
try XCTSkipIf(!uringEnabled, failureMessage)
let (parent, _) = try makeHelloWorldFile()
var ring = try IORing(queueDepth: 6)
@@ -168,7 +225,7 @@ final class IORingTests: XCTestCase {
}
func testPathBufferLifetimeAcrossLinkedRequests() throws {
guard try uringEnabled() else { return }
try XCTSkipIf(!uringEnabled, failureMessage)
let (parent, _) = try makeHelloWorldFile()
let rawBuffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 13, alignment: 16)
var ring = try setupTestRing(depth: 6, fileSlots: 1, buffers: [rawBuffer])
@@ -202,6 +259,441 @@ final class IORingTests: XCTestCase {
try cleanUpHelloWorldFile(parent)
rawBuffer.deallocate()
}
// Timeout test for `blockingConsumeCompletion(timeout:)`:
func testBlockingConsumeCompletionWithTimeoutOnIdleRing() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
let ring = try IORing(queueDepth: 4, flags: [])
try XCTSkipIf(
!ring.supportedFeatures.contains(.extendedArguments),
"Kernel < 5.11: timeouts in io_uring_enter aren't supported."
)
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 testBlockingConsumeCompletionsSendsDone() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 4)
XCTAssertTrue(try ring.submit(linkedRequests: .nop()))
var dones: [Bool] = []
ring.blockingConsumeCompletions { (completion: consuming IORing.Completion?, error, done) in
dones.append(done)
}
XCTAssertEqual(dones, [false, true])
}
func testBlockingConsumeCompletionsKeepsContextOfFailedCompletion() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 4)
XCTAssertTrue(try ring.submit(
linkedRequests: .close(FileDescriptor(rawValue: -1), context: 42)
))
var received: [(context: UInt64?, error: Errno?, done: Bool)] = []
ring.blockingConsumeCompletions { (completion: consuming IORing.Completion?, error, done) in
received.append((completion?.context, error, done))
}
XCTAssertEqual(received.count, 2)
XCTAssertEqual(received.first?.context, 42)
XCTAssertEqual(received.first?.error, .badFileDescriptor)
XCTAssertEqual(received.first?.done, false)
XCTAssertEqual(received.last?.context, nil)
XCTAssertEqual(received.last?.error, nil)
XCTAssertEqual(received.last?.done, true)
}
func testBlockingConsumeCompletionReturnsFailedCompletion() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 4)
XCTAssertTrue(try ring.submit(
linkedRequests: .close(FileDescriptor(rawValue: -1), context: 43)
))
let completion = try ring.blockingConsumeCompletion()
XCTAssertEqual(completion.context, 43)
XCTAssertEqual(completion.error, .badFileDescriptor)
XCTAssertEqual(completion.result, -Errno.badFileDescriptor.rawValue)
}
func testSubmitAndConsumeCompletionsKeepsContextOfFailedCompletion() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 4)
XCTAssertTrue(ring.prepare(request: .close(FileDescriptor(rawValue: -1), context: 44)))
var received: [(context: UInt64?, error: Errno?, done: Bool)] = []
ring.submitPreparedRequestsAndConsumeCompletions {
(completion: consuming IORing.Completion?, error, done) in
received.append((completion?.context, error, done))
}
XCTAssertEqual(received.count, 2)
XCTAssertEqual(received.first?.context, 44)
XCTAssertEqual(received.first?.error, .badFileDescriptor)
XCTAssertEqual(received.first?.done, false)
XCTAssertEqual(received.last?.context, nil)
XCTAssertEqual(received.last?.error, nil)
XCTAssertEqual(received.last?.done, true)
}
func testCompletionOfSuccessfulOperationHasNoError() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 4)
XCTAssertTrue(try ring.submit(linkedRequests: .nop()))
let completion = try ring.blockingConsumeCompletion()
XCTAssertEqual(completion.result, 0)
XCTAssertNil(completion.error)
}
func testRegisterEventFDTwiceThrows() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
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 {
try XCTSkipIf(!uringEnabled, failureMessage)
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))
}
}
func testPollAddPollIn() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 32, flags: [])
// This test case requires timeout support
try XCTSkipIf(
!ring.supportedFeatures.contains(.extendedArguments),
"Kernel < 5.11: timeouts in io_uring_enter aren't supported."
)
// Test POLLIN: Create an eventfd to monitor for read readiness
let testEventFD = FileDescriptor(rawValue: eventfd(0, 0))
defer {
try? testEventFD.close()
}
let pollInContext: UInt64 = 42
// Submit a pollAdd request to monitor for POLLIN events (data available for reading)
let enqueued = try ring.submit(linkedRequests:
.pollAdd(testEventFD, events: .readable, isMultiShot: false, context: pollInContext))
XCTAssert(enqueued)
// Write to the eventfd to trigger the POLLIN event
var value: UInt64 = 1
withUnsafeBytes(of: &value) { bufferPtr in
_ = try? testEventFD.write(bufferPtr)
}
// Consume the completion from the poll operation
let completion = try ring.blockingConsumeCompletion(
timeout: .seconds(1)
)
XCTAssertEqual(completion.context, pollInContext)
let readable = Int32(IORing.Request.PollEvents.readable.rawValue)
XCTAssertNotEqual(
completion.result & readable, 0, "expected POLLIN in the result mask"
)
}
func testPollAddPollOut() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 32, flags: [])
// This test case requires timeout support
try XCTSkipIf(
!ring.supportedFeatures.contains(.extendedArguments),
"Kernel < 5.11: timeouts in io_uring_enter aren't supported."
)
// Test POLLOUT: Create a pipe to monitor for write readiness
var pipeFDs: [Int32] = [0, 0]
let pipeResult = pipe(&pipeFDs)
XCTAssertEqual(pipeResult, 0)
let writeFD = FileDescriptor(rawValue: pipeFDs[1])
let readFD = FileDescriptor(rawValue: pipeFDs[0])
defer {
try? writeFD.close()
try? readFD.close()
}
let pollOutContext: UInt64 = 43
// Submit a pollAdd request to monitor for POLLOUT events (ready for writing)
// Pipes are typically ready for writing when empty
let enqueuedOut = try ring.submit(linkedRequests:
.pollAdd(writeFD, events: .writable, isMultiShot: false, context: pollOutContext))
XCTAssert(enqueuedOut)
// Consume the completion from the poll operation
let completionOut = try ring.blockingConsumeCompletion(
timeout: .seconds(1)
)
XCTAssertEqual(completionOut.context, pollOutContext)
let writable = Int32(IORing.Request.PollEvents.writable.rawValue)
XCTAssertNotEqual(
completionOut.result & writable, 0,
"expected POLLOUT in the result mask"
)
}
// Similar to the multishot example in the documentation for
// `pollAdd(_:events:isMultiShot:context:)`: arm a multishot poll,
// then consume completions for as long as they carry `.moreCompletions`.
func testPollAddMultiShotRearmsAcrossEvents() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 32, flags: [])
// This test case requires timeout support
try XCTSkipIf(
!ring.supportedFeatures.contains(.extendedArguments),
"Kernel < 5.11: timeouts in io_uring_enter aren't supported."
)
var pipeFDs: [Int32] = [0, 0]
XCTAssertEqual(pipe(&pipeFDs), 0)
let readFD = FileDescriptor(rawValue: pipeFDs[0])
let writeFD = FileDescriptor(rawValue: pipeFDs[1])
defer {
try? readFD.close()
try? writeFD.close()
}
func writeByte() throws {
var byte: UInt8 = 1
try withUnsafeBytes(of: &byte) {
try XCTAssertEqual(writeFD.write($0), 1)
}
}
func readByte() throws {
var scratch: UInt8 = 0
try withUnsafeMutableBytes(of: &scratch) {
try XCTAssertEqual(readFD.read(into: $0), 1)
}
}
let context: UInt64 = 44
let readable = Int32(IORing.Request.PollEvents.readable.rawValue)
let pollRequest = IORing.Request.pollAdd(
readFD, events: .readable, isMultiShot: true, context: context
)
let enqueued = try ring.submit(linkedRequests: pollRequest)
XCTAssert(enqueued)
try writeByte()
let first = try ring.blockingConsumeCompletion(timeout: .seconds(1))
// Kernels before 5.13 reject IORING_POLL_ADD_MULTI
try XCTSkipIf(
first.result == -EINVAL,
"Kernel < 5.13: multishot poll is unsupported."
)
XCTAssertEqual(first.context, context)
XCTAssertNotEqual(
first.result & readable, 0, "expected POLLIN in the result mask"
)
XCTAssert(first.flags.contains(.moreCompletions))
// Drain the pipe, then any extra completions.
try readByte()
while ring.tryConsumeCompletion() != nil {}
try writeByte()
// This written byte will only be reported by a re-armed poll.
let second = try ring.blockingConsumeCompletion(timeout: .seconds(1))
XCTAssertEqual(second.context, context)
XCTAssertNotEqual(
second.result & readable, 0, "expected POLLIN in the result mask"
)
// Drain again
try readByte()
while ring.tryConsumeCompletion() != nil {}
// Cancel to end the multishot poll.
try XCTAssert(
ring.submit(linkedRequests: .cancel(.all, matchingContext: context))
)
var terminal: (result: Int32, flags: IORing.Completion.Flags)? = nil
var observed: [(context: UInt64, result: Int32, flags: UInt32)] = []
// The cancel posts a completion of its own under a different context,
// and the two may land a moment apart, so retry briefly rather than
// draining exactly once.
for _ in 0..<100 where terminal == nil {
while let completion = ring.tryConsumeCompletion() {
observed.append(
(
completion.context,
completion.result,
completion.flags.rawValue
)
)
if completion.context == context {
terminal = (completion.result, completion.flags)
}
}
if terminal == nil { usleep(1000) }
}
XCTAssertNotNil(
terminal,
"no terminal completion for the cancelled poll; "
+ "completions seen: \(observed)"
)
if let terminal {
XCTAssertEqual(terminal.result, -ECANCELED)
XCTAssertFalse(
terminal.flags.contains(.moreCompletions),
"poll kept its armed state after being cancelled"
)
}
}
func testPollHangup() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 8)
let (readFD, writeFD) = try FileDescriptor.pipe()
// The hangup is produced by closing the write end mid-test, so the
// cleanup below must not close it a second time: the descriptor number
// may already have been reused elsewhere in the test process.
var writeEndClosed = false
defer {
try? readFD.close()
if !writeEndClosed { try? writeFD.close() }
}
// This test case requires timeout support
try XCTSkipIf(
!ring.supportedFeatures.contains(.extendedArguments),
"Kernel < 5.11: timeouts in io_uring_enter aren't supported."
)
let request = IORing.Request.pollAdd(
readFD, events: .readable, isMultiShot: false, context: 97
)
let success = try ring.submit(linkedRequests: request)
XCTAssertEqual(success, true)
try writeFD.close()
writeEndClosed = true
let dt = Duration.seconds(1)
let completion = try ring.blockingConsumeCompletion(timeout: dt)
for event in IORing.Request.PollEvents.Event.allCases {
if completion.result & Int32(event.rawValue) != 0 {
XCTAssertEqual(event, .hangUp)
return
}
}
let unexpected = completion.result
XCTFail("Unexpected poll event: 0x\(String(unexpected, radix: 16))")
}
func testPollError() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 8)
let (readFD, writeFD) = try FileDescriptor.pipe(options: .nonBlocking)
// POLLERR is produced by closing the read end mid-test; see the note in
// `testPollHangup` for why cleanup must not close it twice.
var readEndClosed = false
defer {
if !readEndClosed { try? readFD.close() }
try? writeFD.close()
}
// This test case requires timeout support
try XCTSkipIf(
!ring.supportedFeatures.contains(.extendedArguments),
"Kernel < 5.11: timeouts in io_uring_enter aren't supported."
)
let chunk = [UInt8](repeating: 0, count: 4096)
chunk.withUnsafeBytes {
// Fill the pipe by writing until an operation fails
while let written = try? writeFD.write($0), written > 0 {}
}
let request = IORing.Request.pollAdd(
writeFD, events: .writable, isMultiShot: false, context: 98
)
let success = try ring.submit(linkedRequests: request)
XCTAssertEqual(success, true)
try readFD.close()
readEndClosed = true
let dt = Duration.seconds(1)
let completion = try ring.blockingConsumeCompletion(timeout: dt)
XCTAssertEqual(completion.context, 98)
let pollError = IORing.Request.PollEvents.error.rawValue
let result = completion.result & Int32(pollError)
if result != pollError {
XCTFail("expected POLLERR, got 0x\(String(result, radix: 16))")
}
}
// A completion's `result` is two things in one field: a non-negative
// value is an event mask, and a negative value is a negated errno. The
// sign is the only thing distinguishing them, so it has to be checked
// before the value is treated as anything else.
func testPollAddOnInvalidDescriptor() throws {
try XCTSkipIf(!uringEnabled, failureMessage)
var ring = try IORing(queueDepth: 8)
let request = IORing.Request.pollAdd(
FileDescriptor(rawValue: -1), events: .readable,
isMultiShot: false, context: 99
)
let success = try ring.submit(linkedRequests: request)
XCTAssertEqual(success, true)
guard let completion = ring.tryConsumeCompletion() else {
XCTFail("expected a completion for the failed poll")
return
}
XCTAssertEqual(completion.context, 99)
// A negative value for `result` marks the completion a a failure.
XCTAssertLessThan(completion.result, 0, "expected a failure")
// The negative value is the error code multiplied by -1.
XCTAssertEqual(Errno(rawValue: -completion.result), .badFileDescriptor)
// A negative result may look like another result code.
// Checking for the error must happen first.
let invalidDescriptor = Int32(IORing.Request.PollEvents.invalidDescriptor.rawValue)
XCTAssertNotEqual(completion.result & invalidDescriptor, 0)
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+50 -14
View File
@@ -2,7 +2,7 @@
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// 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
@@ -39,7 +39,7 @@ import Android
@Suite("Stat")
private struct StatTests {
@available(System 99, *)
@available(System 1.7.0, *)
@Test func basics() async throws {
try withTemporaryFilePath(basename: "Stat_basics") { tempDir in
let dirStatFromFilePath = try tempDir.stat()
@@ -81,7 +81,7 @@ private struct StatTests {
}
}
@available(System 99, *)
@available(System 1.7.0, *)
@Test func followSymlinkInits() async throws {
try withTemporaryFilePath(basename: "Stat_followSymlinkInits") { tempDir in
let targetFilePath = tempDir.appending("target.txt")
@@ -190,7 +190,7 @@ private struct StatTests {
}
}
@available(System 99, *)
@available(System 1.7.0, *)
@Test func permissions() async throws {
try withTemporaryFilePath(basename: "Stat_permissions") { tempDir in
let testFile = tempDir.appending("test.txt")
@@ -220,8 +220,13 @@ private struct StatTests {
}
}
@available(System 99, *)
@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
@@ -247,8 +252,7 @@ private struct StatTests {
#expect(dirCreationTime0 < startUpperBound)
#endif
// Fails intermittently if less than 5ms
usleep(10000)
usleep(timestampSleep)
let file1 = tempDir.appending("test1.txt")
let fd1 = try FileDescriptor.open(file1, .writeOnly, options: .create, permissions: .ownerReadWrite)
@@ -274,7 +278,7 @@ private struct StatTests {
#expect(dirCreationTime1 == dirCreationTime0)
#endif
usleep(10000)
usleep(timestampSleep)
// Changing permissions only updates directory change time
@@ -302,7 +306,7 @@ private struct StatTests {
let file1CreationTime1 = stat1.st_birthtim
#endif
usleep(10000)
usleep(timestampSleep)
try fd1.writeAll("Hello, world!".utf8)
stat1 = try file1.stat()
@@ -330,7 +334,7 @@ private struct StatTests {
#expect(dirStat.st_birthtim == dirCreationTime1)
#endif
usleep(10000)
usleep(timestampSleep)
let file2 = tempDir.appending("test2.txt")
let fd2 = try FileDescriptor.open(file2, .writeOnly, options: .create, permissions: .ownerReadWrite)
@@ -339,9 +343,9 @@ private struct StatTests {
}
let stat2 = try file2.stat()
#expect(stat2.st_atim > file1AccessTime2)
#expect(stat2.st_mtim > file1ModificationTime2)
#expect(stat2.st_ctim > file1ChangeTime2)
#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
@@ -349,7 +353,7 @@ private struct StatTests {
}
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
@available(System 99, *)
@available(System 1.7.0, *)
@Test func flags() async throws {
try withTemporaryFilePath(basename: "Stat_flags") { tempDir in
let filePath = tempDir.appending("test.txt")
@@ -397,6 +401,38 @@ private struct StatTests {
}
#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