mirror of
https://github.com/apple/swift-system
synced 2026-11-22 04:30:46 +00:00
Compare commits
64
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4f1a3aceb1 | ||
|
|
1dc5cdc944 | ||
|
|
781b0cfab5 | ||
|
|
e96ba28879 | ||
|
|
c0e3eea428 | ||
|
|
53b1815f41 | ||
|
|
8e71dd3e0d | ||
|
|
677e51f1f2 | ||
|
|
cf29202fc7 | ||
|
|
406f7634f1 | ||
|
|
1da023b4ca | ||
|
|
abc83c2de1 | ||
|
|
2949c1bfcb | ||
|
|
fa6a245b37 | ||
|
|
640e5755b5 | ||
|
|
1c44ed678c | ||
|
|
6c5077b2d2 | ||
|
|
762c819b0f | ||
|
|
013178c00e | ||
|
|
70505cf6fc | ||
|
|
d1b4ed40f2 | ||
|
|
20dddc22ed | ||
|
|
f6105a8be1 | ||
|
|
65df702254 | ||
|
|
77882a1fc8 | ||
|
|
402eb4b586 | ||
|
|
7f6a009cc4 | ||
|
|
8f2745da9a | ||
|
|
74c1ef0581 | ||
|
|
6dbc60a373 | ||
|
|
443e03c16f | ||
|
|
1e6e65ede7 | ||
|
|
90a005db2f | ||
|
|
98517ef93b | ||
|
|
f28e22fbc1 | ||
|
|
e16b3f1066 | ||
|
|
a3e9687c91 | ||
|
|
b1f3496e31 | ||
|
|
15479b53b9 | ||
|
|
688716f8a2 | ||
|
|
6374a4ab3a | ||
|
|
feb66db229 | ||
|
|
a51425f6d8 | ||
|
|
da235b4503 | ||
|
|
86fdc1dd1d | ||
|
|
d0f7d75929 | ||
|
|
f325ebf78f | ||
|
|
4179b2cce5 | ||
|
|
f5fe750a57 | ||
|
|
9bf5df3d10 | ||
|
|
d27cb52754 | ||
|
|
faae10c4ec | ||
|
|
a85b97fc62 | ||
|
|
92481cc056 | ||
|
|
f0d63f4282 | ||
|
|
b832f4134a | ||
|
|
0eab740450 | ||
|
|
cf36a2fe7b | ||
|
|
9a9b78e4e9 | ||
|
|
292eb44442 | ||
|
|
b2237390d8 | ||
|
|
671a219316 | ||
|
|
5cf1e06016 | ||
|
|
411318ca34 |
No files matched your search
@@ -0,0 +1,20 @@
|
||||
name: Create PR to merge release branch into the main branch
|
||||
# Changes should land on the earliest release branch they will need to ship on and then be automatically forwarded to main
|
||||
permissions:
|
||||
contents: read
|
||||
on:
|
||||
schedule:
|
||||
- cron: '0 9 * * *'
|
||||
workflow_dispatch:
|
||||
jobs:
|
||||
create_merge_pr:
|
||||
name: Create PR to merge release branch into main branch
|
||||
uses: swiftlang/github-workflows/.github/workflows/create_automerge_pr.yml@0.0.18
|
||||
with:
|
||||
base_branch: main
|
||||
head_branch: release/1.9.x
|
||||
pr_message: This PR was automatically opened by a GitHub action. Review the changes included in this PR and determine if they should be included on main. If yes, merge the PR. Otherwise revert changes that should not be included on this branch.
|
||||
permissions:
|
||||
contents: write
|
||||
pull-requests: write
|
||||
if: (github.event_name == 'schedule' && github.repository == 'apple/swift-system') || (github.event_name != 'schedule') # Ensure that we don't run this on a schedule in a fork
|
||||
@@ -0,0 +1,21 @@
|
||||
name: Create PR to merge the previous release branch into the current release branch
|
||||
# Changes should land on the earliest release branch they will need to ship on and then be automatically forwarded to later release branches and main
|
||||
permissions:
|
||||
contents: read
|
||||
on:
|
||||
schedule:
|
||||
# An hour before automerge_to_main.yml. Runs at the same time would collide due to <HH-MM> branch naming.
|
||||
- cron: '0 8 * * *'
|
||||
workflow_dispatch:
|
||||
jobs:
|
||||
create_merge_pr:
|
||||
name: Create PR to merge previous release branch into current release branch
|
||||
uses: swiftlang/github-workflows/.github/workflows/create_automerge_pr.yml@0.0.18
|
||||
with:
|
||||
base_branch: release/1.9.x
|
||||
head_branch: release/1.8.x
|
||||
pr_message: This PR was automatically opened by a GitHub action. Review the changes included in this PR and determine if they should be included on this release branch. If yes, merge the PR. Otherwise revert changes that should not be included on this branch.
|
||||
permissions:
|
||||
contents: write
|
||||
pull-requests: write
|
||||
if: (github.event_name == 'schedule' && github.repository == 'apple/swift-system') || (github.event_name != 'schedule') # Ensure that we don't run this on a schedule in a fork
|
||||
@@ -5,58 +5,45 @@ permissions:
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, reopened, synchronize]
|
||||
types: [opened, reopened, synchronize, ready_for_review]
|
||||
|
||||
jobs:
|
||||
tests:
|
||||
name: Test
|
||||
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.15
|
||||
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.18
|
||||
with:
|
||||
swift_flags: "-Xbuild-tools-swiftc -DSYSTEM_CI"
|
||||
enable_linux_checks: true
|
||||
linux_os_versions: '["noble", "jammy", "focal"]'
|
||||
linux_exclude_swift_versions: |
|
||||
[
|
||||
{"swift_version": "5.9"},
|
||||
{"swift_version": "5.10"},
|
||||
{"swift_version": "6.0"},
|
||||
{"os_version": "focal", "swift_version": "nightly-6.2"},
|
||||
{"swift_version": "6.1"},
|
||||
{"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": "6.4"},
|
||||
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
|
||||
{"os_version": "focal", "swift_version": "6.4.x"},
|
||||
{"os_version": "focal", "swift_version": "nightly-main"},
|
||||
]
|
||||
enable_macos_checks: true
|
||||
macos_exclude_xcode_versions: '[]'
|
||||
enable_windows_checks: true
|
||||
macos_exclude_xcode_versions: |
|
||||
[
|
||||
{"xcode_version": "swift_6.1"},
|
||||
]
|
||||
windows_exclude_swift_versions: |
|
||||
[
|
||||
{"swift_version": "5.9"},
|
||||
{"swift_version": "5.10"},
|
||||
{"swift_version": "6.0"},
|
||||
{"swift_version": "6.1"},
|
||||
]
|
||||
enable_linux_static_sdk_build: true
|
||||
linux_static_sdk_exclude_swift_versions: |
|
||||
[
|
||||
{"os_version": "focal", "swift_version": "nightly-6.2"},
|
||||
{"os_version": "focal", "swift_version": "6.2"},
|
||||
{"os_version": "focal", "swift_version": "nightly-6.3"},
|
||||
{"os_version": "focal", "swift_version": "6.3"},
|
||||
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
|
||||
{"os_version": "focal", "swift_version": "6.4.x"},
|
||||
{"os_version": "focal", "swift_version": "6.4"},
|
||||
{"os_version": "focal", "swift_version": "nightly-main"},
|
||||
]
|
||||
enable_wasm_sdk_build: true
|
||||
wasm_exclude_swift_versions: |
|
||||
[
|
||||
{"os_version": "focal", "swift_version": "nightly-6.2"},
|
||||
{"os_version": "focal", "swift_version": "6.2"},
|
||||
{"os_version": "focal", "swift_version": "nightly-6.3"},
|
||||
{"os_version": "focal", "swift_version": "6.3"},
|
||||
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
|
||||
{"os_version": "focal", "swift_version": "6.4.x"},
|
||||
{"os_version": "focal", "swift_version": "6.4"},
|
||||
{"os_version": "focal", "swift_version": "nightly-main"},
|
||||
]
|
||||
enable_android_sdk_build: true
|
||||
@@ -65,14 +52,17 @@ jobs:
|
||||
|
||||
build-abi-stable:
|
||||
name: Build ABI Stable
|
||||
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.15
|
||||
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@0.0.18
|
||||
with:
|
||||
enable_linux_checks: false
|
||||
enable_macos_checks: true
|
||||
macos_exclude_xcode_versions: |
|
||||
[
|
||||
{"xcode_version": "swift_6.1"},
|
||||
]
|
||||
enable_windows_checks: false
|
||||
# Only build
|
||||
macos_build_command: "xcrun swift build --build-tests"
|
||||
macos_exclude_xcode_versions: '[]'
|
||||
# Enable availability to match ABI stable verion of system.
|
||||
swift_flags: "-Xbuild-tools-swiftc -DSYSTEM_CI -Xbuild-tools-swiftc -DSYSTEM_ABI_STABLE"
|
||||
|
||||
@@ -85,7 +75,10 @@ jobs:
|
||||
uses: actions/checkout@v6
|
||||
- name: Install Dependencies
|
||||
shell: bash
|
||||
run: apt update && apt install -y cmake ninja-build jq
|
||||
run: |
|
||||
apt update && apt install -y curl ninja-build jq
|
||||
curl -fsSL "https://github.com/Kitware/CMake/releases/download/v4.0.2/cmake-4.0.2-linux-$(uname -m).tar.gz" \
|
||||
| tar --strip-components=1 -xz -C /usr/local
|
||||
- name: Configure Project
|
||||
shell: bash
|
||||
run: |
|
||||
@@ -112,7 +105,7 @@ jobs:
|
||||
|
||||
soundness:
|
||||
name: Soundness
|
||||
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@0.0.15
|
||||
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@0.0.18
|
||||
with:
|
||||
license_header_check_project_name: "Swift.org"
|
||||
# https://github.com/apple/swift-system/issues/224
|
||||
|
||||
+1
-1
@@ -7,7 +7,7 @@ Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
See https://swift.org/LICENSE.txt for license information
|
||||
#]]
|
||||
|
||||
cmake_minimum_required(VERSION 3.16.0)
|
||||
cmake_minimum_required(VERSION 3.29)
|
||||
project(SwiftSystem
|
||||
LANGUAGES C Swift)
|
||||
|
||||
|
||||
+10
-2
@@ -1,4 +1,4 @@
|
||||
// swift-tools-version:6.1
|
||||
// swift-tools-version:6.2
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift System open source project
|
||||
@@ -61,6 +61,8 @@ let availability: [Available] = [
|
||||
|
||||
Available("1.7.0", "macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0"),
|
||||
|
||||
Available("1.9.0", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
|
||||
|
||||
Available("199", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
|
||||
]
|
||||
|
||||
@@ -125,9 +127,15 @@ let package = Package(
|
||||
dependencies: [],
|
||||
exclude: ["CMakeLists.txt"],
|
||||
cSettings: cSettings),
|
||||
.systemLibrary(
|
||||
name: "CSystemStatFS",
|
||||
path: "Sources/CSystemStatFS"),
|
||||
.target(
|
||||
name: "SystemPackage",
|
||||
dependencies: ["CSystem"],
|
||||
dependencies: [
|
||||
"CSystem",
|
||||
.target(name: "CSystemStatFS", condition: .when(platforms: [.linux])),
|
||||
],
|
||||
path: "Sources/System",
|
||||
exclude: filesToExclude,
|
||||
cSettings: cSettings,
|
||||
|
||||
@@ -0,0 +1,972 @@
|
||||
# StatFS for Swift System
|
||||
|
||||
* Proposal: [SYS-0009](0009-system-statfs.md)
|
||||
* Authors: [Jonathan Flat](https://github.com/jrflat)
|
||||
* Review Manager: TBD
|
||||
* Status: **Implemented**
|
||||
* Implementation: [apple/swift-system#361](https://github.com/apple/swift-system/pull/361)
|
||||
* Review: ([pitch](https://forums.swift.org/t/pitch-statfs-and-supporting-types/88151))
|
||||
|
||||
#### Revision history
|
||||
|
||||
* **v1** Initial version
|
||||
* **v2** Use `statfs` on Linux and Android, make `StatFS` unavailable on WASI, omit Linux flags the kernel never reports, add descriptions for `MountFlags` and `FileSystemID`, and back-deploy `CInterop.StatFS` with `CInterop.statfs(_:_:)` for migration
|
||||
* **v3** Rename `MountFlags` constants for consistency, remove `type` on Darwin and FreeBSD, and remove the `statfs()` methods on `FilePath` and `FileDescriptor`, eliminating the need for `CInterop` back-deployment
|
||||
* **v4** Add `FileSystemTypeName` wrapper
|
||||
|
||||
## Introduction
|
||||
|
||||
This proposal introduces a Swift-native `StatFS` type to the System library, providing comprehensive access to file system metadata on Unix-like platforms through type-safe, platform-aware APIs that wrap the underlying C `statfs` system calls.
|
||||
|
||||
## Motivation
|
||||
|
||||
Currently, Swift developers who want to work with the file system's lowest level API can only do so through bridged C interfaces. These interfaces lack type safety and require writing non-idiomatic Swift, leading to errors and confusion.
|
||||
|
||||
The C `statfs` interfaces add a few problems of their own:
|
||||
|
||||
- On Linux, Swift's Glibc module doesn't export `statfs`, so calling it requires a C shim.
|
||||
- Block counts are in units of `f_bsize` on Darwin and BSD, but `f_frsize` on Linux and Android, so computing space in bytes requires platform-specific code.
|
||||
- Field widths and signedness vary by platform and C library. For example, `f_bavail` is signed on FreeBSD and OpenBSD.
|
||||
|
||||
The goal of the `StatFS` type is to provide a faithful and performant Swift wrapper around the underlying C system calls while adding type safety, platform abstraction, and improved discoverability/usability with clear naming. For more on the motivation behind System, see [https://www.swift.org/blog/swift-system](https://www.swift.org/blog/swift-system).
|
||||
|
||||
## Proposed solution
|
||||
|
||||
This proposal adds a `struct StatFS` that is available on Unix-like platforms. On Windows and WASI, the struct is declared but marked unavailable (see **Availability on Windows and WASI**). Windows-specific file system APIs and WASI support are discussed in **Future directions**.
|
||||
|
||||
`StatFS` is a Swift wrapper around the C `statfs` struct, which provides information about file systems. This type uses `statfs` rather than the POSIX `statvfs` for the additional information it provides, such as the file system type. Computed properties like `.totalSpace` and `.availableSpace` are supplied for convenience.
|
||||
|
||||
```swift
|
||||
// Get file system information from a path
|
||||
let statfs = try StatFS("/")
|
||||
|
||||
// From FileDescriptor
|
||||
let fdStatFS = try StatFS(fd)
|
||||
|
||||
// From FilePath
|
||||
let pathStatFS = try StatFS(filePath)
|
||||
|
||||
print("File system ID: \(statfs.fileSystemID)")
|
||||
print("Total space: \(statfs.totalSpace) bytes")
|
||||
print("Available space: \(statfs.availableSpace) bytes")
|
||||
|
||||
// Check mount flags
|
||||
if statfs.mountFlags.contains(.readOnly) {
|
||||
print("File system is read-only")
|
||||
}
|
||||
|
||||
// Platform-specific information when available
|
||||
#if os(anyAppleOS) || os(FreeBSD) || os(OpenBSD)
|
||||
print("File system is mounted at \(statfs.mountPoint)")
|
||||
print("File system is mounted from \(statfs.mountSource)")
|
||||
#endif
|
||||
|
||||
#if os(anyAppleOS)
|
||||
if statfs.typeName == .apfs {
|
||||
print("File system is APFS")
|
||||
}
|
||||
#endif
|
||||
```
|
||||
|
||||
### Error handling
|
||||
|
||||
The throwing initializers use a typed `throws(Errno)` and require Swift 6.0 or later:
|
||||
|
||||
```swift
|
||||
do {
|
||||
let statfs = try StatFS("/nonexistent/file")
|
||||
} catch Errno.noSuchFileOrDirectory {
|
||||
print("File not found")
|
||||
} catch {
|
||||
print("Other error: \(error)")
|
||||
}
|
||||
```
|
||||
|
||||
## Detailed design
|
||||
|
||||
See the **Appendix** section at the end of this proposal for a table view of Swift API to C mappings.
|
||||
|
||||
All APIs will be marked `@export(implementation)` for performance, except `StatFS`'s `==` and `hash(into:)`, and descriptions, which are ordinary `public` APIs. Until the package requires Swift 6.4, the implementation will use the equivalent `@_alwaysEmitIntoClient` instead.
|
||||
|
||||
### `MountFlags`
|
||||
|
||||
This proposal introduces a `MountFlags` type representing flags that could be present in a `statfs` struct. On Darwin and BSD, many of these flags could also be passed to a future implementation of `mount`, though some, like `local` and `rootFileSystem`, only describe state the kernel reports. (Linux `mount(2)` instead takes a separate `MS_*` set, distinct from the `ST_*` flags `statfs` reports.) Mount-specific flags are outside the scope of this proposal (see **Future directions**).
|
||||
|
||||
`MountFlags` uses a `CInterop` typealias for its `rawValue` to support different widths of integers used on different operating systems. On Linux and Android, `CInterop.MountFlags` is `CUnsignedLong` rather than the type of `f_flags`, which varies by C library (glibc's is a signed `long`).
|
||||
|
||||
Glibc and musl also define `ST_WRITE`, `ST_APPEND`, and `ST_IMMUTABLE`, but Linux never reports them in `f_flags`, so `MountFlags` omits them. For space, doc comments are omitted for flags that aren't available on Darwin.
|
||||
|
||||
```swift
|
||||
/// Flags describing a mounted file system.
|
||||
///
|
||||
/// These are the flags reported in the `f_flags` field of a `statfs` struct.
|
||||
/// Some reflect options employed when mounting the file system, while others,
|
||||
/// like `local` and `rootFileSystem`, describe state the kernel reports.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
@frozen
|
||||
public struct MountFlags: OptionSet, Sendable, Hashable, Codable {
|
||||
/// The raw C flags.
|
||||
public let rawValue: CInterop.MountFlags
|
||||
|
||||
/// Creates a strongly-typed `MountFlags` from the raw C value.
|
||||
public init(rawValue: CInterop.MountFlags)
|
||||
|
||||
// Flags available on all platforms
|
||||
|
||||
/// The file system is mounted read-only, even for the super-user.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_RDONLY` on Darwin and BSD,
|
||||
/// or `ST_RDONLY` otherwise.
|
||||
public static var readOnly: MountFlags { get }
|
||||
|
||||
/// The file system is written to synchronously.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_SYNCHRONOUS` on Darwin and BSD,
|
||||
/// or `ST_SYNCHRONOUS` otherwise.
|
||||
public static var synchronous: MountFlags { get }
|
||||
|
||||
/// Programs may not be executed from the file system.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOEXEC` on Darwin and BSD,
|
||||
/// or `ST_NOEXEC` otherwise.
|
||||
public static var noExecution: MountFlags { get }
|
||||
|
||||
/// Set-user-ID and set-group-ID (setuid and setgid) bits are not honored on
|
||||
/// the file system.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOSUID` on Darwin and BSD,
|
||||
/// or `ST_NOSUID` otherwise.
|
||||
public static var noSetUserID: MountFlags { get }
|
||||
|
||||
/// Access times are not updated on the file system.
|
||||
///
|
||||
/// - Note: On OpenBSD, access time may still be updated when the
|
||||
/// modification or status-change time is also being updated.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOATIME` on Darwin and BSD,
|
||||
/// or `ST_NOATIME` otherwise.
|
||||
public static var noAccessTime: MountFlags { get }
|
||||
|
||||
// Flags available on all platforms except FreeBSD
|
||||
|
||||
#if !os(FreeBSD)
|
||||
/// Special files may not be interpreted on the file system.
|
||||
///
|
||||
/// - Note: Not available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NODEV` on Darwin and OpenBSD,
|
||||
/// or `ST_NODEV` otherwise.
|
||||
public static var noDevices: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on Linux and Android
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
public static var mandatoryLocking: MountFlags { get }
|
||||
public static var noDirectoryAccessTime: MountFlags { get }
|
||||
public static var relativeAccessTime: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on Linux, Android, and FreeBSD
|
||||
|
||||
#if os(Linux) || os(Android) || os(FreeBSD)
|
||||
public static var noSymlinkFollowing: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on Darwin, FreeBSD, and OpenBSD
|
||||
|
||||
#if os(anyAppleOS) || os(FreeBSD) || os(OpenBSD)
|
||||
/// The file system is written to asynchronously.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_ASYNC`.
|
||||
public static var asynchronous: MountFlags { get }
|
||||
|
||||
/// The file system is exported for use over the network via NFS.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_EXPORTED`.
|
||||
public static var exported: MountFlags { get }
|
||||
|
||||
/// The file system is stored locally, rather than being accessed over a network.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_LOCAL`.
|
||||
public static var local: MountFlags { get }
|
||||
|
||||
/// Quotas are enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_QUOTA`.
|
||||
public static var quotasEnabled: MountFlags { get }
|
||||
|
||||
/// The file system is the root file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_ROOTFS`.
|
||||
public static var rootFileSystem: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on Darwin and FreeBSD
|
||||
|
||||
#if os(anyAppleOS) || os(FreeBSD)
|
||||
/// The file system is unioned with the underlying file system, rather than
|
||||
/// obscuring it.
|
||||
///
|
||||
/// - Note: Only available on Darwin and FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_UNION`.
|
||||
public static var union: MountFlags { get }
|
||||
|
||||
/// The file system was mounted by the automounter.
|
||||
///
|
||||
/// - Note: Only available on Darwin and FreeBSD. See `automount(8)`.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_AUTOMOUNTED`.
|
||||
public static var automounted: MountFlags { get }
|
||||
|
||||
/// The file system maintains Mandatory Access Control (MAC) labels for
|
||||
/// individual objects.
|
||||
///
|
||||
/// - Note: Only available on Darwin and FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_MULTILABEL`.
|
||||
public static var multiLabel: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on FreeBSD and OpenBSD
|
||||
|
||||
#if os(FreeBSD) || os(OpenBSD)
|
||||
public static var exportedReadOnly: MountFlags { get }
|
||||
public static var exportedByDefault: MountFlags { get }
|
||||
public static var exportedAnonymously: MountFlags { get }
|
||||
public static var softUpdates: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on Darwin only
|
||||
|
||||
#if os(anyAppleOS)
|
||||
/// Per-file encrypted data protection is enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_CPROTECT`.
|
||||
public static var contentProtection: MountFlags { get }
|
||||
|
||||
/// The file system resides on removable media.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_REMOVABLE`.
|
||||
public static var removable: MountFlags { get }
|
||||
|
||||
/// The file system is quarantined.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_QUARANTINE`.
|
||||
public static var quarantined: MountFlags { get }
|
||||
|
||||
/// The file system supports volfs.
|
||||
///
|
||||
/// - Note: Only available on Darwin. Deprecated since Mac OS X 10.5.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_DOVOLFS`.
|
||||
public static var supportsVolfs: MountFlags { get }
|
||||
|
||||
/// The file system should not be presented to the user for browsing
|
||||
/// (e.g. hidden in Finder).
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_DONTBROWSE`.
|
||||
public static var noBrowsing: MountFlags { get }
|
||||
|
||||
/// The file system ignores ownership information.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_IGNORE_OWNERSHIP`.
|
||||
public static var ignoresOwnership: MountFlags { get }
|
||||
|
||||
/// The file system is journaled.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_JOURNALED`.
|
||||
public static var journaled: MountFlags { get }
|
||||
|
||||
/// User extended attributes are not allowed on the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOUSERXATTR`.
|
||||
public static var noUserExtendedAttributes: MountFlags { get }
|
||||
|
||||
/// The file system defers writes.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_DEFWRITE`.
|
||||
public static var defersWrites: MountFlags { get }
|
||||
|
||||
/// Symbolic links are not followed when resolving the mount point.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOFOLLOW`.
|
||||
public static var noSymlinkFollowingAtMountPoint: MountFlags { get }
|
||||
|
||||
/// The file system is a snapshot.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_SNAPSHOT`.
|
||||
public static var snapshot: MountFlags { get }
|
||||
|
||||
/// Access times are always updated when files are read. Without this flag,
|
||||
/// the file system may skip some access time updates for performance.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_STRICTATIME`.
|
||||
public static var strictAccessTime: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on FreeBSD only
|
||||
|
||||
#if os(FreeBSD)
|
||||
public static var exportedWithKerberos: MountFlags { get }
|
||||
public static var exportedPublicly: MountFlags { get }
|
||||
public static var posixACLs: MountFlags { get }
|
||||
public static var geomJournaled: MountFlags { get }
|
||||
public static var excludedFromDiskFreeReports: MountFlags { get }
|
||||
public static var nfs4ACLs: MountFlags { get }
|
||||
public static var noClusteredReads: MountFlags { get }
|
||||
public static var noClusteredWrites: MountFlags { get }
|
||||
public static var setUserIDDirectories: MountFlags { get }
|
||||
public static var softUpdatesJournaling: MountFlags { get }
|
||||
public static var untrusted: MountFlags { get }
|
||||
public static var userMounted: MountFlags { get }
|
||||
public static var verified: MountFlags { get }
|
||||
#endif
|
||||
|
||||
// Flags available on OpenBSD only
|
||||
|
||||
#if os(OpenBSD)
|
||||
public static var noPermissionChecks: MountFlags { get }
|
||||
public static var writeExecuteAllowed: MountFlags { get }
|
||||
#endif
|
||||
}
|
||||
|
||||
extension MountFlags: CustomStringConvertible, CustomDebugStringConvertible {
|
||||
/// A textual representation of the mount flags.
|
||||
public var description: String { get }
|
||||
|
||||
/// A textual representation of the mount flags, suitable for debugging.
|
||||
public var debugDescription: String { get }
|
||||
}
|
||||
```
|
||||
|
||||
Like `FilePermissions`, `MountFlags` describes itself by listing its flags, such as `[.readOnly, .local]`.
|
||||
|
||||
### `FileSystemID`, `FileSystemType`, `FileSystemSubtype`, and `FileSystemTypeName`
|
||||
|
||||
```swift
|
||||
/// A Swift wrapper of the C `f_fsid` file system ID found in a `statfs`
|
||||
/// struct.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
@frozen
|
||||
public struct FileSystemID: RawRepresentable, Sendable, Hashable, Codable {
|
||||
/// The raw C file system ID.
|
||||
public var rawValue: CInterop.FileSystemID
|
||||
|
||||
/// Creates a strongly-typed `FileSystemID` from the raw C value.
|
||||
public init(rawValue: CInterop.FileSystemID)
|
||||
|
||||
/// Creates a strongly-typed `FileSystemID` from the raw C value.
|
||||
public init(_ rawValue: CInterop.FileSystemID)
|
||||
}
|
||||
|
||||
extension FileSystemID: CustomStringConvertible, CustomDebugStringConvertible {
|
||||
/// A textual representation of the file system ID.
|
||||
public var description: String { get }
|
||||
|
||||
/// A textual representation of the file system ID, suitable for debugging.
|
||||
public var debugDescription: String { get }
|
||||
}
|
||||
|
||||
// `FileSystemType` is available on Linux and Android, where `f_type` is the
|
||||
// file system's magic number. Darwin and FreeBSD report a kernel-assigned
|
||||
// index in `f_type`, so `typeName` identifies the file system there instead.
|
||||
// `FileSystemSubtype` is Darwin-only. Both fit in a `UInt32` on every platform
|
||||
// that provides them, so no `CInterop` typealias is needed.
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
/// A Swift wrapper of the C `f_type` file system type found in a `statfs`
|
||||
/// struct.
|
||||
///
|
||||
/// - Note: Only available on Linux and Android.
|
||||
@frozen
|
||||
public struct FileSystemType: RawRepresentable, Sendable, Hashable, Codable {
|
||||
/// The raw C file system type.
|
||||
public var rawValue: UInt32
|
||||
|
||||
/// Creates a strongly-typed `FileSystemType` from the raw C value.
|
||||
public init(rawValue: UInt32)
|
||||
|
||||
/// Creates a strongly-typed `FileSystemType` from the raw C value.
|
||||
public init(_ rawValue: UInt32)
|
||||
}
|
||||
#endif
|
||||
|
||||
#if os(anyAppleOS)
|
||||
/// A Swift wrapper of the C `f_fssubtype` file system subtype found in a
|
||||
/// `statfs` struct on Darwin.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
@frozen
|
||||
public struct FileSystemSubtype: RawRepresentable, Sendable, Hashable, Codable {
|
||||
/// The raw C file system subtype.
|
||||
public var rawValue: UInt32
|
||||
|
||||
/// Creates a strongly-typed `FileSystemSubtype` from the raw C value.
|
||||
public init(rawValue: UInt32)
|
||||
|
||||
/// Creates a strongly-typed `FileSystemSubtype` from the raw C value.
|
||||
public init(_ rawValue: UInt32)
|
||||
}
|
||||
#endif
|
||||
|
||||
#if os(anyAppleOS) || os(FreeBSD) || os(OpenBSD)
|
||||
/// A Swift wrapper of the C `f_fstypename` file system type name found in a
|
||||
/// `statfs` struct.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
@frozen
|
||||
public struct FileSystemTypeName: RawRepresentable, Sendable, Hashable, Codable, ExpressibleByStringLiteral {
|
||||
/// The raw file system type name.
|
||||
public var rawValue: String
|
||||
|
||||
/// Creates a strongly-typed `FileSystemTypeName` from the raw name.
|
||||
public init(rawValue: String)
|
||||
|
||||
/// Creates a strongly-typed `FileSystemTypeName` from the raw name.
|
||||
public init(_ rawValue: String)
|
||||
|
||||
/// Creates a `FileSystemTypeName` from a string literal, such as `"apfs"`.
|
||||
public init(stringLiteral value: String)
|
||||
|
||||
// Type names available on Darwin only
|
||||
|
||||
#if os(anyAppleOS)
|
||||
/// The Apple File System (APFS).
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding `f_fstypename` value is `"apfs"`.
|
||||
public static var apfs: FileSystemTypeName { get }
|
||||
|
||||
/// The Mac OS Extended file system (HFS Plus).
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding `f_fstypename` value is `"hfs"`.
|
||||
public static var hfs: FileSystemTypeName { get }
|
||||
#endif
|
||||
}
|
||||
|
||||
extension FileSystemTypeName: CustomStringConvertible, CustomDebugStringConvertible {
|
||||
/// The file system type name, such as `apfs`.
|
||||
public var description: String { get }
|
||||
|
||||
/// The file system type name as a quoted string, such as `"apfs"`.
|
||||
public var debugDescription: String { get }
|
||||
}
|
||||
#endif
|
||||
```
|
||||
|
||||
`CInterop.FileSystemID` is the C `fsid_t` struct (a fixed two-element `int32_t` array), which provides no synthesized conformances. `FileSystemID` implements `Equatable`, `Hashable`, and `Codable` manually in terms of its elements, named `val` on Darwin and BSD and `__val` on Linux and Android. It encodes them as an unkeyed container of two `Int32` values and describes itself by listing them, such as `FileSystemID(16777239, 26)`.
|
||||
|
||||
`FileSystemTypeName` wraps `f_fstypename` so that well-known type names can be offered as constants, such as `.apfs`. It conforms to `ExpressibleByStringLiteral` so comparisons against names without a constant like `statfs.typeName == "nfs"` still read naturally. This proposal only provides constants for `"apfs"` and `"hfs"`. Other names can be added in the future when their stability is confirmed.
|
||||
|
||||
### `StatFS`
|
||||
|
||||
`StatFS` offers initializers that accept a `FilePath`, null-terminated `UnsafePointer<CChar>`, or `FileDescriptor`.
|
||||
|
||||
The underlying C fields for each numeric property vary in signedness and width across platforms. Rather than create a platform-dependent type for each, we choose one fixed integer type per property — `Int` or `UInt64` — and clamp when getting or setting the value.
|
||||
|
||||
Block sizes and lengths (`blockSize`, `preferredIOBlockSize`, `fragmentSize`, and `maximumNameLength`) are exposed as `Int`. Most modern file systems report 4KiB block sizes by default, and in practice, the highest value seen on specialized (often network) file systems is on the order of 1MiB. The preferred I/O size could similarly reach values around 16MiB. These are still orders of magnitude smaller than `Int.max`, even for 32-bit platforms.
|
||||
|
||||
Block and inode counts, and the space values computed from them, are exposed as `UInt64` to preserve their full unsigned range on every platform. Real-world values can exceed `Int64.max`, and space computations can overflow and saturate to `UInt64.max`. Clamping lets us report `0` for the signed "available to non-superuser" counts that some BSDs allow to go negative.
|
||||
|
||||
```swift
|
||||
/// A Swift wrapper of the C `statfs` struct.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
/// - Note: The numeric properties clamp when converting to or from the
|
||||
/// underlying C field. Use `rawValue` for exact, unclamped access.
|
||||
@frozen
|
||||
public struct StatFS: RawRepresentable, Sendable, Hashable {
|
||||
/// The raw C `statfs` struct.
|
||||
public var rawValue: CInterop.StatFS
|
||||
|
||||
/// Creates a Swift `StatFS` from the raw C struct.
|
||||
public init(rawValue: CInterop.StatFS)
|
||||
|
||||
/// Creates a `StatFS` from a `FilePath`.
|
||||
///
|
||||
/// The corresponding C function is `statfs()`.
|
||||
public init(
|
||||
_ path: FilePath,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno)
|
||||
|
||||
/// Creates a `StatFS` from a null-terminated `UnsafePointer<CChar>` path.
|
||||
///
|
||||
/// The corresponding C function is `statfs()`.
|
||||
public init(
|
||||
_ path: UnsafePointer<CChar>,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno)
|
||||
|
||||
/// Creates a `StatFS` from a `FileDescriptor`.
|
||||
///
|
||||
/// The corresponding C function is `fstatfs()`.
|
||||
public init(
|
||||
_ fd: FileDescriptor,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno)
|
||||
|
||||
/// File system block size, in bytes.
|
||||
///
|
||||
/// - Note: On Darwin and BSD, this is the fundamental size for block counts.
|
||||
/// Other platforms use `fragmentSize` (`f_frsize`) instead.
|
||||
///
|
||||
/// The corresponding C property is `f_bsize`.
|
||||
public var blockSize: Int { get set }
|
||||
|
||||
#if os(anyAppleOS) || os(FreeBSD) || os(OpenBSD)
|
||||
/// Block size for optimal data transfer, in bytes.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_iosize`.
|
||||
public var preferredIOBlockSize: Int { get set }
|
||||
#else
|
||||
/// File system fragment size, in bytes.
|
||||
///
|
||||
/// - Note: On Linux and Android, this is the fundamental size for block
|
||||
/// counts. Not present on Darwin or BSD, which use `blockSize` instead.
|
||||
///
|
||||
/// The corresponding C property is `f_frsize`.
|
||||
public var fragmentSize: Int { get set }
|
||||
#endif
|
||||
|
||||
/// Total number of blocks in the file system.
|
||||
///
|
||||
/// - Note: In units of `blockSize` on Darwin and BSD, or `fragmentSize`
|
||||
/// otherwise.
|
||||
///
|
||||
/// The corresponding C property is `f_blocks`.
|
||||
public var totalBlocks: UInt64 { get set }
|
||||
|
||||
/// Total size of the file system, in bytes.
|
||||
///
|
||||
/// - Note: Computed for convenience as `totalBlocks` times the fundamental
|
||||
/// block size (see `totalBlocks`). Saturates to `UInt64.max` on overflow.
|
||||
public var totalSpace: UInt64 { get }
|
||||
|
||||
/// Number of free blocks in the file system.
|
||||
///
|
||||
/// - Note: In units of `blockSize` on Darwin and BSD, or `fragmentSize`
|
||||
/// otherwise.
|
||||
///
|
||||
/// The corresponding C property is `f_bfree`.
|
||||
public var freeBlocks: UInt64 { get set }
|
||||
|
||||
/// Free space in the file system, in bytes.
|
||||
///
|
||||
/// - Note: Computed for convenience as `freeBlocks` times the fundamental
|
||||
/// block size (see `freeBlocks`). Saturates to `UInt64.max` on overflow.
|
||||
public var freeSpace: UInt64 { get }
|
||||
|
||||
/// Number of free blocks available to non-superuser.
|
||||
///
|
||||
/// - Note: In units of `blockSize` on Darwin and BSD, or `fragmentSize`
|
||||
/// otherwise. On FreeBSD and OpenBSD, the underlying C property is
|
||||
/// signed; negative values are clamped to 0.
|
||||
///
|
||||
/// The corresponding C property is `f_bavail`.
|
||||
public var availableBlocks: UInt64 { get set }
|
||||
|
||||
/// Available space in the file system for non-superuser, in bytes.
|
||||
///
|
||||
/// - Note: Computed for convenience as `availableBlocks` times the fundamental
|
||||
/// block size (see `availableBlocks`). Saturates to `UInt64.max` on overflow.
|
||||
public var availableSpace: UInt64 { get }
|
||||
|
||||
/// Total number of inodes in the file system.
|
||||
///
|
||||
/// The corresponding C property is `f_files`.
|
||||
public var totalInodes: UInt64 { get set }
|
||||
|
||||
/// Number of free inodes in the file system.
|
||||
///
|
||||
/// - Note: On FreeBSD, this reports the inodes available to a non-superuser
|
||||
/// rather than the total free count, and the underlying C field is signed
|
||||
/// (negative values are clamped to 0); on other platforms, it is the total
|
||||
/// number of free inodes.
|
||||
///
|
||||
/// The corresponding C property is `f_ffree`.
|
||||
public var freeInodes: UInt64 { get set }
|
||||
|
||||
#if os(OpenBSD)
|
||||
/// Number of free inodes available to non-superuser.
|
||||
///
|
||||
/// - Note: Darwin, FreeBSD, Linux, and Android `statfs` do not report it.
|
||||
/// On OpenBSD, the underlying C property is signed; negative values are
|
||||
/// clamped to 0.
|
||||
///
|
||||
/// The corresponding C property is `f_favail`.
|
||||
public var availableInodes: UInt64 { get set }
|
||||
#endif
|
||||
|
||||
#if !os(anyAppleOS)
|
||||
/// Maximum length of a file name on the file system, in bytes.
|
||||
///
|
||||
/// - Note: Darwin's `statfs` does not report it.
|
||||
///
|
||||
/// The corresponding C property is `f_namelen` on Linux and Android, or
|
||||
/// `f_namemax` otherwise.
|
||||
public var maximumNameLength: Int { get set }
|
||||
#endif
|
||||
|
||||
/// File system ID.
|
||||
///
|
||||
/// The corresponding C property is `f_fsid`.
|
||||
public var fileSystemID: FileSystemID { get set }
|
||||
|
||||
/// Flags describing how the file system is mounted.
|
||||
///
|
||||
/// - Note: On Linux, the kernel also sets an `ST_VALID` bit in `f_flags`
|
||||
/// to mark the field as filled in. It isn't a mount flag, so this
|
||||
/// property omits it like glibc's `statvfs` and Bionic's `statfs` do.
|
||||
/// The setter preserves it.
|
||||
///
|
||||
/// The corresponding C property is `f_flags`.
|
||||
public var mountFlags: MountFlags { get set }
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
/// File system type.
|
||||
///
|
||||
/// - Note: This is the file system's magic number, such as `0xEF53` for
|
||||
/// ext4. Only available on Linux and Android. On Darwin and BSD, use
|
||||
/// `typeName` to identify the file system.
|
||||
///
|
||||
/// The corresponding C property is `f_type`.
|
||||
public var type: FileSystemType { get set }
|
||||
#endif
|
||||
|
||||
#if os(anyAppleOS)
|
||||
/// File system subtype.
|
||||
///
|
||||
/// - Note: This is a numeric value whose meaning depends on `typeName`,
|
||||
/// with no stable, public constants. Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C property is `f_fssubtype`.
|
||||
public var subtype: FileSystemSubtype { get set }
|
||||
#endif
|
||||
|
||||
#if os(anyAppleOS) || os(FreeBSD) || os(OpenBSD)
|
||||
/// User that mounted the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_owner`.
|
||||
public var owner: UserID { get set }
|
||||
|
||||
/// File system type name, such as "apfs".
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_fstypename`.
|
||||
public var typeName: FileSystemTypeName { get }
|
||||
|
||||
/// Directory where the file system is mounted, such as "/System/Volumes/Data".
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_mntonname`.
|
||||
public var mountPoint: FilePath { get }
|
||||
|
||||
/// The source of the mounted file system, such as "/dev/disk3s7".
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_mntfromname`.
|
||||
public var mountSource: FilePath { get }
|
||||
#endif
|
||||
|
||||
/// Compares the file system metadata fields of two `StatFS` values,
|
||||
/// including fields not exposed as properties, such as `f_flags_ext` on
|
||||
/// Darwin.
|
||||
///
|
||||
/// Fields are compared by their raw C values. Reserved/"spare" fields and
|
||||
/// OpenBSD's `mount_info` union are not compared. Name buffers are compared
|
||||
/// only up to their NUL terminators.
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool
|
||||
|
||||
/// Hashes the file system metadata fields of a `StatFS` struct.
|
||||
///
|
||||
/// These are the same fields compared by `==`. Reserved/"spare" fields are
|
||||
/// not hashed, and name buffers are hashed only up to their NUL terminators.
|
||||
public func hash(into hasher: inout Hasher)
|
||||
}
|
||||
```
|
||||
|
||||
`typeName`, `mountPoint`, and `mountSource` are get-only because they are backed by fixed-size C character buffers, which a non-throwing setter could not safely fill without risking silent truncation. Callers that need to write these fields can do so through `rawValue` directly.
|
||||
|
||||
`StatFS` conforms to `Hashable` (and therefore `Equatable`) by comparing and hashing the raw values of its C fields, as `Stat` does, so two `StatFS` values are equal when their `rawValue`s match in every meaningful field. Comparing the clamped properties instead would treat different raw values like two negative `f_bavail` counts as equal, and would ignore fields without a property. A byte-wise comparison would be unreliable because the bytes following each name buffer's NUL terminator are unspecified, and the struct may carry reserved/spare padding.
|
||||
|
||||
### CInterop extensions
|
||||
|
||||
This proposal extends the existing `CInterop` namespace with platform-appropriate typealiases for the underlying C types. Each is used as the `rawValue` for a corresponding strongly-typed representation.
|
||||
|
||||
```swift
|
||||
extension CInterop {
|
||||
/// The C `statfs` struct.
|
||||
public typealias StatFS = statfs
|
||||
|
||||
public typealias FileSystemID = fsid_t
|
||||
|
||||
#if os(anyAppleOS) || os(OpenBSD)
|
||||
public typealias MountFlags = UInt32
|
||||
#elseif os(FreeBSD)
|
||||
public typealias MountFlags = UInt64
|
||||
#else
|
||||
public typealias MountFlags = CUnsignedLong
|
||||
#endif
|
||||
}
|
||||
```
|
||||
|
||||
All three have the same availability as the rest of this proposal.
|
||||
|
||||
### Vending `struct statfs` on glibc platforms
|
||||
|
||||
Unlike the Musl and Android modules, Swift's Glibc module doesn't export `<sys/vfs.h>`, which declares `struct statfs`. On glibc platforms, System therefore vends `struct statfs` from a new module, `CSystemStatFS`, that contains only this header, and re-exports it so clients can access `rawValue`'s fields under `MemberImportVisibility`. As a result, importing System on glibc platforms also brings C's `statfs()` and `fstatfs()` into scope. The Glibc module does export `fsid_t`, so accessing the `__val` field of a `CInterop.FileSystemID` under `MemberImportVisibility` requires importing Glibc.
|
||||
|
||||
### Availability on Windows and WASI
|
||||
|
||||
Windows has no `statfs`/`statvfs`. Rather than omit the type there, where usage would fail with an unhelpful `cannot find 'StatFS' in scope`, we declare an unavailable stub with a message suggesting the relevant Win32 APIs. In the future, the message could suggest dedicated System APIs instead.
|
||||
|
||||
`wasi-libc` has no `statfs`, and in the current `wasi-libc`, `statvfs` and `fstatvfs` are unconditional stubs (in `libc-bottom-half/sources/posix.c`) that set `errno` to `ENOSYS` and return `-1`:
|
||||
|
||||
```c
|
||||
int statvfs(const char *__restrict path, struct statvfs *__restrict buf) {
|
||||
// TODO: We plan to support this eventually in WASI, but not yet.
|
||||
errno = ENOSYS;
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
As a result, `StatFS` initializers would always fail at runtime on WASI and throw `Errno.noFunction`, so WASI gets an unavailable stub as well.
|
||||
|
||||
```swift
|
||||
#if os(Windows)
|
||||
@available(Windows, unavailable, message: "Consider using a Win32 API such as GetVolumeInformationW or GetDiskFreeSpaceExW instead.")
|
||||
public struct StatFS {
|
||||
public init(_ path: FilePath, retryOnInterrupt: Bool = true) throws(Errno)
|
||||
public init(_ path: UnsafePointer<CChar>, retryOnInterrupt: Bool = true) throws(Errno)
|
||||
public init(_ fd: FileDescriptor, retryOnInterrupt: Bool = true) throws(Errno)
|
||||
}
|
||||
#elseif os(WASI)
|
||||
@available(*, unavailable, message: "wasi-libc doesn't implement statfs or statvfs.")
|
||||
public struct StatFS {
|
||||
// The same three initializers
|
||||
}
|
||||
#else
|
||||
// ...
|
||||
#endif
|
||||
```
|
||||
|
||||
Marking the type covers the three throwing initializers each stub declares. The other types and `CInterop` additions in this proposal aren't declared on either platform.
|
||||
|
||||
## Source compatibility
|
||||
|
||||
This proposal is additive, but on glibc platforms, clients that already vend `struct statfs` from their own module (since Swift's Glibc module doesn't export it) may need to import both that module and System in each file that accesses `statfs` fields. When two modules declare the same C struct, `MemberImportVisibility` attributes its fields to the module the compiler reaches the struct through first, which can differ between debug and release builds. In testing, a client that used `StatFS.rawValue` in one file and its own module's `statfs` in another built in debug but failed in release, reporting a missing import of `CSystemStatFS`.
|
||||
|
||||
## ABI compatibility
|
||||
|
||||
This proposal is additive and ABI-compatible with existing code.
|
||||
|
||||
## Implications on adoption
|
||||
|
||||
This feature can be freely adopted and un-adopted in source code with no deployment constraints and without affecting source or ABI compatibility.
|
||||
|
||||
## Future directions
|
||||
|
||||
To remain faithful to the underlying system calls, we don't anticipate extending `StatFS`. However, the types introduced in this proposal could serve as the foundation of broader file system APIs in Swift.
|
||||
|
||||
For instance, on Darwin and BSD, `MountFlags` could be useful for a future `mount()` implementation, and a future Swift wrapper of `getfsstat()` could return an array of `StatFS` structs.
|
||||
|
||||
A Linux `mount(2)` wrapper would look different. There, the flags `statfs` reports (`ST_*`) are a distinct set from the flags `mount(2)` accepts (`MS_*`), so a mount wrapper would need its own input type rather than reusing `MountFlags`. The `MS_*` set also mixes per-mount options with operation selectors like bind, move, remount, and propagation changes, so an idiomatic wrapper would likely split these into separate functions. A new implementation might also prefer the newer `fsopen` / `fsmount` / `move_mount` family over classic `mount(2)`. Because Linux's `mount` signature differs from Darwin's and BSD's, any such wrapper would be platform-specific.
|
||||
|
||||
Once `wasi-libc` implements `statvfs`, a future proposal could make `StatFS` available on WASI by wrapping `statvfs` and `fstatvfs`.
|
||||
|
||||
On Darwin, `f_flags_ext` reports extended flags such as `MNT_EXT_ROOT_DATA_VOL` and `MNT_EXT_FSKIT`. They're reachable through `rawValue` today, and a future proposal could expose them as their own option set.
|
||||
|
||||
If Swift's Glibc module exports `<sys/vfs.h>` in the future, `CSystemStatFS` would become redundant. System could keep re-exporting it, but accessing `rawValue`'s fields under `MemberImportVisibility` would then require importing Glibc, as with `CInterop.Stat`.
|
||||
|
||||
While this proposal does not include `StatFS` on Windows, SYS-0017 proposes `volumeInformation()` on `Win32.FileHandle`, a Swift-native wrapper of `GetVolumeInformationByHandleW`. Other volume APIs, such as `GetDiskFreeSpaceExW` and `DeviceIoControl`, could follow with their associated types.
|
||||
|
||||
A more general `FileSystemInfo` API could then build on these OS-specific types to provide an ergonomic, cross-platform abstraction for file system metadata. These future cross-platform APIs might be better implemented outside of System, such as in Foundation or another dedicated package.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
### `FileSystemInfo` as the lowest-level type
|
||||
|
||||
An alternative approach could be to have a more general `FileSystemInfo` type be the lowest level of abstraction provided by the System library. This type would then handle all the `statfs` or Windows-specific struct storage and accessors. However, this alternative:
|
||||
|
||||
- Is inconsistent with System's philosophy of providing low-level system abstractions.
|
||||
- Introduces an even larger number of system-specific APIs on each type.
|
||||
- Misses out on the familiarity of the `statfs` name. Developers know what to look for and what to expect from this type.
|
||||
|
||||
### Single combined type for both file and file system metadata
|
||||
|
||||
Combining `Stat` ([SYS-0006](https://github.com/apple/swift-system/blob/main/Proposals/0006-system-stat.md)) and `StatFS` into a single type was considered but rejected because file and file system information serve different purposes and are typically needed in different contexts. Storing and/or initializing both `stat` and `statfs` structs unnecessarily reduces performance when one isn't needed.
|
||||
|
||||
### Separate `StatFS` and `StatVFS` types
|
||||
|
||||
Having separate types for `statfs` and `statvfs` would increase cognitive overhead and confusion for developers deciding which to choose. It would require additional documentation explaining differences that are transparently handled by platform availability, and would require duplicate code. On operating systems where `statfs` exposes additional information, such as Darwin, FreeBSD, and Linux, `statvfs` is just a wrapper around `statfs`, so there's little upside to providing a `StatVFS` type here. One upside might be that all properties of `StatVFS` would be available where the struct itself is available, but this likely doesn't outweigh the cost of having two types.
|
||||
|
||||
### Use `statvfs` on Linux and Android
|
||||
|
||||
`statvfs` is the POSIX interface, and the Glibc, Musl, and Android modules all export it, so System wouldn't need a `CSystemStatFS` module, which can conflict with clients' own `statfs` modules (see **Source compatibility**). However, on Linux, `statvfs` is also a wrapper around `statfs`, and it drops useful information: 1) with Bionic or glibc before 2.39, `f_type`, the file system magic number (such as `0xEF53` for ext4) that Linux code conventionally uses to identify a file system is absent; and 2) with musl or 32-bit platforms, half of the 2-word `fsid_t` is omitted. `statvfs`'s only extra field, `f_favail`, is a copy of `f_ffree` in glibc, musl, and Bionic.
|
||||
|
||||
### Add `statfs()` methods to `FilePath` and `FileDescriptor`
|
||||
|
||||
Like `FilePath.stat()` and `FileDescriptor.stat()` in [SYS-0006](https://github.com/apple/swift-system/blob/main/Proposals/0006-system-stat.md), `StatFS` could offer `statfs()` methods alongside its initializers. However, `statfs` describes the file system containing a file rather than the file itself, so it's not as closely tied to the individual `FilePath` or `FileDescriptor`. The proposed initializers can still chain, as in `try StatFS(path).availableSpace`.
|
||||
|
||||
The methods would also shadow the C `statfs` struct initializer and function inside extensions of those types, so existing code that calls them unqualified there would no longer compile. [SYS-0008](0008-backdeploy-cinterop-stat.md) back-deployed `CInterop.stat(_:_:)` as a migration path for the same issue with `stat()`. Leaving out the methods avoids the break and the need for new `CInterop` APIs. They could always be added later, along with a migration path, if desired.
|
||||
|
||||
### Expose `type` and `subtype` as raw integers
|
||||
|
||||
`FileSystemType` and `FileSystemSubtype` wrap `UInt32` values that, except for Linux magic numbers, have no stable, public constants, so exposing `type` and `subtype` as bare `UInt32` was considered. We keep the wrapper types for fidelity to the underlying struct and for consistency with `FileSystemID`, which is similarly opaque. The wrappers also give these fields distinct types, avoiding accidental cross-comparisons and granting flexibility to add members later, if desired.
|
||||
|
||||
### Expose `typeName` as a `String`
|
||||
|
||||
`typeName` could be a `String` like Foundation's `volumeTypeName` resource value. Unlike Linux magic numbers, type names are already readable, so `typeName == "apfs"` works about as well as a constant would. However, a wrapper allows us to provide constants like `.apfs`, which help with discoverability and avoid mistakes like comparing against `"APFS"`. And `ExpressibleByStringLiteral` allows us to still keep the ergonomics of literal comparison.
|
||||
|
||||
### Make `StatFS` available on WASI
|
||||
|
||||
`StatFS` could wrap `statvfs` and `fstatvfs` on WASI, as v1 of this proposal did. This would let developers write code that is otherwise portable across Unix-like platforms, and since clients calling `try StatFS(...)` are expected to handle a potential `Errno`, the always-failing calls wouldn't degrade ergonomics. It would also keep the availability coupled: once `wasi-libc` gains real `statvfs` support, System would pick it up automatically without needing to track it.
|
||||
|
||||
However, the portability would only be at compile time, since every call would throw `Errno.noFunction`. The WASI mappings, such as reading `mountFlags` from `f_flag` and an integer `FileSystemID` that other platforms can't decode, would also be designed against `wasi-libc`'s stubs. Leaving WASI out also lets `StatFS` wrap `statfs` on every platform where it's available, instead of `statvfs` on WASI alone. Making `StatFS` available later is additive, while reshaping it after it ships would be source-breaking.
|
||||
|
||||
## Acknowledgments
|
||||
|
||||
Thank you to Michael Ilseman for discussions on the shape and future directions of this API.
|
||||
|
||||
## Appendix
|
||||
|
||||
### Swift API to C mapping
|
||||
|
||||
The following tables show the mapping between Swift APIs and their underlying C system calls across different operating systems:
|
||||
|
||||
#### `StatFS` function mappings
|
||||
|
||||
The `retryOnInterrupt: Bool = true` parameter is omitted for clarity.
|
||||
|
||||
| Swift API | Darwin / BSD / Linux / Android |
|
||||
|-----------|--------------------------------|
|
||||
| `StatFS(_ path: UnsafePointer<CChar>)` | `statfs()` |
|
||||
| `StatFS(_ path: FilePath)` | `statfs()` |
|
||||
| | |
|
||||
| `StatFS(_ fd: FileDescriptor)` | `fstatfs()` |
|
||||
|
||||
#### `StatFS` property mappings
|
||||
|
||||
`"` denotes the same property name across all operating systems.
|
||||
|
||||
| Swift Property | Darwin | FreeBSD | OpenBSD | Linux | Android |
|
||||
|----------------|--------|---------|---------|-------|---------|
|
||||
| `blockSize` | `f_bsize` | " | " | " | " |
|
||||
| `preferredIOBlockSize` | `f_iosize` | `f_iosize` | `f_iosize` | N/A | N/A |
|
||||
| `fragmentSize` | N/A | N/A | N/A | `f_frsize` | `f_frsize` |
|
||||
| `totalBlocks` | `f_blocks` | " | " | " | " |
|
||||
| `freeBlocks` | `f_bfree` | " | " | " | " |
|
||||
| `availableBlocks` | `f_bavail` | " | " | " | " |
|
||||
| `totalInodes` | `f_files` | " | " | " | " |
|
||||
| `freeInodes` | `f_ffree` | " | " | " | " |
|
||||
| `availableInodes` | N/A | N/A | `f_favail` | N/A | N/A |
|
||||
| `maximumNameLength` | N/A | `f_namemax` | `f_namemax` | `f_namelen` | `f_namelen` |
|
||||
| `fileSystemID` | `f_fsid` | " | " | " | " |
|
||||
| `mountFlags` | `f_flags` | " | " | " | " |
|
||||
| `type` | N/A | N/A | N/A | `f_type` | `f_type` |
|
||||
| `subtype` | `f_fssubtype` | N/A | N/A | N/A | N/A |
|
||||
| `owner` | `f_owner` | `f_owner` | `f_owner` | N/A | N/A |
|
||||
| `typeName` | `f_fstypename` | `f_fstypename` | `f_fstypename` | N/A | N/A |
|
||||
| `mountPoint` | `f_mntonname` | `f_mntonname` | `f_mntonname` | N/A | N/A |
|
||||
| `mountSource` | `f_mntfromname` | `f_mntfromname` | `f_mntfromname` | N/A | N/A |
|
||||
|
||||
#### `MountFlags` mappings
|
||||
|
||||
| Swift Flag | Darwin | FreeBSD | OpenBSD | Linux | Android |
|
||||
|------------|--------|---------|---------|-------|---------|
|
||||
| `readOnly` | `MNT_RDONLY` | `MNT_RDONLY` | `MNT_RDONLY` | `ST_RDONLY` | `ST_RDONLY` |
|
||||
| `synchronous` | `MNT_SYNCHRONOUS` | `MNT_SYNCHRONOUS` | `MNT_SYNCHRONOUS` | `ST_SYNCHRONOUS` | `ST_SYNCHRONOUS` |
|
||||
| `noExecution` | `MNT_NOEXEC` | `MNT_NOEXEC` | `MNT_NOEXEC` | `ST_NOEXEC` | `ST_NOEXEC` |
|
||||
| `noSetUserID` | `MNT_NOSUID` | `MNT_NOSUID` | `MNT_NOSUID` | `ST_NOSUID` | `ST_NOSUID` |
|
||||
| `noAccessTime` | `MNT_NOATIME` | `MNT_NOATIME` | `MNT_NOATIME` | `ST_NOATIME` | `ST_NOATIME` |
|
||||
| `noDevices` | `MNT_NODEV` | N/A | `MNT_NODEV` | `ST_NODEV` | `ST_NODEV` |
|
||||
| `mandatoryLocking` | N/A | N/A | N/A | `ST_MANDLOCK` | `ST_MANDLOCK` |
|
||||
| `noDirectoryAccessTime` | N/A | N/A | N/A | `ST_NODIRATIME` | `ST_NODIRATIME` |
|
||||
| `relativeAccessTime` | N/A | N/A | N/A | `ST_RELATIME` | `ST_RELATIME` |
|
||||
| `noSymlinkFollowing` | N/A | `MNT_NOSYMFOLLOW` | N/A | `ST_NOSYMFOLLOW` | `ST_NOSYMFOLLOW` |
|
||||
| `asynchronous` | `MNT_ASYNC` | `MNT_ASYNC` | `MNT_ASYNC` | N/A | N/A |
|
||||
| `exported` | `MNT_EXPORTED` | `MNT_EXPORTED` | `MNT_EXPORTED` | N/A | N/A |
|
||||
| `local` | `MNT_LOCAL` | `MNT_LOCAL` | `MNT_LOCAL` | N/A | N/A |
|
||||
| `quotasEnabled` | `MNT_QUOTA` | `MNT_QUOTA` | `MNT_QUOTA` | N/A | N/A |
|
||||
| `rootFileSystem` | `MNT_ROOTFS` | `MNT_ROOTFS` | `MNT_ROOTFS` | N/A | N/A |
|
||||
| `union` | `MNT_UNION` | `MNT_UNION` | N/A | N/A | N/A |
|
||||
| `automounted` | `MNT_AUTOMOUNTED` | `MNT_AUTOMOUNTED` | N/A | N/A | N/A |
|
||||
| `multiLabel` | `MNT_MULTILABEL` | `MNT_MULTILABEL` | N/A | N/A | N/A |
|
||||
| `exportedReadOnly` | N/A | `MNT_EXRDONLY` | `MNT_EXRDONLY` | N/A | N/A |
|
||||
| `exportedByDefault` | N/A | `MNT_DEFEXPORTED` | `MNT_DEFEXPORTED` | N/A | N/A |
|
||||
| `exportedAnonymously` | N/A | `MNT_EXPORTANON` | `MNT_EXPORTANON` | N/A | N/A |
|
||||
| `softUpdates` | N/A | `MNT_SOFTDEP` | `MNT_SOFTDEP` | N/A | N/A |
|
||||
| `contentProtection` | `MNT_CPROTECT` | N/A | N/A | N/A | N/A |
|
||||
| `removable` | `MNT_REMOVABLE` | N/A | N/A | N/A | N/A |
|
||||
| `quarantined` | `MNT_QUARANTINE` | N/A | N/A | N/A | N/A |
|
||||
| `supportsVolfs` | `MNT_DOVOLFS` | N/A | N/A | N/A | N/A |
|
||||
| `noBrowsing` | `MNT_DONTBROWSE` | N/A | N/A | N/A | N/A |
|
||||
| `ignoresOwnership` | `MNT_IGNORE_OWNERSHIP` | N/A | N/A | N/A | N/A |
|
||||
| `journaled` | `MNT_JOURNALED` | N/A | N/A | N/A | N/A |
|
||||
| `noUserExtendedAttributes` | `MNT_NOUSERXATTR` | N/A | N/A | N/A | N/A |
|
||||
| `defersWrites` | `MNT_DEFWRITE` | N/A | N/A | N/A | N/A |
|
||||
| `noSymlinkFollowingAtMountPoint` | `MNT_NOFOLLOW` | N/A | N/A | N/A | N/A |
|
||||
| `snapshot` | `MNT_SNAPSHOT` | N/A | N/A | N/A | N/A |
|
||||
| `strictAccessTime` | `MNT_STRICTATIME` | N/A | N/A | N/A | N/A |
|
||||
| `exportedWithKerberos` | N/A | `MNT_EXKERB` | N/A | N/A | N/A |
|
||||
| `exportedPublicly` | N/A | `MNT_EXPUBLIC` | N/A | N/A | N/A |
|
||||
| `posixACLs` | N/A | `MNT_ACLS` | N/A | N/A | N/A |
|
||||
| `geomJournaled` | N/A | `MNT_GJOURNAL` | N/A | N/A | N/A |
|
||||
| `excludedFromDiskFreeReports` | N/A | `MNT_IGNORE` | N/A | N/A | N/A |
|
||||
| `nfs4ACLs` | N/A | `MNT_NFS4ACLS` | N/A | N/A | N/A |
|
||||
| `noClusteredReads` | N/A | `MNT_NOCLUSTERR` | N/A | N/A | N/A |
|
||||
| `noClusteredWrites` | N/A | `MNT_NOCLUSTERW` | N/A | N/A | N/A |
|
||||
| `setUserIDDirectories` | N/A | `MNT_SUIDDIR` | N/A | N/A | N/A |
|
||||
| `softUpdatesJournaling` | N/A | `MNT_SUJ` | N/A | N/A | N/A |
|
||||
| `untrusted` | N/A | `MNT_UNTRUSTED` | N/A | N/A | N/A |
|
||||
| `userMounted` | N/A | `MNT_USER` | N/A | N/A | N/A |
|
||||
| `verified` | N/A | `MNT_VERIFIED` | N/A | N/A | N/A |
|
||||
| `noPermissionChecks` | N/A | N/A | `MNT_NOPERM` | N/A | N/A |
|
||||
| `writeExecuteAllowed` | N/A | N/A | `MNT_WXALLOWED` | N/A | N/A |
|
||||
@@ -114,13 +114,13 @@ We maintain separate branches for each active minor version of the package:
|
||||
| swift-system 1.6.x | release/1.6.0 |
|
||||
| swift-system 1.7.x | release/1.7.0 |
|
||||
| swift-system 1.8.x | release/1.8.x |
|
||||
| swift-system 1.9.x (unreleased) | |
|
||||
| swift-system 1.9.x (unreleased) | release/1.9.x |
|
||||
|
||||
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.7.0` → `release/1.8.x` → `main`
|
||||
`release/1.8.x` → `release/1.9.x` → `main`
|
||||
|
||||
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.)
|
||||
For example, anything landing on `release/1.8.x` will eventually appear on `release/1.9.x` and finally `main` as well. There is no need to file standalone PRs for each release line. (Merges into `release/1.9.x` and `main` are performed by the [release](.github/workflows/automerge_to_release.yml) and [main](.github/workflows/automerge_to_main.yml) automergers; propagation from older release branches is performed by project maintainers.)
|
||||
|
||||
### Code of Conduct
|
||||
|
||||
|
||||
@@ -8,4 +8,7 @@ See https://swift.org/LICENSE.txt for license information
|
||||
#]]
|
||||
|
||||
add_subdirectory(CSystem)
|
||||
if(CMAKE_SYSTEM_NAME STREQUAL Linux)
|
||||
add_subdirectory(CSystemStatFS)
|
||||
endif()
|
||||
add_subdirectory(System)
|
||||
@@ -13,12 +13,9 @@ 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)
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
/*
|
||||
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__)
|
||||
@@ -1,20 +0,0 @@
|
||||
/*
|
||||
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(__FreeBSD__)
|
||||
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef O_CLOFORK
|
||||
#define COMPATIBILITY_O_CLOFORK O_CLOFORK
|
||||
#else
|
||||
#define COMPATIBILITY_O_CLOFORK 0
|
||||
#endif
|
||||
|
||||
#endif // defined(__FreeBSD__)
|
||||
@@ -1,7 +1,7 @@
|
||||
/*
|
||||
This source file is part of the Swift System open source project
|
||||
|
||||
Copyright (c) 2020 Apple Inc. and the Swift System project authors
|
||||
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
|
||||
Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
|
||||
See https://swift.org/LICENSE.txt for license information
|
||||
@@ -9,16 +9,36 @@
|
||||
|
||||
#ifdef __linux__
|
||||
|
||||
#include <sys/epoll.h>
|
||||
// Glibc doesn't export eventfd, which the tests use.
|
||||
#include <sys/eventfd.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/sysinfo.h>
|
||||
#include <sys/timerfd.h>
|
||||
#include <sys/types.h>
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
#include <unistd.h>
|
||||
#include "io_uring.h"
|
||||
#endif
|
||||
|
||||
// Test-only getters for constants that require _GNU_SOURCE.
|
||||
unsigned long long _system_get_ST_RDONLY(void);
|
||||
unsigned long long _system_get_ST_NOSUID(void);
|
||||
unsigned long long _system_get_ST_NODEV(void);
|
||||
unsigned long long _system_get_ST_NOEXEC(void);
|
||||
unsigned long long _system_get_ST_SYNCHRONOUS(void);
|
||||
unsigned long long _system_get_ST_MANDLOCK(void);
|
||||
unsigned long long _system_get_ST_NOATIME(void);
|
||||
unsigned long long _system_get_ST_NODIRATIME(void);
|
||||
unsigned long long _system_get_ST_RELATIME(void);
|
||||
unsigned long long _system_get_ST_NOSYMFOLLOW(void);
|
||||
|
||||
#if !defined(__ANDROID__)
|
||||
#include <stddef.h>
|
||||
#include "io_uring.h"
|
||||
|
||||
// Defined in shims.c, which can include the libc headers they need.
|
||||
extern int csystem_io_uring_setup(unsigned int entries,
|
||||
struct io_uring_params *p);
|
||||
extern int csystem_io_uring_enter(int fd, unsigned int to_submit,
|
||||
unsigned int min_complete,
|
||||
unsigned int flags, void *sig);
|
||||
extern int csystem_io_uring_enter2(int fd, unsigned int to_submit,
|
||||
unsigned int min_complete,
|
||||
unsigned int flags, void *args, size_t sz);
|
||||
extern int csystem_io_uring_register(int fd, unsigned int opcode, void *arg,
|
||||
unsigned int nr_args);
|
||||
#endif // !defined(__ANDROID__)
|
||||
|
||||
#endif // __linux__
|
||||
@@ -12,3 +12,18 @@ extern int csystem_posix_pipe2(int fildes[2], int flag);
|
||||
#endif
|
||||
|
||||
extern int csystem_posix_dup3(int fildes, int fildes2, int flag);
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
// Thread-safe replacement for strerror(3).
|
||||
//
|
||||
// Writes the message for `errnum` into `buf`, which holds `buflen` bytes, and
|
||||
// always NUL-terminates it if `buflen` is not zero. Returns 0 on success, or an
|
||||
// error number (e.g. EINVAL for an unknown `errnum`, ERANGE if the message was
|
||||
// truncated). A message that exactly fills the buffer is also reported as
|
||||
// ERANGE, because not every C library can tell that apart from truncation.
|
||||
// Even on failure, `buf` may contain a message such as "Unknown error 1234".
|
||||
//
|
||||
// This hides the differences between the XSI and GNU variants of strerror_r,
|
||||
// and uses strerror_s on Windows.
|
||||
extern int csystem_strerror_r(int errnum, char *buf, size_t buflen);
|
||||
@@ -1,17 +0,0 @@
|
||||
/*
|
||||
This source file is part of the Swift System open source project
|
||||
|
||||
Copyright (c) 2020 Apple Inc. and the Swift System project authors
|
||||
Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
|
||||
See https://swift.org/LICENSE.txt for license information
|
||||
*/
|
||||
|
||||
#if defined(_WIN32)
|
||||
|
||||
#define NOMINMAX
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#define VC_EXTRA_LEAN
|
||||
#include <Windows.h>
|
||||
|
||||
#endif
|
||||
@@ -1,7 +1,6 @@
|
||||
#include <unistd.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <sys/uio.h>
|
||||
#include <signal.h>
|
||||
#pragma once
|
||||
|
||||
// Types only: the syscall wrappers need libc headers, so they're in shims.c.
|
||||
|
||||
#define __SWIFT_IORING_SQE_FALLBACK_STRUCT { \
|
||||
__u8 opcode; \
|
||||
@@ -193,19 +192,6 @@ struct io_uring_params {
|
||||
};
|
||||
#endif // __has_include(<linux/io_uring.h>)
|
||||
|
||||
#ifndef SWIFT_IORING_C_WRAPPER
|
||||
#define SWIFT_IORING_C_WRAPPER
|
||||
|
||||
# ifndef __NR_io_uring_setup
|
||||
# define __NR_io_uring_setup 425
|
||||
# endif
|
||||
# ifndef __NR_io_uring_enter
|
||||
# define __NR_io_uring_enter 426
|
||||
# endif
|
||||
# ifndef __NR_io_uring_register
|
||||
# define __NR_io_uring_register 427
|
||||
# endif
|
||||
|
||||
/*
|
||||
struct io_uring_getevents_arg {
|
||||
__u64 sigmask;
|
||||
@@ -220,29 +206,3 @@ struct swift_io_uring_getevents_arg {
|
||||
__u32 min_wait_usec;
|
||||
__u64 ts;
|
||||
};
|
||||
|
||||
static inline int io_uring_register(int fd, unsigned int opcode, void *arg,
|
||||
unsigned int nr_args)
|
||||
{
|
||||
return syscall(__NR_io_uring_register, fd, opcode, arg, nr_args);
|
||||
}
|
||||
|
||||
static inline int io_uring_setup(unsigned int entries, struct io_uring_params *p)
|
||||
{
|
||||
return syscall(__NR_io_uring_setup, entries, p);
|
||||
}
|
||||
|
||||
static inline int io_uring_enter2(int fd, unsigned int to_submit, unsigned int min_complete,
|
||||
unsigned int flags, void *args, size_t sz)
|
||||
{
|
||||
return syscall(__NR_io_uring_enter, fd, to_submit, min_complete,
|
||||
flags, args, sz);
|
||||
}
|
||||
|
||||
static inline int io_uring_enter(int fd, unsigned int to_submit, unsigned int min_complete,
|
||||
unsigned int flags, sigset_t *sig)
|
||||
{
|
||||
return io_uring_enter2(fd, to_submit, min_complete, flags, sig, _NSIG / 8);
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,9 +1,17 @@
|
||||
// System imports CSystem with `internal import`. Don't include a header that
|
||||
// the platform's C module also includes: CSystem would then co-own its
|
||||
// declarations, so Swift would limit them to CSystem's import access level and
|
||||
// could credit their members to CSystem under MemberImportVisibility.
|
||||
// (CSystemWASI.h still does; see Constants.swift.)
|
||||
module CSystem {
|
||||
header "CSystemShared.h"
|
||||
header "CSystemDarwin.h"
|
||||
header "CSystemLinux.h"
|
||||
header "CSystemWASI.h"
|
||||
header "CSystemWindows.h"
|
||||
header "CSystemFreeBSD.h"
|
||||
export *
|
||||
}
|
||||
|
||||
// IORing's inlinable code stores these types, so System imports this module
|
||||
// with `public import`. Keep libc headers out of it too.
|
||||
module CSystemIOUring {
|
||||
header "io_uring.h"
|
||||
}
|
||||
+108
-7
@@ -14,20 +14,85 @@
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#if defined(__FreeBSD__)
|
||||
#include <CSystemFreeBSD.h>
|
||||
#endif
|
||||
|
||||
#ifdef __linux__
|
||||
#define _GNU_SOURCE
|
||||
#include <signal.h>
|
||||
#include <sys/statvfs.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <unistd.h>
|
||||
#include <CSystemLinux.h>
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32)
|
||||
#include <CSystemWindows.h>
|
||||
unsigned long long _system_get_ST_RDONLY(void) { return ST_RDONLY; }
|
||||
unsigned long long _system_get_ST_NOSUID(void) { return ST_NOSUID; }
|
||||
unsigned long long _system_get_ST_NODEV(void) { return ST_NODEV; }
|
||||
unsigned long long _system_get_ST_NOEXEC(void) { return ST_NOEXEC; }
|
||||
unsigned long long _system_get_ST_SYNCHRONOUS(void) { return ST_SYNCHRONOUS; }
|
||||
unsigned long long _system_get_ST_MANDLOCK(void) { return ST_MANDLOCK; }
|
||||
unsigned long long _system_get_ST_NOATIME(void) { return ST_NOATIME; }
|
||||
unsigned long long _system_get_ST_NODIRATIME(void) { return ST_NODIRATIME; }
|
||||
unsigned long long _system_get_ST_RELATIME(void) { return ST_RELATIME; }
|
||||
|
||||
// ST_NOSYMFOLLOW wasn't defined until glibc 2.34. 0x2000 is the bit the
|
||||
// kernel's internal <linux/statfs.h> and newer glibc both use.
|
||||
#ifndef ST_NOSYMFOLLOW
|
||||
#define ST_NOSYMFOLLOW 0x2000
|
||||
#endif
|
||||
unsigned long long _system_get_ST_NOSYMFOLLOW(void) { return ST_NOSYMFOLLOW; }
|
||||
#endif
|
||||
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <CSystemShared.h>
|
||||
|
||||
static int csystem_strerror_r_impl(int errnum, char *buf, size_t buflen) {
|
||||
#if defined(_WIN32)
|
||||
return strerror_s(buf, buflen, errnum);
|
||||
#elif defined(_GNU_SOURCE) && \
|
||||
(defined(__GLIBC__) || (defined(__ANDROID__) && __ANDROID_API__ >= 23))
|
||||
// With _GNU_SOURCE (defined above on Linux), glibc and bionic provide the
|
||||
// GNU variant, which returns a pointer to the message. That pointer is
|
||||
// either `buf` or an immutable static string, so copying from it is safe.
|
||||
const char *message = strerror_r(errnum, buf, buflen);
|
||||
if (message == NULL) {
|
||||
return EINVAL;
|
||||
}
|
||||
if (message != buf) {
|
||||
size_t length = strlen(message);
|
||||
if (length >= buflen) {
|
||||
memcpy(buf, message, buflen - 1);
|
||||
buf[buflen - 1] = '\0';
|
||||
return ERANGE;
|
||||
}
|
||||
memcpy(buf, message, length + 1);
|
||||
}
|
||||
return 0;
|
||||
#else
|
||||
// XSI variant (Darwin, FreeBSD, OpenBSD, musl, WASI). Some implementations
|
||||
// return -1 and set errno instead of returning the error number.
|
||||
int result = strerror_r(errnum, buf, buflen);
|
||||
if (result == -1) {
|
||||
result = errno;
|
||||
}
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
extern int csystem_strerror_r(int errnum, char *buf, size_t buflen) {
|
||||
if (buf == NULL || buflen == 0) {
|
||||
return ERANGE;
|
||||
}
|
||||
buf[0] = '\0';
|
||||
int result = csystem_strerror_r_impl(errnum, buf, buflen);
|
||||
buf[buflen - 1] = '\0';
|
||||
// strerror_s on Windows and bionic's strerror_r silently truncate the
|
||||
// message and return 0. Report a message that fills the whole buffer as
|
||||
// ERANGE on every platform, since it may have been truncated.
|
||||
if (result == 0 && strlen(buf) == buflen - 1) {
|
||||
result = ERANGE;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
#if !defined(_WIN32) && !defined(__wasi__) && !defined(__APPLE__)
|
||||
#define HAVE_PIPE2_DUP3
|
||||
@@ -70,3 +135,39 @@ extern int csystem_posix_dup3(int fildes, int fildes2, int flag) {
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
|
||||
#if defined(__linux__) && !defined(__ANDROID__)
|
||||
# ifndef __NR_io_uring_setup
|
||||
# define __NR_io_uring_setup 425
|
||||
# endif
|
||||
# ifndef __NR_io_uring_enter
|
||||
# define __NR_io_uring_enter 426
|
||||
# endif
|
||||
# ifndef __NR_io_uring_register
|
||||
# define __NR_io_uring_register 427
|
||||
# endif
|
||||
|
||||
extern int csystem_io_uring_setup(unsigned int entries,
|
||||
struct io_uring_params *p) {
|
||||
return syscall(__NR_io_uring_setup, entries, p);
|
||||
}
|
||||
|
||||
extern int csystem_io_uring_enter2(int fd, unsigned int to_submit,
|
||||
unsigned int min_complete,
|
||||
unsigned int flags, void *args, size_t sz) {
|
||||
return syscall(__NR_io_uring_enter, fd, to_submit, min_complete, flags,
|
||||
args, sz);
|
||||
}
|
||||
|
||||
extern int csystem_io_uring_enter(int fd, unsigned int to_submit,
|
||||
unsigned int min_complete,
|
||||
unsigned int flags, void *sig) {
|
||||
return csystem_io_uring_enter2(fd, to_submit, min_complete, flags, sig,
|
||||
_NSIG / 8);
|
||||
}
|
||||
|
||||
extern int csystem_io_uring_register(int fd, unsigned int opcode, void *arg,
|
||||
unsigned int nr_args) {
|
||||
return syscall(__NR_io_uring_register, fd, opcode, arg, nr_args);
|
||||
}
|
||||
#endif // defined(__linux__) && !defined(__ANDROID__)
|
||||
@@ -0,0 +1,19 @@
|
||||
#[[
|
||||
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
|
||||
#]]
|
||||
|
||||
add_library(CSystemStatFS INTERFACE)
|
||||
target_include_directories(CSystemStatFS INTERFACE
|
||||
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>"
|
||||
$<INSTALL_INTERFACE:include/CSystemStatFS>)
|
||||
|
||||
install(FILES
|
||||
CSystemStatFS.h
|
||||
module.modulemap
|
||||
DESTINATION include/CSystemStatFS)
|
||||
set_property(GLOBAL APPEND PROPERTY SWIFT_SYSTEM_EXPORTS CSystemStatFS)
|
||||
@@ -0,0 +1,18 @@
|
||||
/*
|
||||
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
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
// Unlike the Musl and Android modules, Glibc doesn't export <sys/vfs.h>,
|
||||
// which declares `struct statfs` and `statfs()`/`fstatfs()`. SystemPackage
|
||||
// re-exports this module on glibc platforms so that clients can use the
|
||||
// raw `CInterop.StatFS` value under MemberImportVisibility.
|
||||
#if defined(__linux__) && !defined(__ANDROID__)
|
||||
#include <sys/vfs.h>
|
||||
#endif
|
||||
@@ -0,0 +1,4 @@
|
||||
module CSystemStatFS [system] {
|
||||
header "CSystemStatFS.h"
|
||||
export *
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
#[[
|
||||
This source file is part of the Swift System open source project
|
||||
|
||||
Copyright (c) 2020 Apple Inc. and the Swift System project authors
|
||||
Copyright (c) 2020 - 2026 Apple Inc. and the Swift System project authors
|
||||
Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
|
||||
See https://swift.org/LICENSE.txt for license information
|
||||
@@ -31,7 +31,7 @@ set_target_properties(SystemPackage PROPERTIES
|
||||
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
|
||||
1.7.0 1.9.0
|
||||
199)
|
||||
set(SWIFT_SYSTEM_SOURCE_AVAILABILITY
|
||||
"macOS 10.10, iOS 8.0, watchOS 2.0, tvOS 9.0, visionOS 1.0")
|
||||
@@ -61,7 +61,9 @@ target_sources(SystemPackage PRIVATE
|
||||
FileSystem/FileMode.swift
|
||||
FileSystem/FileType.swift
|
||||
FileSystem/Identifiers.swift
|
||||
FileSystem/Stat.swift)
|
||||
FileSystem/MountFlags.swift
|
||||
FileSystem/Stat.swift
|
||||
FileSystem/StatFS.swift)
|
||||
if(CMAKE_SYSTEM_NAME STREQUAL Linux)
|
||||
target_sources(SystemPackage PRIVATE
|
||||
IORing/IOCompletion.swift
|
||||
@@ -82,6 +84,10 @@ target_sources(SystemPackage PRIVATE
|
||||
Internals/WindowsSyscallAdapters.swift)
|
||||
target_link_libraries(SystemPackage PUBLIC
|
||||
CSystem)
|
||||
if(CMAKE_SYSTEM_NAME STREQUAL Linux)
|
||||
target_link_libraries(SystemPackage PUBLIC
|
||||
CSystemStatFS)
|
||||
endif()
|
||||
|
||||
set(SWIFT_SYSTEM_APPLE_PLATFORMS "Darwin" "iOS" "watchOS" "tvOS" "visionOS")
|
||||
if(CMAKE_SYSTEM_NAME IN_LIST SWIFT_SYSTEM_APPLE_PLATFORMS)
|
||||
|
||||
@@ -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
|
||||
@@ -1547,11 +1547,25 @@ extension Errno: CustomStringConvertible, CustomDebugStringConvertible {
|
||||
/// A textual representation of the most recent error
|
||||
/// returned by a system call.
|
||||
///
|
||||
/// The corresponding C function is `strerror(3)`.
|
||||
/// The corresponding C function is `strerror(3)`. This property uses a
|
||||
/// thread-safe variant of it, so it is safe to use from multiple threads.
|
||||
@inline(never)
|
||||
public var description: String {
|
||||
guard let ptr = system_strerror(self.rawValue) else { return "unknown error" }
|
||||
return String(cString: ptr)
|
||||
// Error messages are short, so 256 bytes is plenty. If one is longer,
|
||||
// csystem_strerror_r truncates it. The message is written directly into
|
||||
// the new string's storage.
|
||||
let message = String(_unsafeUninitializedCapacity: 256) { buffer in
|
||||
let capacity = buffer.count
|
||||
buffer.withMemoryRebound(to: CChar.self) { buffer in
|
||||
// Even when strerror_r fails, e.g. with EINVAL for an unknown error
|
||||
// number, most C libraries still write a message like
|
||||
// "Unknown error 1234", so use whatever was written. The shim always
|
||||
// NUL-terminates the buffer.
|
||||
_ = system_strerror_r(self.rawValue, buffer.baseAddress!, capacity)
|
||||
}
|
||||
return UnsafeBufferPointer(buffer).firstIndex(of: 0) ?? 0
|
||||
}
|
||||
return message.isEmpty ? "unknown error" : message
|
||||
}
|
||||
|
||||
/// A textual representation,
|
||||
|
||||
@@ -381,7 +381,7 @@ extension FileDescriptor {
|
||||
/// Duplicates this file descriptor and returns the newly created copy.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - `target`: The desired target file descriptor, or `nil`, in which case
|
||||
/// - 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 duplicate operation
|
||||
|
||||
@@ -143,7 +143,9 @@ extension FilePath.ComponentView: RangeReplaceableCollection {
|
||||
str.append(platformSeparator)
|
||||
}
|
||||
str.appendComponents(components: newElements)
|
||||
if !atEnd {
|
||||
// If we're replacing through the end, we must not leave a trailing
|
||||
// separator.
|
||||
if subrange.upperBound != endIndex {
|
||||
str.append(platformSeparator)
|
||||
}
|
||||
_path._storage.replaceSubrange(range, with: str)
|
||||
|
||||
@@ -9,7 +9,6 @@
|
||||
|
||||
#if !os(Windows)
|
||||
|
||||
import CSystem
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
import Darwin
|
||||
#elseif canImport(Glibc)
|
||||
@@ -17,6 +16,7 @@ import Glibc
|
||||
#elseif canImport(Musl)
|
||||
import Musl
|
||||
#elseif canImport(WASILibc)
|
||||
internal import CSystem // For the members of system_dirent
|
||||
import WASILibc
|
||||
#elseif canImport(Android)
|
||||
import Android
|
||||
|
||||
@@ -113,13 +113,15 @@ public struct FilePermissions: OptionSet, Sendable, Hashable, Codable {
|
||||
|
||||
/// Indicates that the file is executed as the owner.
|
||||
///
|
||||
/// For more information, see the `setuid(2)` man page.
|
||||
/// For more information, see the `chmod(2)` man page's
|
||||
/// discussion of `S_ISUID` (the set-user-ID bit).
|
||||
@_alwaysEmitIntoClient
|
||||
public static var setUserID: FilePermissions { .init(rawValue: 0o4000) }
|
||||
|
||||
/// Indicates that the file is executed as the group.
|
||||
///
|
||||
/// For more information, see the `setgid(2)` man page.
|
||||
/// For more information, see the `chmod(2)` man page's
|
||||
/// discussion of `S_ISGID` (the set-group-ID bit).
|
||||
@_alwaysEmitIntoClient
|
||||
public static var setGroupID: FilePermissions { .init(rawValue: 0o2000) }
|
||||
|
||||
|
||||
@@ -0,0 +1,647 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 !os(Windows) && !os(WASI)
|
||||
|
||||
/// Flags describing a mounted file system.
|
||||
///
|
||||
/// These are the flags reported in the `f_flags` field of a `statfs` struct.
|
||||
/// Some reflect options employed when mounting the file system, while others,
|
||||
/// like `local` and `rootFileSystem`, describe state the kernel reports.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
///
|
||||
/// The corresponding C constants available on each platform:
|
||||
///
|
||||
/// | MountFlags | Darwin | FreeBSD | OpenBSD | Linux | Android |
|
||||
/// |----------------------------------|------------------------|-------------------|-------------------|------------------|------------------|
|
||||
/// | `readOnly` | `MNT_RDONLY` | `MNT_RDONLY` | `MNT_RDONLY` | `ST_RDONLY` | `ST_RDONLY` |
|
||||
/// | `synchronous` | `MNT_SYNCHRONOUS` | `MNT_SYNCHRONOUS` | `MNT_SYNCHRONOUS` | `ST_SYNCHRONOUS` | `ST_SYNCHRONOUS` |
|
||||
/// | `noExecution` | `MNT_NOEXEC` | `MNT_NOEXEC` | `MNT_NOEXEC` | `ST_NOEXEC` | `ST_NOEXEC` |
|
||||
/// | `noSetUserID` | `MNT_NOSUID` | `MNT_NOSUID` | `MNT_NOSUID` | `ST_NOSUID` | `ST_NOSUID` |
|
||||
/// | `noAccessTime` | `MNT_NOATIME` | `MNT_NOATIME` | `MNT_NOATIME` | `ST_NOATIME` | `ST_NOATIME` |
|
||||
/// | `noDevices` | `MNT_NODEV` | N/A | `MNT_NODEV` | `ST_NODEV` | `ST_NODEV` |
|
||||
/// | `mandatoryLocking` | N/A | N/A | N/A | `ST_MANDLOCK` | `ST_MANDLOCK` |
|
||||
/// | `noDirectoryAccessTime` | N/A | N/A | N/A | `ST_NODIRATIME` | `ST_NODIRATIME` |
|
||||
/// | `relativeAccessTime` | N/A | N/A | N/A | `ST_RELATIME` | `ST_RELATIME` |
|
||||
/// | `noSymlinkFollowing` | N/A | `MNT_NOSYMFOLLOW` | N/A | `ST_NOSYMFOLLOW` | `ST_NOSYMFOLLOW` |
|
||||
/// | `asynchronous` | `MNT_ASYNC` | `MNT_ASYNC` | `MNT_ASYNC` | N/A | N/A |
|
||||
/// | `exported` | `MNT_EXPORTED` | `MNT_EXPORTED` | `MNT_EXPORTED` | N/A | N/A |
|
||||
/// | `local` | `MNT_LOCAL` | `MNT_LOCAL` | `MNT_LOCAL` | N/A | N/A |
|
||||
/// | `quotasEnabled` | `MNT_QUOTA` | `MNT_QUOTA` | `MNT_QUOTA` | N/A | N/A |
|
||||
/// | `rootFileSystem` | `MNT_ROOTFS` | `MNT_ROOTFS` | `MNT_ROOTFS` | N/A | N/A |
|
||||
/// | `union` | `MNT_UNION` | `MNT_UNION` | N/A | N/A | N/A |
|
||||
/// | `automounted` | `MNT_AUTOMOUNTED` | `MNT_AUTOMOUNTED` | N/A | N/A | N/A |
|
||||
/// | `multiLabel` | `MNT_MULTILABEL` | `MNT_MULTILABEL` | N/A | N/A | N/A |
|
||||
/// | `exportedReadOnly` | N/A | `MNT_EXRDONLY` | `MNT_EXRDONLY` | N/A | N/A |
|
||||
/// | `exportedByDefault` | N/A | `MNT_DEFEXPORTED` | `MNT_DEFEXPORTED` | N/A | N/A |
|
||||
/// | `exportedAnonymously` | N/A | `MNT_EXPORTANON` | `MNT_EXPORTANON` | N/A | N/A |
|
||||
/// | `softUpdates` | N/A | `MNT_SOFTDEP` | `MNT_SOFTDEP` | N/A | N/A |
|
||||
/// | `contentProtection` | `MNT_CPROTECT` | N/A | N/A | N/A | N/A |
|
||||
/// | `removable` | `MNT_REMOVABLE` | N/A | N/A | N/A | N/A |
|
||||
/// | `quarantined` | `MNT_QUARANTINE` | N/A | N/A | N/A | N/A |
|
||||
/// | `supportsVolfs` | `MNT_DOVOLFS` | N/A | N/A | N/A | N/A |
|
||||
/// | `noBrowsing` | `MNT_DONTBROWSE` | N/A | N/A | N/A | N/A |
|
||||
/// | `ignoresOwnership` | `MNT_IGNORE_OWNERSHIP` | N/A | N/A | N/A | N/A |
|
||||
/// | `journaled` | `MNT_JOURNALED` | N/A | N/A | N/A | N/A |
|
||||
/// | `noUserExtendedAttributes` | `MNT_NOUSERXATTR` | N/A | N/A | N/A | N/A |
|
||||
/// | `defersWrites` | `MNT_DEFWRITE` | N/A | N/A | N/A | N/A |
|
||||
/// | `noSymlinkFollowingAtMountPoint` | `MNT_NOFOLLOW` | N/A | N/A | N/A | N/A |
|
||||
/// | `snapshot` | `MNT_SNAPSHOT` | N/A | N/A | N/A | N/A |
|
||||
/// | `strictAccessTime` | `MNT_STRICTATIME` | N/A | N/A | N/A | N/A |
|
||||
/// | `exportedWithKerberos` | N/A | `MNT_EXKERB` | N/A | N/A | N/A |
|
||||
/// | `exportedPublicly` | N/A | `MNT_EXPUBLIC` | N/A | N/A | N/A |
|
||||
/// | `posixACLs` | N/A | `MNT_ACLS` | N/A | N/A | N/A |
|
||||
/// | `geomJournaled` | N/A | `MNT_GJOURNAL` | N/A | N/A | N/A |
|
||||
/// | `excludedFromDiskFreeReports` | N/A | `MNT_IGNORE` | N/A | N/A | N/A |
|
||||
/// | `nfs4ACLs` | N/A | `MNT_NFS4ACLS` | N/A | N/A | N/A |
|
||||
/// | `noClusteredReads` | N/A | `MNT_NOCLUSTERR` | N/A | N/A | N/A |
|
||||
/// | `noClusteredWrites` | N/A | `MNT_NOCLUSTERW` | N/A | N/A | N/A |
|
||||
/// | `setUserIDDirectories` | N/A | `MNT_SUIDDIR` | N/A | N/A | N/A |
|
||||
/// | `softUpdatesJournaling` | N/A | `MNT_SUJ` | N/A | N/A | N/A |
|
||||
/// | `untrusted` | N/A | `MNT_UNTRUSTED` | N/A | N/A | N/A |
|
||||
/// | `userMounted` | N/A | `MNT_USER` | N/A | N/A | N/A |
|
||||
/// | `verified` | N/A | `MNT_VERIFIED` | N/A | N/A | N/A |
|
||||
/// | `noPermissionChecks` | N/A | N/A | `MNT_NOPERM` | N/A | N/A |
|
||||
/// | `writeExecuteAllowed` | N/A | N/A | `MNT_WXALLOWED` | N/A | N/A |
|
||||
@frozen
|
||||
@available(System 1.9.0, *)
|
||||
public struct MountFlags: OptionSet, Sendable, Hashable, Codable {
|
||||
|
||||
/// The raw C flags.
|
||||
@_alwaysEmitIntoClient
|
||||
public let rawValue: CInterop.MountFlags
|
||||
|
||||
/// Creates a strongly-typed `MountFlags` from the raw C value.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(rawValue: CInterop.MountFlags) { self.rawValue = rawValue }
|
||||
|
||||
// MARK: Flags Available on All Platforms
|
||||
|
||||
/// The file system is mounted read-only, even for the super-user.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_RDONLY` on Darwin and BSD,
|
||||
/// or `ST_RDONLY` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var readOnly: MountFlags { MountFlags(rawValue: _MOUNT_RDONLY) }
|
||||
|
||||
/// The file system is written to synchronously.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_SYNCHRONOUS` on Darwin and BSD,
|
||||
/// or `ST_SYNCHRONOUS` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var synchronous: MountFlags { MountFlags(rawValue: _MOUNT_SYNCHRONOUS) }
|
||||
|
||||
/// Programs may not be executed from the file system.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOEXEC` on Darwin and BSD,
|
||||
/// or `ST_NOEXEC` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noExecution: MountFlags { MountFlags(rawValue: _MOUNT_NOEXEC) }
|
||||
|
||||
/// Set-user-ID and set-group-ID (setuid and setgid) bits are not honored on
|
||||
/// the file system.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOSUID` on Darwin and BSD,
|
||||
/// or `ST_NOSUID` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noSetUserID: MountFlags { MountFlags(rawValue: _MOUNT_NOSUID) }
|
||||
|
||||
/// Access times are not updated on the file system.
|
||||
///
|
||||
/// - Note: On OpenBSD, access time may still be updated when the
|
||||
/// modification or status-change time is also being updated.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOATIME` on Darwin and BSD,
|
||||
/// or `ST_NOATIME` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noAccessTime: MountFlags { MountFlags(rawValue: _MOUNT_NOATIME) }
|
||||
|
||||
// MARK: Flags Available on All Platforms Except FreeBSD
|
||||
|
||||
#if !os(FreeBSD)
|
||||
/// Special files may not be interpreted on the file system.
|
||||
///
|
||||
/// - Note: Not available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NODEV` on Darwin and OpenBSD,
|
||||
/// or `ST_NODEV` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noDevices: MountFlags { MountFlags(rawValue: _MOUNT_NODEV) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Linux and Android
|
||||
|
||||
// Glibc and musl also define `ST_WRITE`, `ST_APPEND`, and `ST_IMMUTABLE`, but
|
||||
// Linux never reports them in `f_flags`, so they have no corresponding flag.
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
/// Mandatory file locking is enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on Linux and Android.
|
||||
/// - Note: Mandatory locking was deprecated and removed in Linux 5.15.
|
||||
///
|
||||
/// The corresponding C constant is `ST_MANDLOCK`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var mandatoryLocking: MountFlags { MountFlags(rawValue: _ST_MANDLOCK) }
|
||||
|
||||
/// Directory access times are not updated on the file system.
|
||||
///
|
||||
/// - Note: Only available on Linux and Android.
|
||||
///
|
||||
/// The corresponding C constant is `ST_NODIRATIME`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noDirectoryAccessTime: MountFlags { MountFlags(rawValue: _ST_NODIRATIME) }
|
||||
|
||||
/// The access time is only updated if it's earlier than or equal to the file's
|
||||
/// last modification or status-change time, or if it's more than a day old.
|
||||
///
|
||||
/// - Note: Only available on Linux and Android.
|
||||
///
|
||||
/// The corresponding C constant is `ST_RELATIME`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var relativeAccessTime: MountFlags { MountFlags(rawValue: _ST_RELATIME) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Linux, Android, and FreeBSD
|
||||
|
||||
#if os(Linux) || os(Android) || os(FreeBSD)
|
||||
/// Symbolic links are not followed when resolving paths on the file system.
|
||||
///
|
||||
/// - Note: Only available on Linux, Android, and FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOSYMFOLLOW` on FreeBSD,
|
||||
/// or `ST_NOSYMFOLLOW` on Linux and Android.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noSymlinkFollowing: MountFlags { MountFlags(rawValue: _MOUNT_NOSYMFOLLOW) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
/// The file system is written to asynchronously.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_ASYNC`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var asynchronous: MountFlags { MountFlags(rawValue: _MNT_ASYNC) }
|
||||
|
||||
/// The file system is exported for use over the network via NFS.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_EXPORTED`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var exported: MountFlags { MountFlags(rawValue: _MNT_EXPORTED) }
|
||||
|
||||
/// The file system is stored locally, rather than being accessed over a network.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_LOCAL`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var local: MountFlags { MountFlags(rawValue: _MNT_LOCAL) }
|
||||
|
||||
/// Quotas are enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_QUOTA`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var quotasEnabled: MountFlags { MountFlags(rawValue: _MNT_QUOTA) }
|
||||
|
||||
/// The file system is the root file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_ROOTFS`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var rootFileSystem: MountFlags { MountFlags(rawValue: _MNT_ROOTFS) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Darwin and FreeBSD
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
|
||||
/// The file system is unioned with the underlying file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin and FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_UNION`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var union: MountFlags { MountFlags(rawValue: _MNT_UNION) }
|
||||
|
||||
/// The file system was mounted by the automounter.
|
||||
///
|
||||
/// - Note: Only available on Darwin and FreeBSD. See `automount(8)`.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_AUTOMOUNTED`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var automounted: MountFlags { MountFlags(rawValue: _MNT_AUTOMOUNTED) }
|
||||
|
||||
/// The file system maintains Mandatory Access Control (MAC) labels for
|
||||
/// individual objects.
|
||||
///
|
||||
/// - Note: Only available on Darwin and FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_MULTILABEL`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var multiLabel: MountFlags { MountFlags(rawValue: _MNT_MULTILABEL) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on FreeBSD and OpenBSD
|
||||
|
||||
#if os(FreeBSD) || os(OpenBSD)
|
||||
/// The file system is exported for reading only.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD and OpenBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_EXRDONLY`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var exportedReadOnly: MountFlags { MountFlags(rawValue: _MNT_EXRDONLY) }
|
||||
|
||||
/// The file system is exported to any host by default.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD and OpenBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_DEFEXPORTED`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var exportedByDefault: MountFlags { MountFlags(rawValue: _MNT_DEFEXPORTED) }
|
||||
|
||||
/// The file system is exported with all remote users mapped to the
|
||||
/// anonymous user account.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD and OpenBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_EXPORTANON`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var exportedAnonymously: MountFlags { MountFlags(rawValue: _MNT_EXPORTANON) }
|
||||
|
||||
/// Soft updates are enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD and OpenBSD. Accepted for compatibility
|
||||
/// on OpenBSD, but has no effect there.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_SOFTDEP`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var softUpdates: MountFlags { MountFlags(rawValue: _MNT_SOFTDEP) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Darwin Only
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
/// Per-file encrypted data protection is enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_CPROTECT`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var contentProtection: MountFlags { MountFlags(rawValue: _MNT_CPROTECT) }
|
||||
|
||||
/// The file system resides on removable media.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_REMOVABLE`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var removable: MountFlags { MountFlags(rawValue: _MNT_REMOVABLE) }
|
||||
|
||||
/// The file system is quarantined.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_QUARANTINE`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var quarantined: MountFlags { MountFlags(rawValue: _MNT_QUARANTINE) }
|
||||
|
||||
/// The file system supports volfs.
|
||||
///
|
||||
/// - Note: Only available on Darwin. Deprecated since Mac OS X 10.5.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_DOVOLFS`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var supportsVolfs: MountFlags { MountFlags(rawValue: _MNT_DOVOLFS) }
|
||||
|
||||
/// The file system should not be presented to the user for browsing
|
||||
/// (e.g. hidden in Finder).
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_DONTBROWSE`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noBrowsing: MountFlags { MountFlags(rawValue: _MNT_DONTBROWSE) }
|
||||
|
||||
/// The file system ignores ownership information.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_IGNORE_OWNERSHIP`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var ignoresOwnership: MountFlags { MountFlags(rawValue: _MNT_IGNORE_OWNERSHIP) }
|
||||
|
||||
/// The file system is journaled.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_JOURNALED`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var journaled: MountFlags { MountFlags(rawValue: _MNT_JOURNALED) }
|
||||
|
||||
/// User extended attributes are not allowed on the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOUSERXATTR`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noUserExtendedAttributes: MountFlags { MountFlags(rawValue: _MNT_NOUSERXATTR) }
|
||||
|
||||
/// The file system defers writes.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_DEFWRITE`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var defersWrites: MountFlags { MountFlags(rawValue: _MNT_DEFWRITE) }
|
||||
|
||||
/// Symbolic links are not followed when resolving the mount point.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOFOLLOW`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noSymlinkFollowingAtMountPoint: MountFlags { MountFlags(rawValue: _MNT_NOFOLLOW) }
|
||||
|
||||
/// The file system is a snapshot.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_SNAPSHOT`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var snapshot: MountFlags { MountFlags(rawValue: _MNT_SNAPSHOT) }
|
||||
|
||||
/// Access times are always updated when files are read. Without this flag,
|
||||
/// the file system may skip some access time updates for performance.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_STRICTATIME`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var strictAccessTime: MountFlags { MountFlags(rawValue: _MNT_STRICTATIME) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on FreeBSD Only
|
||||
|
||||
#if os(FreeBSD)
|
||||
/// The file system is exported with Kerberos user-ID mapping.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_EXKERB`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var exportedWithKerberos: MountFlags { MountFlags(rawValue: _MNT_EXKERB) }
|
||||
|
||||
/// The file system is exported publicly for WebNFS clients.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_EXPUBLIC`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var exportedPublicly: MountFlags { MountFlags(rawValue: _MNT_EXPUBLIC) }
|
||||
|
||||
/// POSIX.1e ACLs are enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_ACLS`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var posixACLs: MountFlags { MountFlags(rawValue: _MNT_ACLS) }
|
||||
|
||||
/// The file system is journaled by `gjournal`.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD. See `gjournal(8)`.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_GJOURNAL`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var geomJournaled: MountFlags { MountFlags(rawValue: _MNT_GJOURNAL) }
|
||||
|
||||
/// The file system is omitted from `df(1)` listings.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_IGNORE`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var excludedFromDiskFreeReports: MountFlags { MountFlags(rawValue: _MNT_IGNORE) }
|
||||
|
||||
/// NFSv4 ACLs are enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NFS4ACLS`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var nfs4ACLs: MountFlags { MountFlags(rawValue: _MNT_NFS4ACLS) }
|
||||
|
||||
/// Clustered reads are disabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOCLUSTERR`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noClusteredReads: MountFlags { MountFlags(rawValue: _MNT_NOCLUSTERR) }
|
||||
|
||||
/// Clustered writes are disabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOCLUSTERW`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noClusteredWrites: MountFlags { MountFlags(rawValue: _MNT_NOCLUSTERW) }
|
||||
|
||||
/// Newly created files in a directory with the set-user-ID bit set are owned
|
||||
/// by that directory's owner, rather than by the creating user.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_SUIDDIR`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var setUserIDDirectories: MountFlags { MountFlags(rawValue: _MNT_SUIDDIR) }
|
||||
|
||||
/// Soft updates journaling is enabled on the file system.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_SUJ`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var softUpdatesJournaling: MountFlags { MountFlags(rawValue: _MNT_SUJ) }
|
||||
|
||||
/// The file system is untrusted, as the integrity of its media is unknown.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_UNTRUSTED`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var untrusted: MountFlags { MountFlags(rawValue: _MNT_UNTRUSTED) }
|
||||
|
||||
/// The file system was mounted by a non-root user.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_USER`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var userMounted: MountFlags { MountFlags(rawValue: _MNT_USER) }
|
||||
|
||||
/// The file system is marked as verified, so per-file integrity checks are
|
||||
/// skipped on execution.
|
||||
///
|
||||
/// - Note: Only available on FreeBSD. See `mac_veriexec(4)`.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_VERIFIED`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var verified: MountFlags { MountFlags(rawValue: _MNT_VERIFIED) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on OpenBSD Only
|
||||
|
||||
#if os(OpenBSD)
|
||||
/// File permissions are not checked on the file system (FFS only).
|
||||
///
|
||||
/// - Note: Only available on OpenBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_NOPERM`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var noPermissionChecks: MountFlags { MountFlags(rawValue: _MNT_NOPERM) }
|
||||
|
||||
/// Programs residing on the file system may create memory mappings that are
|
||||
/// both writable and executable.
|
||||
///
|
||||
/// By default, requesting such a mapping (via `mmap(2)` or `mprotect(2)`)
|
||||
/// kills the process. This flag lifts that restriction.
|
||||
///
|
||||
/// - Note: Only available on OpenBSD.
|
||||
///
|
||||
/// The corresponding C constant is `MNT_WXALLOWED`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var writeExecuteAllowed: MountFlags { MountFlags(rawValue: _MNT_WXALLOWED) }
|
||||
#endif
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension MountFlags
|
||||
: CustomStringConvertible, CustomDebugStringConvertible
|
||||
{
|
||||
/// A textual representation of the mount flags.
|
||||
@inline(never)
|
||||
public var description: String {
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
let descriptions: [(Element, StaticString)] = [
|
||||
(.readOnly, ".readOnly"),
|
||||
(.synchronous, ".synchronous"),
|
||||
(.noExecution, ".noExecution"),
|
||||
(.noSetUserID, ".noSetUserID"),
|
||||
(.noAccessTime, ".noAccessTime"),
|
||||
(.noDevices, ".noDevices"),
|
||||
(.asynchronous, ".asynchronous"),
|
||||
(.exported, ".exported"),
|
||||
(.local, ".local"),
|
||||
(.quotasEnabled, ".quotasEnabled"),
|
||||
(.rootFileSystem, ".rootFileSystem"),
|
||||
(.union, ".union"),
|
||||
(.automounted, ".automounted"),
|
||||
(.multiLabel, ".multiLabel"),
|
||||
(.contentProtection, ".contentProtection"),
|
||||
(.removable, ".removable"),
|
||||
(.quarantined, ".quarantined"),
|
||||
(.supportsVolfs, ".supportsVolfs"),
|
||||
(.noBrowsing, ".noBrowsing"),
|
||||
(.ignoresOwnership, ".ignoresOwnership"),
|
||||
(.journaled, ".journaled"),
|
||||
(.noUserExtendedAttributes, ".noUserExtendedAttributes"),
|
||||
(.defersWrites, ".defersWrites"),
|
||||
(.noSymlinkFollowingAtMountPoint, ".noSymlinkFollowingAtMountPoint"),
|
||||
(.snapshot, ".snapshot"),
|
||||
(.strictAccessTime, ".strictAccessTime"),
|
||||
]
|
||||
#elseif os(FreeBSD)
|
||||
let descriptions: [(Element, StaticString)] = [
|
||||
(.readOnly, ".readOnly"),
|
||||
(.synchronous, ".synchronous"),
|
||||
(.noExecution, ".noExecution"),
|
||||
(.noSetUserID, ".noSetUserID"),
|
||||
(.noAccessTime, ".noAccessTime"),
|
||||
(.noSymlinkFollowing, ".noSymlinkFollowing"),
|
||||
(.asynchronous, ".asynchronous"),
|
||||
(.exported, ".exported"),
|
||||
(.local, ".local"),
|
||||
(.quotasEnabled, ".quotasEnabled"),
|
||||
(.rootFileSystem, ".rootFileSystem"),
|
||||
(.union, ".union"),
|
||||
(.automounted, ".automounted"),
|
||||
(.multiLabel, ".multiLabel"),
|
||||
(.exportedReadOnly, ".exportedReadOnly"),
|
||||
(.exportedByDefault, ".exportedByDefault"),
|
||||
(.exportedAnonymously, ".exportedAnonymously"),
|
||||
(.softUpdates, ".softUpdates"),
|
||||
(.exportedWithKerberos, ".exportedWithKerberos"),
|
||||
(.exportedPublicly, ".exportedPublicly"),
|
||||
(.posixACLs, ".posixACLs"),
|
||||
(.geomJournaled, ".geomJournaled"),
|
||||
(.excludedFromDiskFreeReports, ".excludedFromDiskFreeReports"),
|
||||
(.nfs4ACLs, ".nfs4ACLs"),
|
||||
(.noClusteredReads, ".noClusteredReads"),
|
||||
(.noClusteredWrites, ".noClusteredWrites"),
|
||||
(.setUserIDDirectories, ".setUserIDDirectories"),
|
||||
(.softUpdatesJournaling, ".softUpdatesJournaling"),
|
||||
(.untrusted, ".untrusted"),
|
||||
(.userMounted, ".userMounted"),
|
||||
(.verified, ".verified"),
|
||||
]
|
||||
#elseif os(OpenBSD)
|
||||
let descriptions: [(Element, StaticString)] = [
|
||||
(.readOnly, ".readOnly"),
|
||||
(.synchronous, ".synchronous"),
|
||||
(.noExecution, ".noExecution"),
|
||||
(.noSetUserID, ".noSetUserID"),
|
||||
(.noAccessTime, ".noAccessTime"),
|
||||
(.noDevices, ".noDevices"),
|
||||
(.asynchronous, ".asynchronous"),
|
||||
(.exported, ".exported"),
|
||||
(.local, ".local"),
|
||||
(.quotasEnabled, ".quotasEnabled"),
|
||||
(.rootFileSystem, ".rootFileSystem"),
|
||||
(.exportedReadOnly, ".exportedReadOnly"),
|
||||
(.exportedByDefault, ".exportedByDefault"),
|
||||
(.exportedAnonymously, ".exportedAnonymously"),
|
||||
(.softUpdates, ".softUpdates"),
|
||||
(.noPermissionChecks, ".noPermissionChecks"),
|
||||
(.writeExecuteAllowed, ".writeExecuteAllowed"),
|
||||
]
|
||||
#elseif os(Linux) || os(Android)
|
||||
let descriptions: [(Element, StaticString)] = [
|
||||
(.readOnly, ".readOnly"),
|
||||
(.synchronous, ".synchronous"),
|
||||
(.noExecution, ".noExecution"),
|
||||
(.noSetUserID, ".noSetUserID"),
|
||||
(.noAccessTime, ".noAccessTime"),
|
||||
(.noDevices, ".noDevices"),
|
||||
(.mandatoryLocking, ".mandatoryLocking"),
|
||||
(.noDirectoryAccessTime, ".noDirectoryAccessTime"),
|
||||
(.relativeAccessTime, ".relativeAccessTime"),
|
||||
(.noSymlinkFollowing, ".noSymlinkFollowing"),
|
||||
]
|
||||
#endif
|
||||
|
||||
return _buildDescription(descriptions)
|
||||
}
|
||||
|
||||
/// A textual representation of the mount flags, suitable for debugging.
|
||||
public var debugDescription: String { self.description }
|
||||
}
|
||||
|
||||
#endif // !os(Windows) && !os(WASI)
|
||||
@@ -15,15 +15,12 @@
|
||||
#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")
|
||||
|
||||
@@ -0,0 +1,866 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 os(Windows)
|
||||
|
||||
/// A Swift wrapper of the C `statfs` struct.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
@available(Windows, unavailable, message: "Consider using a Win32 API such as GetVolumeInformationW or GetDiskFreeSpaceExW instead.")
|
||||
public struct StatFS {
|
||||
/// Creates a `StatFS` from a `FilePath`.
|
||||
public init(
|
||||
_ path: FilePath,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
fatalError("StatFS is unavailable on Windows")
|
||||
}
|
||||
|
||||
/// Creates a `StatFS` from a null-terminated `UnsafePointer<CChar>` path.
|
||||
public init(
|
||||
_ path: UnsafePointer<CChar>,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
fatalError("StatFS is unavailable on Windows")
|
||||
}
|
||||
|
||||
/// Creates a `StatFS` from a `FileDescriptor`.
|
||||
public init(
|
||||
_ fd: FileDescriptor,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
fatalError("StatFS is unavailable on Windows")
|
||||
}
|
||||
}
|
||||
|
||||
#elseif os(WASI)
|
||||
|
||||
/// A Swift wrapper of the C `statfs` struct.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
@available(*, unavailable, message: "wasi-libc doesn't implement statfs or statvfs.")
|
||||
public struct StatFS {
|
||||
/// Creates a `StatFS` from a `FilePath`.
|
||||
public init(
|
||||
_ path: FilePath,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
fatalError("StatFS is unavailable on WASI")
|
||||
}
|
||||
|
||||
/// Creates a `StatFS` from a null-terminated `UnsafePointer<CChar>` path.
|
||||
public init(
|
||||
_ path: UnsafePointer<CChar>,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
fatalError("StatFS is unavailable on WASI")
|
||||
}
|
||||
|
||||
/// Creates a `StatFS` from a `FileDescriptor`.
|
||||
public init(
|
||||
_ fd: FileDescriptor,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
fatalError("StatFS is unavailable on WASI")
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
// Must import here to use C statfs properties in @_alwaysEmitIntoClient APIs.
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
import Darwin
|
||||
#elseif canImport(Glibc)
|
||||
#if os(Linux)
|
||||
import CSystemStatFS
|
||||
#endif
|
||||
import Glibc
|
||||
#elseif canImport(Musl)
|
||||
import Musl
|
||||
#elseif canImport(Android)
|
||||
import Android
|
||||
#else
|
||||
#error("Unsupported Platform")
|
||||
#endif
|
||||
|
||||
// MARK: - FileSystemID
|
||||
|
||||
/// A Swift wrapper of the C `f_fsid` file system ID found in a `statfs`
|
||||
/// struct.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
@frozen
|
||||
@available(System 1.9.0, *)
|
||||
public struct FileSystemID: RawRepresentable, Sendable {
|
||||
|
||||
/// The raw C file system ID.
|
||||
@_alwaysEmitIntoClient
|
||||
public var rawValue: CInterop.FileSystemID
|
||||
|
||||
/// Creates a strongly-typed `FileSystemID` from the raw C value.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(rawValue: CInterop.FileSystemID) { self.rawValue = rawValue }
|
||||
|
||||
/// Creates a strongly-typed `FileSystemID` from the raw C value.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(_ rawValue: CInterop.FileSystemID) { self.rawValue = rawValue }
|
||||
}
|
||||
|
||||
// `CInterop.FileSystemID` is the C `fsid_t` struct (a fixed two-element
|
||||
// `int32_t` array), which provides no synthesized conformances.
|
||||
@available(System 1.9.0, *)
|
||||
extension FileSystemID {
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _words: (Int32, Int32) {
|
||||
#if os(Linux) || os(Android)
|
||||
rawValue.__val
|
||||
#else
|
||||
rawValue.val
|
||||
#endif
|
||||
}
|
||||
|
||||
@_alwaysEmitIntoClient
|
||||
internal init(_words words: (Int32, Int32)) {
|
||||
#if os(Linux) || os(Android)
|
||||
self.init(rawValue: CInterop.FileSystemID(__val: words))
|
||||
#else
|
||||
self.init(rawValue: CInterop.FileSystemID(val: words))
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension FileSystemID: Equatable {
|
||||
@_alwaysEmitIntoClient
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs._words.0 == rhs._words.0 && lhs._words.1 == rhs._words.1
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension FileSystemID: Hashable {
|
||||
@_alwaysEmitIntoClient
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(_words.0)
|
||||
hasher.combine(_words.1)
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension FileSystemID: Codable {
|
||||
@_alwaysEmitIntoClient
|
||||
public func encode(to encoder: any Encoder) throws {
|
||||
var container = encoder.unkeyedContainer()
|
||||
try container.encode(_words.0)
|
||||
try container.encode(_words.1)
|
||||
}
|
||||
|
||||
@_alwaysEmitIntoClient
|
||||
public init(from decoder: any Decoder) throws {
|
||||
var container = try decoder.unkeyedContainer()
|
||||
let val0 = try container.decode(Int32.self)
|
||||
let val1 = try container.decode(Int32.self)
|
||||
self.init(_words: (val0, val1))
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension FileSystemID: CustomStringConvertible, CustomDebugStringConvertible {
|
||||
/// A textual representation of the file system ID.
|
||||
@inline(never)
|
||||
public var description: String {
|
||||
"FileSystemID(\(_words.0), \(_words.1))"
|
||||
}
|
||||
|
||||
/// A textual representation of the file system ID, suitable for debugging.
|
||||
public var debugDescription: String { self.description }
|
||||
}
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
// MARK: - FileSystemType
|
||||
|
||||
/// A Swift wrapper of the C `f_type` file system type found in a `statfs`
|
||||
/// struct.
|
||||
///
|
||||
/// - Note: Only available on Linux and Android.
|
||||
@frozen
|
||||
@available(System 1.9.0, *)
|
||||
public struct FileSystemType: RawRepresentable, Sendable, Hashable, Codable {
|
||||
|
||||
/// The raw C file system type.
|
||||
@_alwaysEmitIntoClient
|
||||
public var rawValue: UInt32
|
||||
|
||||
/// Creates a strongly-typed `FileSystemType` from the raw C value.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(rawValue: UInt32) { self.rawValue = rawValue }
|
||||
|
||||
/// Creates a strongly-typed `FileSystemType` from the raw C value.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(_ rawValue: UInt32) { self.rawValue = rawValue }
|
||||
}
|
||||
#endif // os(Linux) || os(Android)
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
// MARK: - FileSystemSubtype
|
||||
|
||||
/// A Swift wrapper of the C `f_fssubtype` file system subtype found in a
|
||||
/// `statfs` struct on Darwin.
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
@frozen
|
||||
@available(System 1.9.0, *)
|
||||
public struct FileSystemSubtype: RawRepresentable, Sendable, Hashable, Codable {
|
||||
|
||||
/// The raw C file system subtype.
|
||||
@_alwaysEmitIntoClient
|
||||
public var rawValue: UInt32
|
||||
|
||||
/// Creates a strongly-typed `FileSystemSubtype` from the raw C value.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(rawValue: UInt32) { self.rawValue = rawValue }
|
||||
|
||||
/// Creates a strongly-typed `FileSystemSubtype` from the raw C value.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(_ rawValue: UInt32) { self.rawValue = rawValue }
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
// MARK: - FileSystemTypeName
|
||||
|
||||
/// A Swift wrapper of the C `f_fstypename` file system type name found in a
|
||||
/// `statfs` struct.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
@frozen
|
||||
@available(System 1.9.0, *)
|
||||
public struct FileSystemTypeName
|
||||
: RawRepresentable, Sendable, Hashable, Codable, ExpressibleByStringLiteral
|
||||
{
|
||||
|
||||
/// The raw file system type name.
|
||||
@_alwaysEmitIntoClient
|
||||
public var rawValue: String
|
||||
|
||||
/// Creates a strongly-typed `FileSystemTypeName` from the raw name.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(rawValue: String) { self.rawValue = rawValue }
|
||||
|
||||
/// Creates a strongly-typed `FileSystemTypeName` from the raw name.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(_ rawValue: String) { self.rawValue = rawValue }
|
||||
|
||||
/// Creates a `FileSystemTypeName` from a string literal, such as `"apfs"`.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(stringLiteral value: String) { self.rawValue = value }
|
||||
|
||||
// MARK: Type Names Available on Darwin Only
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
/// The Apple File System (APFS).
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding `f_fstypename` value is `"apfs"`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var apfs: FileSystemTypeName { FileSystemTypeName(rawValue: "apfs") }
|
||||
|
||||
/// The Mac OS Extended file system (HFS Plus).
|
||||
///
|
||||
/// - Note: Only available on Darwin.
|
||||
///
|
||||
/// The corresponding `f_fstypename` value is `"hfs"`.
|
||||
@_alwaysEmitIntoClient
|
||||
public static var hfs: FileSystemTypeName { FileSystemTypeName(rawValue: "hfs") }
|
||||
#endif
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension FileSystemTypeName: CustomStringConvertible, CustomDebugStringConvertible {
|
||||
/// The file system type name, such as `apfs`.
|
||||
@inline(never)
|
||||
public var description: String { rawValue }
|
||||
|
||||
/// The file system type name as a quoted string, such as `"apfs"`.
|
||||
public var debugDescription: String { description.debugDescription }
|
||||
}
|
||||
#endif // SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
|
||||
// MARK: - StatFS
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
// Helpers for reading the fixed-size, NUL-terminated C character buffers
|
||||
// (`f_fstypename`, `f_mntonname`, `f_mntfromname`) in Darwin/BSD `statfs`.
|
||||
// If the buffer has no NUL (malformed), the entire buffer is used.
|
||||
@available(System 1.9.0, *)
|
||||
extension String {
|
||||
@usableFromInline
|
||||
internal init(_nullTerminatedBytes buffer: UnsafeRawBufferPointer) {
|
||||
let bytes = buffer.prefix { $0 != 0 }
|
||||
self = String(decoding: bytes, as: CInterop.PlatformUnicodeEncoding.self)
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension FilePath {
|
||||
@usableFromInline
|
||||
internal init(_nullTerminatedBytes buffer: UnsafeRawBufferPointer) {
|
||||
let chars = buffer.bindMemory(to: CInterop.PlatformChar.self)
|
||||
guard let base = chars.baseAddress else {
|
||||
self = FilePath()
|
||||
return
|
||||
}
|
||||
self = if chars.firstIndex(of: 0) != nil {
|
||||
FilePath(platformString: base)
|
||||
} else {
|
||||
withUnsafeTemporaryAllocation(
|
||||
of: CInterop.PlatformChar.self,
|
||||
capacity: chars.count + 1
|
||||
) { terminatedBuffer in
|
||||
terminatedBuffer.baseAddress!.initialize(from: base, count: chars.count)
|
||||
terminatedBuffer[chars.count] = 0
|
||||
return FilePath(platformString: terminatedBuffer.baseAddress!)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/// A Swift wrapper of the C `statfs` struct.
|
||||
///
|
||||
/// - Note: Not available on Windows or WASI.
|
||||
/// - Note: The numeric properties clamp when converting to or from the
|
||||
/// underlying C field. Use `rawValue` for exact, unclamped access.
|
||||
@frozen
|
||||
@available(System 1.9.0, *)
|
||||
public struct StatFS: RawRepresentable, Sendable, Hashable {
|
||||
|
||||
/// The raw C `statfs` struct.
|
||||
@_alwaysEmitIntoClient
|
||||
public var rawValue: CInterop.StatFS
|
||||
|
||||
/// Creates a Swift `StatFS` from the raw C struct.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(rawValue: CInterop.StatFS) { self.rawValue = rawValue }
|
||||
|
||||
// MARK: Initializers
|
||||
|
||||
/// Creates a `StatFS` from a `FilePath`.
|
||||
///
|
||||
/// The corresponding C function is `statfs()`.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(
|
||||
_ path: FilePath,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
self.rawValue = try path.withPlatformString {
|
||||
Self._statfs($0, retryOnInterrupt: retryOnInterrupt)
|
||||
}.get()
|
||||
}
|
||||
|
||||
/// Creates a `StatFS` from a null-terminated `UnsafePointer<CChar>` path.
|
||||
///
|
||||
/// The corresponding C function is `statfs()`.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(
|
||||
_ path: UnsafePointer<CChar>,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
self.rawValue = try Self._statfs(
|
||||
path, retryOnInterrupt: retryOnInterrupt
|
||||
).get()
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal static func _statfs(
|
||||
_ path: UnsafePointer<CChar>,
|
||||
retryOnInterrupt: Bool
|
||||
) -> Result<CInterop.StatFS, Errno> {
|
||||
var result = CInterop.StatFS()
|
||||
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
|
||||
system_statfs(path, &result)
|
||||
}.map { result }
|
||||
}
|
||||
|
||||
/// Creates a `StatFS` from a `FileDescriptor`.
|
||||
///
|
||||
/// The corresponding C function is `fstatfs()`.
|
||||
@_alwaysEmitIntoClient
|
||||
public init(
|
||||
_ fd: FileDescriptor,
|
||||
retryOnInterrupt: Bool = true
|
||||
) throws(Errno) {
|
||||
self.rawValue = try Self._fstatfs(
|
||||
fd, retryOnInterrupt: retryOnInterrupt
|
||||
).get()
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal static func _fstatfs(
|
||||
_ fd: FileDescriptor,
|
||||
retryOnInterrupt: Bool
|
||||
) -> Result<CInterop.StatFS, Errno> {
|
||||
var result = CInterop.StatFS()
|
||||
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
|
||||
system_fstatfs(fd.rawValue, &result)
|
||||
}.map { result }
|
||||
}
|
||||
|
||||
// MARK: Properties
|
||||
|
||||
/// File system block size, in bytes.
|
||||
///
|
||||
/// - Note: On Darwin and BSD, this is the fundamental size for block counts.
|
||||
/// Other platforms use `fragmentSize` (`f_frsize`) instead.
|
||||
///
|
||||
/// The corresponding C property is `f_bsize`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var blockSize: Int {
|
||||
get { Int(clamping: rawValue.f_bsize) }
|
||||
set { rawValue.f_bsize = .init(clamping: newValue) }
|
||||
}
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
/// Block size for optimal data transfer, in bytes.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_iosize`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var preferredIOBlockSize: Int {
|
||||
get { Int(clamping: rawValue.f_iosize) }
|
||||
set { rawValue.f_iosize = .init(clamping: newValue) }
|
||||
}
|
||||
#else
|
||||
/// File system fragment size, in bytes.
|
||||
///
|
||||
/// - Note: On Linux and Android, this is the fundamental size for block
|
||||
/// counts. Not present on Darwin or BSD, which use `blockSize` instead.
|
||||
///
|
||||
/// The corresponding C property is `f_frsize`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var fragmentSize: Int {
|
||||
get { Int(clamping: rawValue.f_frsize) }
|
||||
set { rawValue.f_frsize = .init(clamping: newValue) }
|
||||
}
|
||||
#endif
|
||||
|
||||
/// The fundamental block size used for space calculations, in bytes.
|
||||
///
|
||||
/// This is `blockSize` on Darwin and BSD, or `fragmentSize` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _fundamentalBlockSize: UInt64 {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
UInt64(clamping: rawValue.f_bsize)
|
||||
#else
|
||||
UInt64(clamping: rawValue.f_frsize)
|
||||
#endif
|
||||
}
|
||||
|
||||
@_alwaysEmitIntoClient
|
||||
internal func _saturatingSpace(_ blocks: UInt64) -> UInt64 {
|
||||
let (result, overflow) = blocks.multipliedReportingOverflow(by: _fundamentalBlockSize)
|
||||
return overflow ? .max : result
|
||||
}
|
||||
|
||||
/// Total number of blocks in the file system.
|
||||
///
|
||||
/// - Note: In units of `blockSize` on Darwin and BSD, or `fragmentSize`
|
||||
/// otherwise.
|
||||
///
|
||||
/// The corresponding C property is `f_blocks`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var totalBlocks: UInt64 {
|
||||
get { UInt64(clamping: rawValue.f_blocks) }
|
||||
set { rawValue.f_blocks = .init(clamping: newValue) }
|
||||
}
|
||||
|
||||
/// Total size of the file system, in bytes.
|
||||
///
|
||||
/// - Note: Computed for convenience as `totalBlocks` times the fundamental
|
||||
/// block size (see `totalBlocks`). Saturates to `UInt64.max` on overflow.
|
||||
@_alwaysEmitIntoClient
|
||||
public var totalSpace: UInt64 { _saturatingSpace(totalBlocks) }
|
||||
|
||||
/// Number of free blocks in the file system.
|
||||
///
|
||||
/// - Note: In units of `blockSize` on Darwin and BSD, or `fragmentSize`
|
||||
/// otherwise.
|
||||
///
|
||||
/// The corresponding C property is `f_bfree`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var freeBlocks: UInt64 {
|
||||
get { UInt64(clamping: rawValue.f_bfree) }
|
||||
set { rawValue.f_bfree = .init(clamping: newValue) }
|
||||
}
|
||||
|
||||
/// Free space in the file system, in bytes.
|
||||
///
|
||||
/// - Note: Computed for convenience as `freeBlocks` times the fundamental
|
||||
/// block size (see `freeBlocks`). Saturates to `UInt64.max` on overflow.
|
||||
@_alwaysEmitIntoClient
|
||||
public var freeSpace: UInt64 { _saturatingSpace(freeBlocks) }
|
||||
|
||||
/// Number of free blocks available to non-superuser.
|
||||
///
|
||||
/// - Note: In units of `blockSize` on Darwin and BSD, or `fragmentSize`
|
||||
/// otherwise. On FreeBSD and OpenBSD, the underlying C property is
|
||||
/// signed; negative values are clamped to 0.
|
||||
///
|
||||
/// The corresponding C property is `f_bavail`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var availableBlocks: UInt64 {
|
||||
get { UInt64(clamping: rawValue.f_bavail) }
|
||||
set { rawValue.f_bavail = .init(clamping: newValue) }
|
||||
}
|
||||
|
||||
/// Available space in the file system for non-superuser, in bytes.
|
||||
///
|
||||
/// - Note: Computed for convenience as `availableBlocks` times the fundamental
|
||||
/// block size (see `availableBlocks`). Saturates to `UInt64.max` on overflow.
|
||||
@_alwaysEmitIntoClient
|
||||
public var availableSpace: UInt64 { _saturatingSpace(availableBlocks) }
|
||||
|
||||
/// Total number of inodes in the file system.
|
||||
///
|
||||
/// The corresponding C property is `f_files`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var totalInodes: UInt64 {
|
||||
get { UInt64(clamping: rawValue.f_files) }
|
||||
set { rawValue.f_files = .init(clamping: newValue) }
|
||||
}
|
||||
|
||||
/// Number of free inodes in the file system.
|
||||
///
|
||||
/// - Note: On FreeBSD, this reports the inodes available to a non-superuser
|
||||
/// rather than the total free count, and the underlying C field is signed
|
||||
/// (negative values are clamped to 0); on other platforms, it is the total
|
||||
/// number of free inodes.
|
||||
///
|
||||
/// The corresponding C property is `f_ffree`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var freeInodes: UInt64 {
|
||||
get { UInt64(clamping: rawValue.f_ffree) }
|
||||
set { rawValue.f_ffree = .init(clamping: newValue) }
|
||||
}
|
||||
|
||||
#if os(OpenBSD)
|
||||
/// Number of free inodes available to non-superuser.
|
||||
///
|
||||
/// - Note: Darwin, FreeBSD, Linux, and Android `statfs` do not report it.
|
||||
/// On OpenBSD, the underlying C property is signed; negative values are
|
||||
/// clamped to 0.
|
||||
///
|
||||
/// The corresponding C property is `f_favail`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var availableInodes: UInt64 {
|
||||
get { UInt64(clamping: rawValue.f_favail) }
|
||||
set { rawValue.f_favail = .init(clamping: newValue) }
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !SYSTEM_PACKAGE_DARWIN
|
||||
/// Maximum length of a file name on the file system, in bytes.
|
||||
///
|
||||
/// - Note: Darwin's `statfs` does not report it.
|
||||
///
|
||||
/// The corresponding C property is `f_namelen` on Linux and Android, or
|
||||
/// `f_namemax` otherwise.
|
||||
@_alwaysEmitIntoClient
|
||||
public var maximumNameLength: Int {
|
||||
get {
|
||||
#if os(Linux) || os(Android)
|
||||
Int(clamping: rawValue.f_namelen)
|
||||
#else
|
||||
Int(clamping: rawValue.f_namemax)
|
||||
#endif
|
||||
}
|
||||
set {
|
||||
#if os(Linux) || os(Android)
|
||||
rawValue.f_namelen = .init(clamping: newValue)
|
||||
#else
|
||||
rawValue.f_namemax = .init(clamping: newValue)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/// File system ID.
|
||||
///
|
||||
/// The corresponding C property is `f_fsid`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var fileSystemID: FileSystemID {
|
||||
get { FileSystemID(rawValue: rawValue.f_fsid) }
|
||||
set { rawValue.f_fsid = newValue.rawValue }
|
||||
}
|
||||
|
||||
/// Flags describing how the file system is mounted.
|
||||
///
|
||||
/// - Note: On Linux, the kernel also sets an `ST_VALID` bit in `f_flags`
|
||||
/// to mark the field as filled in. It isn't a mount flag, so this
|
||||
/// property omits it like glibc's `statvfs` and Bionic's `statfs` do.
|
||||
/// The setter preserves it.
|
||||
///
|
||||
/// The corresponding C property is `f_flags`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var mountFlags: MountFlags {
|
||||
get {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
MountFlags(rawValue: rawValue.f_flags)
|
||||
#elseif os(Linux) || os(Android)
|
||||
MountFlags(rawValue: CInterop.MountFlags(truncatingIfNeeded: rawValue.f_flags) & ~_ST_VALID_BIT)
|
||||
#endif
|
||||
}
|
||||
set {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
rawValue.f_flags = newValue.rawValue
|
||||
#elseif os(Linux) || os(Android)
|
||||
let valid = CInterop.MountFlags(truncatingIfNeeded: rawValue.f_flags) & _ST_VALID_BIT
|
||||
rawValue.f_flags = .init(truncatingIfNeeded: newValue.rawValue | valid)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
/// File system type.
|
||||
///
|
||||
/// - Note: This is the file system's magic number, such as `0xEF53` for
|
||||
/// ext4. Only available on Linux and Android. On Darwin and BSD, use
|
||||
/// `typeName` to identify the file system.
|
||||
///
|
||||
/// The corresponding C property is `f_type`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var type: FileSystemType {
|
||||
get {
|
||||
// glibc's `f_type` is a signed `long` and can be negative.
|
||||
FileSystemType(rawValue: UInt32(truncatingIfNeeded: rawValue.f_type))
|
||||
}
|
||||
set {
|
||||
rawValue.f_type = .init(truncatingIfNeeded: newValue.rawValue)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
/// File system subtype.
|
||||
///
|
||||
/// - Note: This is a numeric value whose meaning depends on `typeName`,
|
||||
/// with no stable, public constants. Only available on Darwin.
|
||||
///
|
||||
/// The corresponding C property is `f_fssubtype`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var subtype: FileSystemSubtype {
|
||||
get { FileSystemSubtype(rawValue: rawValue.f_fssubtype) }
|
||||
set { rawValue.f_fssubtype = newValue.rawValue }
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
/// User that mounted the file system.
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_owner`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var owner: UserID {
|
||||
get { UserID(rawValue: rawValue.f_owner) }
|
||||
set { rawValue.f_owner = newValue.rawValue }
|
||||
}
|
||||
|
||||
/// File system type name, such as "apfs".
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_fstypename`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var typeName: FileSystemTypeName {
|
||||
FileSystemTypeName(rawValue: withUnsafeBytes(of: rawValue.f_fstypename) {
|
||||
String(_nullTerminatedBytes: $0)
|
||||
})
|
||||
}
|
||||
|
||||
/// Directory where the file system is mounted, such as "/System/Volumes/Data".
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_mntonname`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var mountPoint: FilePath {
|
||||
withUnsafeBytes(of: rawValue.f_mntonname) {
|
||||
FilePath(_nullTerminatedBytes: $0)
|
||||
}
|
||||
}
|
||||
|
||||
/// The source of the mounted file system, such as "/dev/disk3s7".
|
||||
///
|
||||
/// - Note: Only available on Darwin and BSD.
|
||||
///
|
||||
/// The corresponding C property is `f_mntfromname`.
|
||||
@_alwaysEmitIntoClient
|
||||
public var mountSource: FilePath {
|
||||
withUnsafeBytes(of: rawValue.f_mntfromname) {
|
||||
FilePath(_nullTerminatedBytes: $0)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// MARK: - StatFS Equatable & Hashable
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
extension StatFS {
|
||||
/// Compares the file system metadata fields of two `StatFS` values,
|
||||
/// including fields not exposed as properties, such as `f_flags_ext` on
|
||||
/// Darwin.
|
||||
///
|
||||
/// Fields are compared by their raw C values. Reserved/"spare" fields and
|
||||
/// OpenBSD's `mount_info` union are not compared. Name buffers are compared
|
||||
/// only up to their NUL terminators.
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
guard lhs.rawValue.f_bsize == rhs.rawValue.f_bsize,
|
||||
lhs.rawValue.f_blocks == rhs.rawValue.f_blocks,
|
||||
lhs.rawValue.f_bfree == rhs.rawValue.f_bfree,
|
||||
lhs.rawValue.f_bavail == rhs.rawValue.f_bavail,
|
||||
lhs.rawValue.f_files == rhs.rawValue.f_files,
|
||||
lhs.rawValue.f_ffree == rhs.rawValue.f_ffree,
|
||||
lhs.fileSystemID == rhs.fileSystemID else {
|
||||
return false
|
||||
}
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
guard lhs.rawValue.f_iosize == rhs.rawValue.f_iosize,
|
||||
lhs.rawValue.f_flags == rhs.rawValue.f_flags,
|
||||
lhs.rawValue.f_owner == rhs.rawValue.f_owner,
|
||||
_nullTerminatedBytesEqual(lhs.rawValue.f_fstypename,
|
||||
rhs.rawValue.f_fstypename),
|
||||
_nullTerminatedBytesEqual(lhs.rawValue.f_mntonname,
|
||||
rhs.rawValue.f_mntonname),
|
||||
_nullTerminatedBytesEqual(lhs.rawValue.f_mntfromname,
|
||||
rhs.rawValue.f_mntfromname) else {
|
||||
return false
|
||||
}
|
||||
#elseif os(Linux) || os(Android)
|
||||
guard lhs.rawValue.f_type == rhs.rawValue.f_type,
|
||||
lhs.rawValue.f_frsize == rhs.rawValue.f_frsize,
|
||||
lhs.rawValue.f_flags == rhs.rawValue.f_flags,
|
||||
lhs.rawValue.f_namelen == rhs.rawValue.f_namelen else {
|
||||
return false
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
guard lhs.rawValue.f_type == rhs.rawValue.f_type,
|
||||
lhs.rawValue.f_fssubtype == rhs.rawValue.f_fssubtype,
|
||||
lhs.rawValue.f_flags_ext == rhs.rawValue.f_flags_ext else {
|
||||
return false
|
||||
}
|
||||
#elseif os(FreeBSD)
|
||||
guard lhs.rawValue.f_version == rhs.rawValue.f_version,
|
||||
lhs.rawValue.f_type == rhs.rawValue.f_type,
|
||||
lhs.rawValue.f_namemax == rhs.rawValue.f_namemax,
|
||||
lhs.rawValue.f_syncwrites == rhs.rawValue.f_syncwrites,
|
||||
lhs.rawValue.f_asyncwrites == rhs.rawValue.f_asyncwrites,
|
||||
lhs.rawValue.f_syncreads == rhs.rawValue.f_syncreads,
|
||||
lhs.rawValue.f_asyncreads == rhs.rawValue.f_asyncreads else {
|
||||
return false
|
||||
}
|
||||
#elseif os(OpenBSD)
|
||||
guard lhs.rawValue.f_favail == rhs.rawValue.f_favail,
|
||||
lhs.rawValue.f_namemax == rhs.rawValue.f_namemax,
|
||||
lhs.rawValue.f_syncwrites == rhs.rawValue.f_syncwrites,
|
||||
lhs.rawValue.f_syncreads == rhs.rawValue.f_syncreads,
|
||||
lhs.rawValue.f_asyncwrites == rhs.rawValue.f_asyncwrites,
|
||||
lhs.rawValue.f_asyncreads == rhs.rawValue.f_asyncreads,
|
||||
lhs.rawValue.f_ctime == rhs.rawValue.f_ctime,
|
||||
_nullTerminatedBytesEqual(lhs.rawValue.f_mntfromspec,
|
||||
rhs.rawValue.f_mntfromspec) else {
|
||||
return false
|
||||
}
|
||||
#endif
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
/// Hashes the file system metadata fields of a `StatFS` struct.
|
||||
///
|
||||
/// These are the same fields compared by `==`. Reserved/"spare" fields are
|
||||
/// not hashed, and name buffers are hashed only up to their NUL terminators.
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(rawValue.f_bsize)
|
||||
hasher.combine(rawValue.f_blocks)
|
||||
hasher.combine(rawValue.f_bfree)
|
||||
hasher.combine(rawValue.f_bavail)
|
||||
hasher.combine(rawValue.f_files)
|
||||
hasher.combine(rawValue.f_ffree)
|
||||
hasher.combine(fileSystemID)
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
hasher.combine(rawValue.f_iosize)
|
||||
hasher.combine(rawValue.f_flags)
|
||||
hasher.combine(rawValue.f_owner)
|
||||
Self._combineNullTerminatedBytes(rawValue.f_fstypename, into: &hasher)
|
||||
Self._combineNullTerminatedBytes(rawValue.f_mntonname, into: &hasher)
|
||||
Self._combineNullTerminatedBytes(rawValue.f_mntfromname, into: &hasher)
|
||||
#elseif os(Linux) || os(Android)
|
||||
hasher.combine(rawValue.f_type)
|
||||
hasher.combine(rawValue.f_frsize)
|
||||
hasher.combine(rawValue.f_flags)
|
||||
hasher.combine(rawValue.f_namelen)
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
hasher.combine(rawValue.f_type)
|
||||
hasher.combine(rawValue.f_fssubtype)
|
||||
hasher.combine(rawValue.f_flags_ext)
|
||||
#elseif os(FreeBSD)
|
||||
hasher.combine(rawValue.f_version)
|
||||
hasher.combine(rawValue.f_type)
|
||||
hasher.combine(rawValue.f_namemax)
|
||||
hasher.combine(rawValue.f_syncwrites)
|
||||
hasher.combine(rawValue.f_asyncwrites)
|
||||
hasher.combine(rawValue.f_syncreads)
|
||||
hasher.combine(rawValue.f_asyncreads)
|
||||
#elseif os(OpenBSD)
|
||||
hasher.combine(rawValue.f_favail)
|
||||
hasher.combine(rawValue.f_namemax)
|
||||
hasher.combine(rawValue.f_syncwrites)
|
||||
hasher.combine(rawValue.f_syncreads)
|
||||
hasher.combine(rawValue.f_asyncwrites)
|
||||
hasher.combine(rawValue.f_asyncreads)
|
||||
hasher.combine(rawValue.f_ctime)
|
||||
Self._combineNullTerminatedBytes(rawValue.f_mntfromspec, into: &hasher)
|
||||
#endif
|
||||
}
|
||||
|
||||
@inline(__always)
|
||||
private static func _nullTerminatedBytesEqual<T>(_ lhs: T, _ rhs: T) -> Bool {
|
||||
withUnsafeBytes(of: lhs) { lhsBytes in
|
||||
withUnsafeBytes(of: rhs) { rhsBytes in
|
||||
lhsBytes.prefix { $0 != 0 }.elementsEqual(rhsBytes.prefix { $0 != 0 })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Feeds the length first so adjacent buffers can't run together.
|
||||
@inline(__always)
|
||||
private static func _combineNullTerminatedBytes<T>(
|
||||
_ value: T, into hasher: inout Hasher
|
||||
) {
|
||||
withUnsafeBytes(of: value) { buffer in
|
||||
let bytes = buffer.prefix { $0 != 0 }
|
||||
hasher.combine(bytes.count)
|
||||
hasher.combine(bytes: .init(rebasing: bytes))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // !os(Windows) && !os(WASI)
|
||||
@@ -10,7 +10,7 @@
|
||||
#if compiler(>=6.2) && $Lifetimes
|
||||
#if os(Linux)
|
||||
|
||||
import CSystem
|
||||
public import CSystemIOUring
|
||||
|
||||
public extension IORing {
|
||||
struct Completion: ~Copyable {
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
#if compiler(>=6.2) && $Lifetimes
|
||||
#if os(Linux)
|
||||
|
||||
import CSystem
|
||||
public import CSystemIOUring
|
||||
|
||||
@usableFromInline
|
||||
internal enum IORequestCore {
|
||||
@@ -368,6 +368,8 @@ extension IORing.Request {
|
||||
.init(core: .write(file: file, buffer: buffer, offset: offset, context: context))
|
||||
}
|
||||
|
||||
@available(*, deprecated, message: "Use the overload accepting UnsafeRawBufferPointer instead.")
|
||||
@_disfavoredOverload
|
||||
@inlinable public static func write(
|
||||
_ buffer: UnsafeMutableRawBufferPointer,
|
||||
into file: IORing.RegisteredFile,
|
||||
@@ -378,6 +380,8 @@ extension IORing.Request {
|
||||
file: file, buffer: buffer, offset: offset, context: context))
|
||||
}
|
||||
|
||||
@available(*, deprecated, message: "Use the overload accepting UnsafeRawBufferPointer instead.")
|
||||
@_disfavoredOverload
|
||||
@inlinable public static func write(
|
||||
_ buffer: UnsafeMutableRawBufferPointer,
|
||||
into file: FileDescriptor,
|
||||
@@ -389,6 +393,60 @@ extension IORing.Request {
|
||||
)
|
||||
}
|
||||
|
||||
/// Creates a request to write an unregistered buffer to a registered file.
|
||||
///
|
||||
/// The request does not copy the buffer's contents. Keep its storage alive
|
||||
/// and unchanged until the operation completes. The write only reads from
|
||||
/// the buffer; it does not modify its contents.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - buffer: The bytes to write.
|
||||
/// - file: The registered file to write to.
|
||||
/// - offset: The byte offset in the file at which to begin writing.
|
||||
/// Ignored for non-seekable files. Defaults to `0`.
|
||||
/// - context: An application-specific value passed through to the
|
||||
/// completion event. Defaults to `0`.
|
||||
/// - Returns: An I/O ring write request. A successful completion's result
|
||||
/// is the number of bytes written, which may be less than the buffer's count.
|
||||
@inlinable public static func write(
|
||||
_ buffer: UnsafeRawBufferPointer,
|
||||
into file: IORing.RegisteredFile,
|
||||
at offset: UInt64 = 0,
|
||||
context: UInt64 = 0
|
||||
) -> IORing.Request {
|
||||
// The shared request encoder uses a mutable pointer, but writes only read the buffer.
|
||||
.init(core: .writeUnregisteredSlot(
|
||||
file: file, buffer: UnsafeMutableRawBufferPointer(mutating: buffer), offset: offset, context: context
|
||||
))
|
||||
}
|
||||
|
||||
/// Creates a request to write an unregistered buffer to a file descriptor.
|
||||
///
|
||||
/// The request does not copy the buffer's contents. Keep its storage alive
|
||||
/// and unchanged until the operation completes. The write only reads from
|
||||
/// the buffer; it does not modify its contents.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - buffer: The bytes to write.
|
||||
/// - file: The file descriptor to write to.
|
||||
/// - offset: The byte offset in the file at which to begin writing.
|
||||
/// Ignored for non-seekable files. Defaults to `0`.
|
||||
/// - context: An application-specific value passed through to the
|
||||
/// completion event. Defaults to `0`.
|
||||
/// - Returns: An I/O ring write request. A successful completion's result
|
||||
/// is the number of bytes written, which may be less than the buffer's count.
|
||||
@inlinable public static func write(
|
||||
_ buffer: UnsafeRawBufferPointer,
|
||||
into file: FileDescriptor,
|
||||
at offset: UInt64 = 0,
|
||||
context: UInt64 = 0
|
||||
) -> IORing.Request {
|
||||
// The shared request encoder uses a mutable pointer, but writes only read the buffer.
|
||||
.init(core: .writeUnregistered(
|
||||
file: file, buffer: UnsafeMutableRawBufferPointer(mutating: buffer), offset: offset, context: context
|
||||
))
|
||||
}
|
||||
|
||||
@inlinable public static func close(
|
||||
_ file: FileDescriptor,
|
||||
context: UInt64 = 0
|
||||
|
||||
@@ -10,14 +10,15 @@
|
||||
#if compiler(>=6.2) && $Lifetimes
|
||||
#if os(Linux)
|
||||
|
||||
import CSystem
|
||||
internal import CSystem
|
||||
public import CSystemIOUring
|
||||
#if canImport(Glibc)
|
||||
import Glibc
|
||||
#elseif canImport(Musl)
|
||||
import Musl
|
||||
#endif
|
||||
|
||||
/// Throwing wrapper around the `io_uring_enter2` shim.
|
||||
/// Throwing wrapper around the `csystem_io_uring_enter2` shim.
|
||||
///
|
||||
/// On success returns the syscall's non-negative result (the number of SQEs
|
||||
/// consumed by the kernel). On failure, reads `errno` and throws the matching
|
||||
@@ -32,14 +33,14 @@ internal func _ioUringEnter2(
|
||||
argsSize: Int
|
||||
) throws(Errno) -> Int32 {
|
||||
let result = valueOrErrno(retryOnInterrupt: true) {
|
||||
io_uring_enter2(
|
||||
csystem_io_uring_enter2(
|
||||
ringDescriptor, toSubmit, minComplete, flags, args, argsSize
|
||||
)
|
||||
}
|
||||
return try result.get()
|
||||
}
|
||||
|
||||
/// Throwing wrapper around the `io_uring_enter` shim.
|
||||
/// Throwing wrapper around the `csystem_io_uring_enter` shim.
|
||||
///
|
||||
/// On success returns the syscall's non-negative result (the number of SQEs
|
||||
/// consumed by the kernel). On failure, reads `errno` and throws the matching
|
||||
@@ -53,12 +54,12 @@ internal func _ioUringEnter(
|
||||
sig: UnsafeMutablePointer<sigset_t>?
|
||||
) throws(Errno) -> Int32 {
|
||||
let result = valueOrErrno(retryOnInterrupt: true) {
|
||||
io_uring_enter(ringDescriptor, toSubmit, minComplete, flags, sig)
|
||||
csystem_io_uring_enter(ringDescriptor, toSubmit, minComplete, flags, sig)
|
||||
}
|
||||
return try result.get()
|
||||
}
|
||||
|
||||
/// Throwing wrapper around the `io_uring_register` shim.
|
||||
/// Throwing wrapper around the `csystem_io_uring_register` shim.
|
||||
///
|
||||
/// On success returns the syscall's non-negative result. On failure, reads
|
||||
/// `errno` and throws the matching `Errno`. `EINTR` is retried automatically.
|
||||
@@ -70,7 +71,7 @@ internal func _ioUringRegister(
|
||||
nrArgs: UInt32
|
||||
) throws(Errno) -> Int32 {
|
||||
let result = valueOrErrno(retryOnInterrupt: true) {
|
||||
io_uring_register(ringDescriptor, opcode, arg, nrArgs)
|
||||
csystem_io_uring_register(ringDescriptor, opcode, arg, nrArgs)
|
||||
}
|
||||
return try result.get()
|
||||
}
|
||||
|
||||
@@ -10,7 +10,8 @@
|
||||
#if compiler(>=6.2) && $Lifetimes
|
||||
#if os(Linux)
|
||||
|
||||
import CSystem
|
||||
internal import CSystem
|
||||
public import CSystemIOUring
|
||||
// needed for mmap
|
||||
#if canImport(Glibc)
|
||||
import Glibc
|
||||
@@ -232,7 +233,7 @@ private func setUpRing(
|
||||
|
||||
var err: Errno? = nil
|
||||
let ringDescriptor = withUnsafeMutablePointer(to: ¶ms) {
|
||||
let result = io_uring_setup(queueDepth, $0)
|
||||
let result = csystem_io_uring_setup(queueDepth, $0)
|
||||
if result < 0 {
|
||||
err = Errno.current
|
||||
}
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
#if compiler(>=6.2) && $Lifetimes
|
||||
#if os(Linux)
|
||||
|
||||
import CSystem
|
||||
public import CSystemIOUring
|
||||
#if canImport(Glibc)
|
||||
import Glibc
|
||||
#elseif canImport(Musl)
|
||||
|
||||
@@ -10,19 +10,20 @@
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import CSystem
|
||||
import ucrt
|
||||
#elseif canImport(Glibc)
|
||||
import CSystem
|
||||
#if os(Linux)
|
||||
// SwiftGlibc doesn't export `struct statfs`, so re-export it for clients who
|
||||
// need to use the fields of a `CInterop.StatFS`.
|
||||
@_exported import CSystemStatFS
|
||||
#endif
|
||||
import Glibc
|
||||
#elseif canImport(Musl)
|
||||
import CSystem
|
||||
import Musl
|
||||
#elseif canImport(WASILibc)
|
||||
import WASILibc
|
||||
#elseif canImport(Bionic)
|
||||
import CSystem
|
||||
import Bionic
|
||||
#elseif canImport(Android)
|
||||
import Android
|
||||
#else
|
||||
#error("Unsupported Platform")
|
||||
#endif
|
||||
@@ -116,4 +117,22 @@ extension CInterop {
|
||||
public typealias FileFlags = UInt32
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !os(WASI)
|
||||
@available(System 1.9.0, *)
|
||||
extension CInterop {
|
||||
/// The C `statfs` struct.
|
||||
public typealias StatFS = statfs
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(OpenBSD)
|
||||
public typealias MountFlags = UInt32
|
||||
#elseif os(FreeBSD)
|
||||
public typealias MountFlags = UInt64
|
||||
#else
|
||||
public typealias MountFlags = CUnsignedLong
|
||||
#endif
|
||||
|
||||
public typealias FileSystemID = fsid_t
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -11,11 +11,11 @@
|
||||
// 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 ucrt
|
||||
import WinSDK
|
||||
#elseif canImport(Glibc)
|
||||
import Glibc
|
||||
#elseif canImport(Musl)
|
||||
@@ -28,6 +28,11 @@ import Android
|
||||
#error("Unsupported Platform")
|
||||
#endif
|
||||
|
||||
// Some WASI constants come from CSystem and are inlined into clients.
|
||||
#if os(WASI)
|
||||
public import CSystem
|
||||
#endif
|
||||
|
||||
// MARK: errno
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
@_alwaysEmitIntoClient
|
||||
@@ -629,7 +634,7 @@ internal var _O_CLOEXEC: CInt {
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _O_CLOFORK: CInt {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
|
||||
COMPATIBILITY_O_CLOFORK
|
||||
0x0800_0000 // O_CLOFORK, which SDKs before macOS 27 and older FreeBSD lack
|
||||
#elseif !os(WASI) && !os(Linux) && !os(Android)
|
||||
O_CLOFORK
|
||||
#else
|
||||
@@ -796,4 +801,340 @@ internal var _UF_SYSTEM: UInt32 { UInt32(bitPattern: UF_SYSTEM) }
|
||||
internal var _SF_SNAPSHOT: UInt32 { UInt32(bitPattern: SF_SNAPSHOT) }
|
||||
#endif
|
||||
|
||||
// MARK: - statfs Mount Flags
|
||||
|
||||
// `_MOUNT_*` is `MNT_*` on Darwin and BSD, or `ST_*` on Linux and Android.
|
||||
|
||||
#if !os(WASI)
|
||||
|
||||
// MARK: ST_* bits on Linux and Android
|
||||
|
||||
// Literal bits to keep our `@_alwaysEmitIntoClient` semantics. Calling
|
||||
// CSystem's `_system_get_ST_*` getters would put a CSystem symbol in every
|
||||
// client, block constant folding, and require a public `import CSystem`.
|
||||
// `StatFSTests.mountFlagBitsMatchLibc` checks the literals against libc.
|
||||
#if os(Linux) || os(Android)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_RDONLY_BIT: CInterop.MountFlags { 0x0001 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_NOSUID_BIT: CInterop.MountFlags { 0x0002 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_NODEV_BIT: CInterop.MountFlags { 0x0004 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_NOEXEC_BIT: CInterop.MountFlags { 0x0008 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_SYNCHRONOUS_BIT: CInterop.MountFlags { 0x0010 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_MANDLOCK_BIT: CInterop.MountFlags { 0x0040 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_NOATIME_BIT: CInterop.MountFlags { 0x0400 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_NODIRATIME_BIT: CInterop.MountFlags { 0x0800 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_RELATIME_BIT: CInterop.MountFlags { 0x1000 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_NOSYMFOLLOW_BIT: CInterop.MountFlags { 0x2000 }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_VALID_BIT: CInterop.MountFlags { 0x0020 }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on All Platforms
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MOUNT_RDONLY: CInterop.MountFlags {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
CInterop.MountFlags(truncatingIfNeeded: MNT_RDONLY)
|
||||
#elseif os(Linux) || os(Android)
|
||||
_ST_RDONLY_BIT
|
||||
#endif
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MOUNT_SYNCHRONOUS: CInterop.MountFlags {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
CInterop.MountFlags(truncatingIfNeeded: MNT_SYNCHRONOUS)
|
||||
#elseif os(Linux) || os(Android)
|
||||
_ST_SYNCHRONOUS_BIT
|
||||
#endif
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MOUNT_NOEXEC: CInterop.MountFlags {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
CInterop.MountFlags(truncatingIfNeeded: MNT_NOEXEC)
|
||||
#elseif os(Linux) || os(Android)
|
||||
_ST_NOEXEC_BIT
|
||||
#endif
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MOUNT_NOSUID: CInterop.MountFlags {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
CInterop.MountFlags(truncatingIfNeeded: MNT_NOSUID)
|
||||
#elseif os(Linux) || os(Android)
|
||||
_ST_NOSUID_BIT
|
||||
#endif
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MOUNT_NOATIME: CInterop.MountFlags {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
CInterop.MountFlags(truncatingIfNeeded: MNT_NOATIME)
|
||||
#elseif os(Linux) || os(Android)
|
||||
_ST_NOATIME_BIT
|
||||
#endif
|
||||
}
|
||||
|
||||
// MARK: Flags Available on All Platforms Except FreeBSD
|
||||
|
||||
#if !os(FreeBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MOUNT_NODEV: CInterop.MountFlags {
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(OpenBSD)
|
||||
CInterop.MountFlags(truncatingIfNeeded: MNT_NODEV)
|
||||
#elseif os(Linux) || os(Android)
|
||||
_ST_NODEV_BIT
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Linux and Android
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_MANDLOCK: CInterop.MountFlags { _ST_MANDLOCK_BIT }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_NODIRATIME: CInterop.MountFlags { _ST_NODIRATIME_BIT }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _ST_RELATIME: CInterop.MountFlags { _ST_RELATIME_BIT }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Linux, Android, and FreeBSD
|
||||
|
||||
#if os(Linux) || os(Android) || os(FreeBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MOUNT_NOSYMFOLLOW: CInterop.MountFlags {
|
||||
#if os(FreeBSD)
|
||||
CInterop.MountFlags(truncatingIfNeeded: MNT_NOSYMFOLLOW)
|
||||
#else
|
||||
_ST_NOSYMFOLLOW_BIT
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_ASYNC: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_ASYNC) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_EXPORTED: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_EXPORTED) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_LOCAL: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_LOCAL) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_QUOTA: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_QUOTA) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_ROOTFS: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_ROOTFS) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Darwin and FreeBSD
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_UNION: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_UNION) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_AUTOMOUNTED: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_AUTOMOUNTED) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_MULTILABEL: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_MULTILABEL) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on FreeBSD and OpenBSD
|
||||
|
||||
#if os(FreeBSD) || os(OpenBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_EXRDONLY: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_EXRDONLY) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_DEFEXPORTED: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_DEFEXPORTED) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_EXPORTANON: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_EXPORTANON) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_SOFTDEP: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_SOFTDEP) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on Darwin Only
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_CPROTECT: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_CPROTECT) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_REMOVABLE: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_REMOVABLE) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_QUARANTINE: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_QUARANTINE) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_DOVOLFS: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_DOVOLFS) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_DONTBROWSE: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_DONTBROWSE) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_IGNORE_OWNERSHIP: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_IGNORE_OWNERSHIP) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_JOURNALED: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_JOURNALED) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_NOUSERXATTR: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_NOUSERXATTR) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_DEFWRITE: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_DEFWRITE) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_NOFOLLOW: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_NOFOLLOW) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_SNAPSHOT: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_SNAPSHOT) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_STRICTATIME: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_STRICTATIME) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on FreeBSD Only
|
||||
|
||||
#if os(FreeBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_EXKERB: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_EXKERB) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_EXPUBLIC: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_EXPUBLIC) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_ACLS: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_ACLS) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_GJOURNAL: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_GJOURNAL) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_IGNORE: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_IGNORE) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_NFS4ACLS: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_NFS4ACLS) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_NOCLUSTERR: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_NOCLUSTERR) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_NOCLUSTERW: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_NOCLUSTERW) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_SUIDDIR: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_SUIDDIR) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_SUJ: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_SUJ) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_UNTRUSTED: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_UNTRUSTED) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_USER: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_USER) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_VERIFIED: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_VERIFIED) }
|
||||
#endif
|
||||
|
||||
// MARK: Flags Available on OpenBSD Only
|
||||
|
||||
#if os(OpenBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_NOPERM: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_NOPERM) }
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@_alwaysEmitIntoClient
|
||||
internal var _MNT_WXALLOWED: CInterop.MountFlags { CInterop.MountFlags(truncatingIfNeeded: MNT_WXALLOWED) }
|
||||
#endif
|
||||
|
||||
#endif // !os(WASI)
|
||||
|
||||
#endif // !os(Windows)
|
||||
@@ -10,23 +10,21 @@
|
||||
// Internal wrappers and typedefs which help reduce #if littering in System's
|
||||
// code base.
|
||||
|
||||
// TODO: Should CSystem just include all the header files we need?
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import CSystem
|
||||
import ucrt
|
||||
import WinSDK
|
||||
#elseif canImport(Glibc)
|
||||
import CSystem
|
||||
#if os(Linux)
|
||||
import CSystemStatFS
|
||||
#endif
|
||||
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")
|
||||
@@ -79,10 +77,6 @@ internal var system_errno: CInt {
|
||||
|
||||
// Convention: `system_foo` is system's wrapper for `foo`.
|
||||
|
||||
internal func system_strerror(_ __errnum: Int32) -> UnsafeMutablePointer<Int8>! {
|
||||
strerror(__errnum)
|
||||
}
|
||||
|
||||
internal func system_strlen(_ s: UnsafePointer<CChar>) -> Int {
|
||||
strlen(s)
|
||||
}
|
||||
@@ -108,6 +102,17 @@ internal func system_fstat(_ fd: CInt, _ s: inout CInterop.Stat) -> Int32 {
|
||||
internal func system_fstatat(_ fd: CInt, _ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat, _ flags: CInt) -> Int32 {
|
||||
fstatat(fd, p, &s, flags)
|
||||
}
|
||||
|
||||
#if !os(WASI)
|
||||
@available(System 1.9.0, *)
|
||||
internal func system_statfs(_ p: UnsafePointer<CChar>, _ s: inout CInterop.StatFS) -> Int32 {
|
||||
statfs(p, &s)
|
||||
}
|
||||
@available(System 1.9.0, *)
|
||||
internal func system_fstatfs(_ fd: CInt, _ s: inout CInterop.StatFS) -> Int32 {
|
||||
fstatfs(fd, &s)
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Convention: `system_platform_foo` is a
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
See https://swift.org/LICENSE.txt for license information
|
||||
*/
|
||||
|
||||
import CSystem
|
||||
internal import CSystem
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
import Darwin
|
||||
#elseif canImport(Glibc)
|
||||
@@ -27,6 +27,16 @@ import Android
|
||||
// Interacting with the mocking system, tracing, etc., is a potentially significant
|
||||
// amount of code size, so we hand outline that code for every syscall
|
||||
|
||||
// strerror(3) isn't guaranteed to be thread-safe: for an unknown error number,
|
||||
// it may format the message into a buffer shared by all threads. This wrapper
|
||||
// uses a caller-provided buffer instead (strerror_r(3), or strerror_s on
|
||||
// Windows). It isn't a syscall, so it isn't mocked.
|
||||
internal func system_strerror_r(
|
||||
_ errnum: CInt, _ buffer: UnsafeMutablePointer<CChar>, _ length: Int
|
||||
) -> CInt {
|
||||
csystem_strerror_r(errnum, buffer, length)
|
||||
}
|
||||
|
||||
// open
|
||||
internal func system_open(
|
||||
_ path: UnsafePointer<CInterop.PlatformChar>, _ oflag: Int32
|
||||
|
||||
@@ -16,8 +16,9 @@
|
||||
// - 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.
|
||||
// - Touch every direct member the public API exposes, and the members of C
|
||||
// types it exposes through them (e.g. timespec). One field is not always a
|
||||
// safe proxy for the rest.
|
||||
|
||||
#if canImport(Glibc) || canImport(Musl) || canImport(Android)
|
||||
#if canImport(Glibc)
|
||||
@@ -43,5 +44,29 @@ func _mivProbe(_ s: CInterop.Stat) {
|
||||
_ = s.st_atim
|
||||
_ = s.st_mtim
|
||||
_ = s.st_ctim
|
||||
_ = s.st_atim.tv_sec
|
||||
_ = s.st_atim.tv_nsec
|
||||
}
|
||||
|
||||
// These are the Linux and Android field names. FreeBSD's libc module is also
|
||||
// named Glibc, but its `statfs` and `fsid_t` use the BSD names.
|
||||
#if os(Linux) || os(Android)
|
||||
func _mivProbe(_ s: CInterop.StatFS) {
|
||||
_ = s.f_type
|
||||
_ = s.f_bsize
|
||||
_ = s.f_blocks
|
||||
_ = s.f_bfree
|
||||
_ = s.f_bavail
|
||||
_ = s.f_files
|
||||
_ = s.f_ffree
|
||||
_ = s.f_fsid
|
||||
_ = s.f_namelen
|
||||
_ = s.f_frsize
|
||||
_ = s.f_flags
|
||||
}
|
||||
|
||||
func _mivProbe(_ id: CInterop.FileSystemID) {
|
||||
_ = id.__val
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -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
|
||||
@@ -19,6 +19,14 @@ import System
|
||||
import WinSDK
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE && canImport(CSystem)
|
||||
import CSystem // for csystem_strerror_r
|
||||
#endif
|
||||
|
||||
#if canImport(Dispatch)
|
||||
import Dispatch
|
||||
#endif
|
||||
|
||||
@available(System 0.0.1, *)
|
||||
final class ErrnoTest: XCTestCase {
|
||||
func testConstants() {
|
||||
@@ -235,5 +243,64 @@ final class ErrnoTest: XCTestCase {
|
||||
|
||||
// TODO: `_code/_domain` for NSError bridging
|
||||
|
||||
// TODO: `description`
|
||||
func testDescription() {
|
||||
XCTAssertEqual(Errno.noSuchFileOrDirectory.description, "No such file or directory")
|
||||
XCTAssertEqual(Errno.notPermitted.debugDescription, Errno.notPermitted.description)
|
||||
|
||||
// Unknown error numbers still get a message.
|
||||
let unknown = Errno(rawValue: 98765).description
|
||||
XCTAssertFalse(unknown.isEmpty)
|
||||
#if !os(Windows) && !os(WASI) && !canImport(Musl)
|
||||
// Windows' message is just "Unknown error", and musl's (also used by
|
||||
// WASI) is "No error information", without the number.
|
||||
XCTAssert(unknown.contains("98765"), unknown)
|
||||
#endif
|
||||
}
|
||||
|
||||
#if canImport(Dispatch)
|
||||
func testDescriptionIsThreadSafe() {
|
||||
// For unknown error numbers, strerror(3) may format the message into a
|
||||
// buffer shared by all threads, so concurrent calls could see each
|
||||
// other's messages.
|
||||
let errnos = (0..<64).map { Errno(rawValue: 90000 + CInt($0)) }
|
||||
let expected = errnos.map(\.description)
|
||||
let iterations = 200
|
||||
nonisolated(unsafe) let mismatches =
|
||||
UnsafeMutableBufferPointer<Int>.allocate(capacity: errnos.count)
|
||||
mismatches.initialize(repeating: 0)
|
||||
defer { mismatches.deallocate() }
|
||||
|
||||
DispatchQueue.concurrentPerform(iterations: errnos.count) { index in
|
||||
for _ in 0..<iterations where errnos[index].description != expected[index] {
|
||||
mismatches[index] += 1
|
||||
}
|
||||
}
|
||||
XCTAssertEqual(mismatches.reduce(0, +), 0)
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE && canImport(CSystem)
|
||||
func testStrerrorShim() {
|
||||
var buffer = [CChar](repeating: 1, count: 256)
|
||||
XCTAssertEqual(csystem_strerror_r(ENOENT, &buffer, buffer.count), 0)
|
||||
XCTAssertEqual(
|
||||
buffer.withUnsafeBufferPointer { String(cString: $0.baseAddress!) },
|
||||
"No such file or directory")
|
||||
|
||||
// A buffer that is too small yields a truncated, NUL-terminated message.
|
||||
var small = [CChar](repeating: 1, count: 4)
|
||||
XCTAssertEqual(csystem_strerror_r(ENOENT, &small, small.count), ERANGE)
|
||||
#if !os(Windows)
|
||||
XCTAssertEqual(
|
||||
small.withUnsafeBufferPointer { String(cString: $0.baseAddress!) },
|
||||
"No ")
|
||||
#endif
|
||||
XCTAssertEqual(small[3], 0)
|
||||
|
||||
// A zero-length buffer is rejected without writing to it.
|
||||
var empty = CChar(1)
|
||||
XCTAssertEqual(csystem_strerror_r(ENOENT, &empty, 0), ERANGE)
|
||||
XCTAssertEqual(empty, 1)
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -179,11 +179,12 @@ final class FileOperationsTest: XCTestCase {
|
||||
}
|
||||
|
||||
func testAdHocPipeWithOptions() throws {
|
||||
#if !SYSTEM_PACKAGE_DARWIN || canImport(Darwin, _version: 428)
|
||||
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`.
|
||||
// Ad-hoc test: `MockTestCase` can't match the pointer to the local array
|
||||
// that `pipe` receives, because its address isn't known in advance.
|
||||
let options: FileDescriptor.PipeOptions = [.closeOnExec]
|
||||
let pipe: (readEnd: FileDescriptor, writeEnd: FileDescriptor)
|
||||
pipe = try FileDescriptor.pipe(options: options)
|
||||
@@ -194,12 +195,52 @@ final class FileOperationsTest: XCTestCase {
|
||||
_ = try pipe.writeEnd.write(UnsafeRawBufferPointer($0))
|
||||
}
|
||||
let readLen = 3
|
||||
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { buf, count in
|
||||
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) {
|
||||
buf, count in
|
||||
count = try pipe.readEnd.read(into: UnsafeMutableRawBufferPointer(buf))
|
||||
}
|
||||
XCTAssertEqual(readBytes, Array(abc.utf8))
|
||||
}
|
||||
}
|
||||
#else
|
||||
throw XCTSkip("pipe2 requires a Darwin SDK for anyAppleOS 27 or newer")
|
||||
#endif
|
||||
}
|
||||
|
||||
func testAdHocPipeCloseOnFork() throws {
|
||||
#if canImport(Darwin, _version: 428)
|
||||
guard #available(macOS 27.0, iOS 27.0, watchOS 27.0, tvOS 27.0, visionOS 27.0, *) else {
|
||||
throw XCTSkip("pipe2 and PipeOptions require anyAppleOS 27 or newer")
|
||||
}
|
||||
// System spells O_CLOFORK as a literal on Darwin.
|
||||
XCTAssertEqual(FileDescriptor.PipeOptions.closeOnFork.rawValue, O_CLOFORK)
|
||||
let pipe = try FileDescriptor.pipe(options: .closeOnFork)
|
||||
try pipe.readEnd.closeAfter {
|
||||
try pipe.writeEnd.closeAfter {
|
||||
let flags = fcntl(pipe.readEnd.rawValue, F_GETFD)
|
||||
XCTAssertEqual(flags & FD_CLOFORK, FD_CLOFORK)
|
||||
}
|
||||
}
|
||||
#elseif os(FreeBSD)
|
||||
let pipe: (readEnd: FileDescriptor, writeEnd: FileDescriptor)
|
||||
do {
|
||||
pipe = try FileDescriptor.pipe(options: .closeOnFork)
|
||||
} catch {
|
||||
if (error as? Errno) == .invalidArgument {
|
||||
throw XCTSkip("pipe2 does not support O_CLOFORK before FreeBSD 15")
|
||||
}
|
||||
throw error
|
||||
}
|
||||
try pipe.readEnd.closeAfter {
|
||||
try pipe.writeEnd.closeAfter {
|
||||
let flags = fcntl(pipe.readEnd.rawValue, F_GETFD)
|
||||
XCTAssertEqual(flags & FD_CLOEXEC, 0)
|
||||
XCTAssertNotEqual(flags, 0)
|
||||
}
|
||||
}
|
||||
#else
|
||||
throw XCTSkip("O_CLOFORK requires a Darwin SDK for anyAppleOS 27 or newer")
|
||||
#endif
|
||||
}
|
||||
#endif // !os(WASI)
|
||||
|
||||
@@ -242,6 +283,7 @@ final class FileOperationsTest: XCTestCase {
|
||||
}
|
||||
|
||||
func testAdHocDuplicate3() throws {
|
||||
#if !SYSTEM_PACKAGE_DARWIN || canImport(Darwin, _version: 428)
|
||||
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")
|
||||
}
|
||||
@@ -276,6 +318,9 @@ final class FileOperationsTest: XCTestCase {
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
throw XCTSkip("dup3 requires a Darwin SDK for anyAppleOS 27 or newer")
|
||||
#endif
|
||||
}
|
||||
#endif // !os(Windows)
|
||||
|
||||
|
||||
@@ -20,9 +20,20 @@ import XCTest
|
||||
import WinSDK
|
||||
import ucrt
|
||||
|
||||
private let ERROR_SUCCESS = DWORD(WinSDK.ERROR_SUCCESS)
|
||||
private let FILE_APPEND_DATA = DWORD(WinSDK.FILE_APPEND_DATA)
|
||||
private let FILE_EXECUTE = DWORD(WinSDK.FILE_EXECUTE)
|
||||
private let FILE_READ_ATTRIBUTES = DWORD(WinSDK.FILE_READ_ATTRIBUTES)
|
||||
private let FILE_READ_DATA = DWORD(WinSDK.FILE_READ_DATA)
|
||||
private let FILE_READ_EA = DWORD(WinSDK.FILE_READ_EA)
|
||||
private let FILE_WRITE_ATTRIBUTES = DWORD(WinSDK.FILE_WRITE_ATTRIBUTES)
|
||||
private let FILE_WRITE_DATA = DWORD(WinSDK.FILE_WRITE_DATA)
|
||||
private let FILE_WRITE_EA = DWORD(WinSDK.FILE_WRITE_EA)
|
||||
private let SECURITY_WORLD_RID = DWORD(WinSDK.SECURITY_WORLD_RID)
|
||||
private let STANDARD_RIGHTS_EXECUTE = DWORD(WinSDK.STANDARD_RIGHTS_EXECUTE)
|
||||
private let STANDARD_RIGHTS_READ = DWORD(WinSDK.STANDARD_RIGHTS_READ)
|
||||
private let STANDARD_RIGHTS_WRITE = DWORD(WinSDK.STANDARD_RIGHTS_WRITE)
|
||||
private let SYNCHRONIZE = DWORD(WinSDK.SYNCHRONIZE)
|
||||
|
||||
@available(iOS 8, *)
|
||||
final class FileOperationsTestWindows: XCTestCase {
|
||||
|
||||
@@ -70,7 +70,39 @@ struct TestPathComponents: TestCase {
|
||||
}
|
||||
|
||||
func testRRC() {
|
||||
// TODO: programmatic tests showing parity with Array<Component>
|
||||
// Show that FilePathComponents's replaceSubrange behaves like Array.
|
||||
let pool: [FilePath.Component] = ["x", "..", ".", "longer-name"]
|
||||
let replacements: [[FilePath.Component]] = [[]] + (1 ... 3).flatMap { len in
|
||||
pool.indices.map { offset in
|
||||
(0 ..< len).map { pool[(offset + $0) % pool.count] }
|
||||
}
|
||||
}
|
||||
|
||||
let count = expectedComponents.count
|
||||
for lower in 0 ... count {
|
||||
for upper in lower ... count {
|
||||
for replacement in replacements {
|
||||
var model = expectedComponents
|
||||
model.replaceSubrange(lower ..< upper, with: replacement)
|
||||
|
||||
var p = path
|
||||
let indices = Array(p.components.indices) + [p.components.endIndex]
|
||||
p.components.replaceSubrange(
|
||||
indices[lower] ..< indices[upper], with: replacement
|
||||
)
|
||||
|
||||
let expected = FilePath(root: path.root, model)
|
||||
let message = """
|
||||
replaceSubrange(\(lower)..<\(upper), with: \(replacement)) \
|
||||
returned \(p), expected \(expected)
|
||||
"""
|
||||
expectEqual(expected, p, message + " [path]")
|
||||
expectEqual(path.root, p.root, message + " [root]")
|
||||
expectEqualSequence(model, p.components, message + " [components]")
|
||||
expectEqual(model.last, p.lastComponent, message + " [lastComponent]")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testModify() {
|
||||
@@ -102,7 +134,7 @@ struct TestPathComponents: TestCase {
|
||||
|
||||
@available(System 0.0.2, *)
|
||||
final class FilePathComponentsTest: XCTestCase {
|
||||
func testAdHocRRC() {
|
||||
func testAdHocRRC() throws {
|
||||
var path: FilePath = "/usr/local/bin"
|
||||
|
||||
func expect(
|
||||
@@ -118,26 +150,26 @@ final class FilePathComponentsTest: XCTestCase {
|
||||
|
||||
// Run `body`, restoring `path` afterwards
|
||||
func restoreAfter(
|
||||
body: () -> ()
|
||||
) {
|
||||
body: () throws -> ()
|
||||
) rethrows {
|
||||
let copy = path
|
||||
defer { path = copy }
|
||||
body()
|
||||
try body()
|
||||
}
|
||||
|
||||
// Interior removal keeps path prefix intact, if there is one
|
||||
restoreAfter {
|
||||
try restoreAfter {
|
||||
path = "prefix//middle1/middle2////suffix"
|
||||
let suffix = path.components.indices.last!
|
||||
let suffix = try XCTUnwrap(path.components.indices.last)
|
||||
path.components.removeSubrange(..<suffix)
|
||||
expect("suffix")
|
||||
}
|
||||
|
||||
restoreAfter {
|
||||
try restoreAfter {
|
||||
path = "prefix//middle1/middle2////suffix"
|
||||
let firstMiddle = path.components.index(
|
||||
path.components.startIndex, offsetBy: 1)
|
||||
let suffix = path.components.indices.last!
|
||||
let suffix = try XCTUnwrap(path.components.indices.last)
|
||||
path.components.removeSubrange(firstMiddle ..< suffix)
|
||||
expect("prefix/suffix")
|
||||
}
|
||||
@@ -193,14 +225,16 @@ final class FilePathComponentsTest: XCTestCase {
|
||||
}
|
||||
|
||||
// Insertion into the middle adds trailing separator
|
||||
restoreAfter {
|
||||
try restoreAfter {
|
||||
path.components.remove(
|
||||
at: path.components.index(after: path.components.startIndex))
|
||||
expect("/usr/bin")
|
||||
path.components.insert("middle", at: path.components.indices.last!)
|
||||
path.components.insert(
|
||||
"middle", at: try XCTUnwrap(path.components.indices.last))
|
||||
expect("/usr/middle/bin")
|
||||
path.components.insert(
|
||||
contentsOf: ["middle2", "middle3"], at: path.components.indices.last!)
|
||||
contentsOf: ["middle2", "middle3"],
|
||||
at: try XCTUnwrap(path.components.indices.last))
|
||||
expect("/usr/middle/middle2/middle3/bin")
|
||||
|
||||
let slice = path.components.dropFirst().dropLast()
|
||||
@@ -210,6 +244,35 @@ final class FilePathComponentsTest: XCTestCase {
|
||||
expect("/usr/newMiddle/newMiddle2/newMiddle3/newMiddle4/bin")
|
||||
}
|
||||
|
||||
// Replacing components at the end of a path must not append a separator.
|
||||
try restoreAfter {
|
||||
let last = try XCTUnwrap(path.components.indices.last)
|
||||
path.components.replaceSubrange(last..., with: ["sbin"])
|
||||
expect("/usr/local/sbin")
|
||||
XCTAssertEqual(path.lastComponent, "sbin")
|
||||
XCTAssertEqual(path.components.last, "sbin")
|
||||
|
||||
path.components.replaceSubrange(
|
||||
path.components.index(after: path.components.startIndex)...,
|
||||
with: ["a", "b", "c"])
|
||||
expect("/usr/a/b/c")
|
||||
|
||||
path.components.append("d")
|
||||
expect("/usr/a/b/c/d")
|
||||
XCTAssertEqual(path.components.count, 5)
|
||||
|
||||
path.components.replaceSubrange(
|
||||
path.components.startIndex..., with: ["x", "y"])
|
||||
expect("/x/y")
|
||||
}
|
||||
try restoreAfter {
|
||||
path = "a/b"
|
||||
path.components.replaceSubrange(
|
||||
try XCTUnwrap(path.components.indices.last)..., with: ["x"])
|
||||
expect("a/x")
|
||||
XCTAssertEqual(path.lastComponent, "x")
|
||||
}
|
||||
|
||||
restoreAfter {
|
||||
path.components.removeLast(3)
|
||||
expect("/")
|
||||
@@ -218,14 +281,15 @@ final class FilePathComponentsTest: XCTestCase {
|
||||
}
|
||||
|
||||
// Empty insertions / removals
|
||||
restoreAfter {
|
||||
try restoreAfter {
|
||||
path.components.replaceSubrange(..<path.components.startIndex, with: [])
|
||||
expect("/usr/local/bin")
|
||||
path.components.replaceSubrange(path.components.endIndex..., with: [])
|
||||
expect("/usr/local/bin")
|
||||
path.components.insert(contentsOf: [], at: path.components.startIndex)
|
||||
expect("/usr/local/bin")
|
||||
path.components.insert(contentsOf: [], at: path.components.indices.last!)
|
||||
path.components.insert(
|
||||
contentsOf: [], at: try XCTUnwrap(path.components.indices.last))
|
||||
expect("/usr/local/bin")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -16,15 +16,6 @@ import XCTest
|
||||
#endif
|
||||
|
||||
final class TemporaryPathTest: XCTestCase {
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
func testNotInSlashTmp() throws {
|
||||
try withTemporaryFilePath(basename: "NotInSlashTmp") { path in
|
||||
// We shouldn't be using "/tmp" on Darwin
|
||||
XCTAssertNotEqual(path.components.first!, "tmp")
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
func testUnique() throws {
|
||||
try withTemporaryFilePath(basename: "test") { path in
|
||||
let strPath = String(decoding: path)
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
#if os(Linux)
|
||||
|
||||
import XCTest
|
||||
import CSystem
|
||||
|
||||
#if SYSTEM_PACKAGE
|
||||
@testable import SystemPackage
|
||||
@@ -21,6 +22,76 @@ func requestBytes(_ request: consuming RawIORequest) -> [UInt8] {
|
||||
// that were generated with liburing or manually written out,
|
||||
// which are known to work correctly.
|
||||
final class IORequestTests: XCTestCase {
|
||||
func testWriteUnregisteredImmutableBuffer() {
|
||||
let bytes: [UInt8] = [1, 2, 3]
|
||||
bytes.withUnsafeBytes { buffer in
|
||||
let request = IORing.Request.write(
|
||||
buffer, into: FileDescriptor(rawValue: 7), at: 17, context: 42
|
||||
).makeRawRequest(pathBuffers: PendingPathBuffers(reservedCapacity: 0))
|
||||
XCTAssertEqual(request.rawValue.opcode, 23)
|
||||
XCTAssertEqual(request.rawValue.fd, 7)
|
||||
XCTAssertEqual(request.rawValue.flags, 0)
|
||||
XCTAssertEqual(request.rawValue.addr, UInt64(UInt(bitPattern: buffer.baseAddress)))
|
||||
XCTAssertEqual(request.rawValue.len, 3)
|
||||
XCTAssertEqual(request.rawValue.off, 17)
|
||||
XCTAssertEqual(request.rawValue.user_data, 42)
|
||||
}
|
||||
}
|
||||
|
||||
func testWriteUnregisteredImmutableBufferToRegisteredFile() {
|
||||
let bytes: [UInt8] = [1, 2, 3]
|
||||
bytes.withUnsafeBytes { buffer in
|
||||
let file = IORing.RegisteredFile(resource: 7, index: 3)
|
||||
let request = IORing.Request.write(
|
||||
buffer, into: file, at: 17, context: 42
|
||||
).makeRawRequest(pathBuffers: PendingPathBuffers(reservedCapacity: 0))
|
||||
XCTAssertEqual(request.rawValue.opcode, 23)
|
||||
XCTAssertEqual(request.rawValue.fd, 3)
|
||||
XCTAssertEqual(request.rawValue.flags, 1)
|
||||
XCTAssertEqual(request.rawValue.addr, UInt64(UInt(bitPattern: buffer.baseAddress)))
|
||||
XCTAssertEqual(request.rawValue.len, 3)
|
||||
XCTAssertEqual(request.rawValue.off, 17)
|
||||
XCTAssertEqual(request.rawValue.user_data, 42)
|
||||
}
|
||||
}
|
||||
|
||||
func testInferredRebasedWriteBuffer() {
|
||||
var bytes: [UInt8] = [1, 2, 3]
|
||||
bytes.withUnsafeMutableBytes { buffer in
|
||||
let written = 1
|
||||
let file = FileDescriptor(rawValue: 7)
|
||||
let request = IORing.Request.write(
|
||||
.init(rebasing: buffer[written...]), into: file, at: UInt64(written)
|
||||
).makeRawRequest(pathBuffers: PendingPathBuffers(reservedCapacity: 0))
|
||||
let registered = IORing.Request.write(
|
||||
.init(rebasing: buffer[written...]),
|
||||
into: IORing.RegisteredFile(resource: 7, index: 3), at: UInt64(written)
|
||||
).makeRawRequest(pathBuffers: PendingPathBuffers(reservedCapacity: 0))
|
||||
XCTAssertEqual(request.rawValue.len, 2)
|
||||
XCTAssertEqual(request.rawValue.off, 1)
|
||||
XCTAssertEqual(registered.rawValue.len, 2)
|
||||
XCTAssertEqual(registered.rawValue.off, 1)
|
||||
}
|
||||
}
|
||||
|
||||
func testMutableWriteFunctionReferences() {
|
||||
let write: (UnsafeMutableRawBufferPointer, FileDescriptor, UInt64, UInt64) -> IORing.Request =
|
||||
IORing.Request.write
|
||||
let writeRegistered: (UnsafeMutableRawBufferPointer, IORing.RegisteredFile, UInt64, UInt64) -> IORing.Request =
|
||||
IORing.Request.write
|
||||
var bytes: [UInt8] = [1, 2, 3]
|
||||
bytes.withUnsafeMutableBytes { buffer in
|
||||
let request = write(buffer, FileDescriptor(rawValue: 7), 17, 42)
|
||||
.makeRawRequest(pathBuffers: PendingPathBuffers(reservedCapacity: 0))
|
||||
let registered = writeRegistered(buffer, IORing.RegisteredFile(resource: 7, index: 3), 17, 42)
|
||||
.makeRawRequest(pathBuffers: PendingPathBuffers(reservedCapacity: 0))
|
||||
XCTAssertEqual(request.rawValue.fd, 7)
|
||||
XCTAssertEqual(request.rawValue.len, 3)
|
||||
XCTAssertEqual(registered.rawValue.fd, 3)
|
||||
XCTAssertEqual(registered.rawValue.flags, 1)
|
||||
}
|
||||
}
|
||||
|
||||
func testNop() {
|
||||
let req = IORing.Request.nop().makeRawRequest(
|
||||
pathBuffers: PendingPathBuffers(reservedCapacity: 0))
|
||||
|
||||
@@ -2,7 +2,8 @@
|
||||
#if os(Linux)
|
||||
|
||||
import XCTest
|
||||
import CSystem //for eventfd
|
||||
import CSystem // for eventfd and csystem_io_uring_setup
|
||||
import CSystemIOUring
|
||||
#if canImport(Glibc)
|
||||
import Glibc // for errno
|
||||
#elseif canImport(Musl)
|
||||
@@ -30,7 +31,7 @@ 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
|
||||
// (gated on IORING_TIMEOUT_BOOTTIME in io_uring.h); in that configuration
|
||||
// IORing.init throws ENOTSUP. Treat that as disabled so tests skip cleanly
|
||||
// instead of failing.
|
||||
do throws(Errno) {
|
||||
@@ -61,7 +62,7 @@ func isUringEnabled() throws -> Bool {
|
||||
// - EPERM or EACCES -> treat as disabled
|
||||
// - propagate any other error.
|
||||
var params = io_uring_params()
|
||||
let raw = io_uring_setup(1, ¶ms)
|
||||
let raw = csystem_io_uring_setup(1, ¶ms)
|
||||
if raw < 0 {
|
||||
let err = Errno(rawValue: errno)
|
||||
switch err {
|
||||
@@ -125,6 +126,30 @@ final class IORingTests: XCTestCase {
|
||||
return ring
|
||||
}
|
||||
|
||||
func testWriteImmutableUnregisteredBuffer() throws {
|
||||
try XCTSkipIf(!uringEnabled, failureMessage)
|
||||
let bytes: [UInt8] = [1, 2, 3]
|
||||
try bytes.withUnsafeBytes { buffer in
|
||||
var ring = try IORing(queueDepth: 1)
|
||||
let (readFD, writeFD) = try FileDescriptor.pipe()
|
||||
defer {
|
||||
try? readFD.close()
|
||||
try? writeFD.close()
|
||||
}
|
||||
XCTAssertTrue(try ring.submit(linkedRequests: .write(buffer, into: writeFD, context: 42)))
|
||||
let completion = try ring.blockingConsumeCompletion(timeout: .seconds(1))
|
||||
XCTAssertEqual(completion.context, 42)
|
||||
guard completion.result == 3 else {
|
||||
XCTFail("Expected three bytes written, got \(completion.result)")
|
||||
return
|
||||
}
|
||||
var received = [UInt8](repeating: 0, count: 3)
|
||||
let count = try received.withUnsafeMutableBytes { try readFD.read(into: $0) }
|
||||
XCTAssertEqual(count, 3)
|
||||
XCTAssertEqual(received, bytes)
|
||||
}
|
||||
}
|
||||
|
||||
func testUndersizedSubmissionQueue() throws {
|
||||
try XCTSkipIf(!uringEnabled, failureMessage)
|
||||
var ring: IORing = try IORing(queueDepth: 1)
|
||||
|
||||
@@ -0,0 +1,499 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 !os(Windows) && !os(WASI)
|
||||
|
||||
import Testing
|
||||
|
||||
#if canImport(Foundation)
|
||||
import Foundation
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
import Darwin
|
||||
#elseif canImport(Glibc)
|
||||
import CSystem
|
||||
import Glibc
|
||||
#elseif canImport(Musl)
|
||||
import CSystem
|
||||
import Musl
|
||||
#elseif canImport(Android)
|
||||
import CSystem
|
||||
import Android
|
||||
#else
|
||||
#error("Unsupported Platform")
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE
|
||||
@testable import SystemPackage
|
||||
#else
|
||||
@testable import System
|
||||
#endif
|
||||
|
||||
@Suite("StatFS")
|
||||
private struct StatFSTests {
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func initializersAgree() async throws {
|
||||
try withTemporaryFilePath(basename: "StatFS_initializersAgree") { tempDir in
|
||||
let fromFilePath = try StatFS(tempDir)
|
||||
let fromCString = try tempDir.withPlatformString { try StatFS($0) }
|
||||
|
||||
let dirFD = try FileDescriptor.open(tempDir, .readOnly)
|
||||
defer { try? dirFD.close() }
|
||||
let fromFD = try StatFS(dirFD)
|
||||
|
||||
#expect(fromFilePath.fileSystemID == fromCString.fileSystemID)
|
||||
#expect(fromFilePath.fileSystemID == fromFD.fileSystemID)
|
||||
|
||||
#expect(fromFilePath.blockSize == fromFD.blockSize)
|
||||
#expect(fromFilePath.totalBlocks == fromFD.totalBlocks)
|
||||
#expect(fromFilePath.mountFlags == fromFD.mountFlags)
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func spaceAndBlocks() async throws {
|
||||
try withTemporaryFilePath(basename: "StatFS_spaceAndBlocks") { tempDir in
|
||||
let statfs = try StatFS(tempDir)
|
||||
|
||||
#expect(statfs.blockSize > 0)
|
||||
#expect(statfs.totalBlocks > 0)
|
||||
#expect(statfs.freeBlocks <= statfs.totalBlocks)
|
||||
#expect(statfs.availableBlocks <= statfs.freeBlocks)
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func readOnlyFlagReflectsWritableFileSystem() async throws {
|
||||
try withTemporaryFilePath(basename: "StatFS_readOnly") { tempDir in
|
||||
let statfs = try StatFS(tempDir)
|
||||
#expect(!statfs.mountFlags.contains(.readOnly))
|
||||
}
|
||||
}
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@Test func darwinAndBSDFields() async throws {
|
||||
try withTemporaryFilePath(basename: "StatFS_darwinBSD") { tempDir in
|
||||
let statfs = try StatFS(tempDir)
|
||||
#expect(statfs.preferredIOBlockSize > 0)
|
||||
#expect(!statfs.typeName.rawValue.isEmpty)
|
||||
#expect(statfs.mountPoint.isAbsolute)
|
||||
#expect(!statfs.mountSource.string.isEmpty)
|
||||
|
||||
let mountStatFS = try StatFS(statfs.mountPoint)
|
||||
#expect(mountStatFS.mountPoint == statfs.mountPoint)
|
||||
#expect(mountStatFS.typeName == statfs.typeName)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func nonexistentPathThrows() async throws {
|
||||
#expect(throws: Errno.noSuchFileOrDirectory) {
|
||||
_ = try StatFS("/var/empty/definitely/does/not/exist")
|
||||
}
|
||||
#expect(throws: Errno.noSuchFileOrDirectory) {
|
||||
_ = try StatFS(FilePath("/var/empty/definitely/does/not/exist"))
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func badFileDescriptorThrows() async throws {
|
||||
let badFD = FileDescriptor(rawValue: -1)
|
||||
#expect(throws: Errno.badFileDescriptor) {
|
||||
_ = try StatFS(badFD)
|
||||
}
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func propertiesMatchRawFields() async throws {
|
||||
try withTemporaryFilePath(basename: "StatFS_diff") { tempDir in
|
||||
var raw = CInterop.StatFS()
|
||||
try tempDir.withPlatformString {
|
||||
try #require(statfs($0, &raw) == 0, "\(Errno.current)")
|
||||
}
|
||||
let s = StatFS(rawValue: raw)
|
||||
|
||||
#expect(s.blockSize == Int(raw.f_bsize))
|
||||
#expect(s.totalBlocks == UInt64(clamping: raw.f_blocks))
|
||||
#expect(s.freeBlocks == UInt64(clamping: raw.f_bfree))
|
||||
#expect(s.availableBlocks == UInt64(clamping: raw.f_bavail))
|
||||
#expect(s.totalInodes == UInt64(clamping: raw.f_files))
|
||||
#expect(s.freeInodes == UInt64(clamping: raw.f_ffree))
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
#expect(s.preferredIOBlockSize == Int(raw.f_iosize))
|
||||
#expect(s.owner.rawValue == raw.f_owner)
|
||||
#expect(s.mountFlags.rawValue == raw.f_flags)
|
||||
#expect(s.typeName.rawValue == withUnsafeBytes(of: raw.f_fstypename) {
|
||||
$0.withMemoryRebound(to: CChar.self) { String(cString: $0.baseAddress!) }
|
||||
})
|
||||
#expect(s.mountPoint.string == withUnsafeBytes(of: raw.f_mntonname) {
|
||||
$0.withMemoryRebound(to: CChar.self) { String(cString: $0.baseAddress!) }
|
||||
})
|
||||
#expect(s.mountSource.string == withUnsafeBytes(of: raw.f_mntfromname) {
|
||||
$0.withMemoryRebound(to: CChar.self) { String(cString: $0.baseAddress!) }
|
||||
})
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
#expect(s.subtype.rawValue == raw.f_fssubtype)
|
||||
#elseif os(FreeBSD)
|
||||
#expect(s.maximumNameLength == Int(raw.f_namemax))
|
||||
#else // os(OpenBSD)
|
||||
#expect(s.maximumNameLength == Int(raw.f_namemax))
|
||||
#expect(s.availableInodes == UInt64(clamping: raw.f_favail))
|
||||
#endif
|
||||
#else
|
||||
#expect(s.fragmentSize == Int(raw.f_frsize))
|
||||
#expect(s.maximumNameLength == Int(raw.f_namelen))
|
||||
#expect(s.type.rawValue == UInt32(truncatingIfNeeded: raw.f_type))
|
||||
// `mountFlags` omits the kernel's ST_VALID (0x20) bookkeeping bit.
|
||||
#expect(s.mountFlags.rawValue == CInterop.MountFlags(truncatingIfNeeded: raw.f_flags) & ~0x20)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
// Each setter writes its own field, and clamps instead of trapping.
|
||||
@available(System 1.9.0, *)
|
||||
@Test func settersWriteRawFields() throws {
|
||||
var s = StatFS(rawValue: CInterop.StatFS())
|
||||
s.blockSize = 1
|
||||
s.totalBlocks = 2
|
||||
s.freeBlocks = 3
|
||||
s.availableBlocks = 4
|
||||
s.totalInodes = 5
|
||||
s.freeInodes = 6
|
||||
#expect(s.rawValue.f_bsize == 1)
|
||||
#expect(s.rawValue.f_blocks == 2)
|
||||
#expect(s.rawValue.f_bfree == 3)
|
||||
#expect(s.rawValue.f_bavail == 4)
|
||||
#expect(s.rawValue.f_files == 5)
|
||||
#expect(s.rawValue.f_ffree == 6)
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
s.subtype = FileSystemSubtype(8)
|
||||
#expect(s.rawValue.f_fssubtype == 8)
|
||||
#endif
|
||||
|
||||
s.mountFlags.insert(.readOnly)
|
||||
#expect(s.mountFlags.contains(.readOnly))
|
||||
|
||||
s.blockSize = .max
|
||||
#expect(s.blockSize == Int(clamping: type(of: s.rawValue.f_bsize).max))
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func craftedStructComputesSpace() throws {
|
||||
var raw = CInterop.StatFS()
|
||||
// The block-count unit is f_bsize on Darwin/BSD, f_frsize elsewhere.
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
raw.f_bsize = 512
|
||||
#else
|
||||
raw.f_bsize = 4096 // Should not be used in calculations
|
||||
raw.f_frsize = 512
|
||||
#endif
|
||||
raw.f_blocks = 1000
|
||||
raw.f_bfree = 400
|
||||
raw.f_bavail = 100
|
||||
|
||||
let s = StatFS(rawValue: raw)
|
||||
#expect(s.totalSpace == 1000 * 512)
|
||||
#expect(s.freeSpace == 400 * 512)
|
||||
#expect(s.availableSpace == 100 * 512)
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func spaceSaturatesOnOverflow() throws {
|
||||
var raw = CInterop.StatFS()
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
raw.f_bsize = 512
|
||||
#else
|
||||
raw.f_frsize = 512
|
||||
#endif
|
||||
raw.f_blocks = .max
|
||||
|
||||
let s = StatFS(rawValue: raw)
|
||||
if MemoryLayout.size(ofValue: raw.f_blocks) == MemoryLayout<UInt64>.size {
|
||||
#expect(s.totalSpace == .max)
|
||||
} else {
|
||||
#expect(s.totalSpace == UInt64(raw.f_blocks) * 512)
|
||||
}
|
||||
}
|
||||
|
||||
#if os(FreeBSD) || os(OpenBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@Test func negativeCountsClampToZero() throws {
|
||||
var raw = CInterop.StatFS()
|
||||
raw.f_bsize = 512
|
||||
raw.f_bavail = -1
|
||||
#if os(FreeBSD)
|
||||
raw.f_ffree = -1
|
||||
#else
|
||||
raw.f_favail = -1
|
||||
#endif
|
||||
|
||||
let s = StatFS(rawValue: raw)
|
||||
#expect(s.availableBlocks == 0)
|
||||
#expect(s.availableSpace == 0)
|
||||
#if os(FreeBSD)
|
||||
#expect(s.freeInodes == 0)
|
||||
#else
|
||||
#expect(s.availableInodes == 0)
|
||||
#endif
|
||||
|
||||
// Distinct negative counts read the same through the clamped property,
|
||||
// but they're still different values.
|
||||
var other = raw
|
||||
other.f_bavail = -2
|
||||
#expect(StatFS(rawValue: other).availableBlocks == s.availableBlocks)
|
||||
#expect(StatFS(rawValue: other) != s)
|
||||
}
|
||||
#endif
|
||||
|
||||
#if os(Linux)
|
||||
// /proc files report size 0 via stat, so read until EOF instead of getting
|
||||
// the size up front.
|
||||
private func _readEntireFile(_ path: String) throws -> String {
|
||||
let fd = try FileDescriptor.open(FilePath(path), .readOnly)
|
||||
defer { try? fd.close() }
|
||||
var result = [UInt8]()
|
||||
var chunk = [UInt8](repeating: 0, count: 64 * 1024)
|
||||
while true {
|
||||
let n = try chunk.withUnsafeMutableBytes { try fd.read(into: $0) }
|
||||
if n == 0 { break }
|
||||
result.append(contentsOf: chunk[..<n])
|
||||
}
|
||||
return String(decoding: result, as: UTF8.self)
|
||||
}
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func mountFlagsMatchProcMounts() throws {
|
||||
let contents = try _readEntireFile("/proc/self/mounts")
|
||||
|
||||
// Fields: device, mountPoint, fsType, options, dump, pass.
|
||||
var mounts: [String: Set<String>] = [:]
|
||||
for line in contents.split(separator: "\n") {
|
||||
let fields = line.split(separator: " ")
|
||||
guard fields.count >= 4 else { continue }
|
||||
let mountPoint = String(fields[1])
|
||||
// Skip octal-escaped paths (spaces, tabs, etc.).
|
||||
if mountPoint.contains(where: { $0 == "\\" }) { continue }
|
||||
mounts[mountPoint] = Set(fields[3].split(separator: ",").map(String.init))
|
||||
}
|
||||
|
||||
let checks: [(option: String, flag: MountFlags)] = [
|
||||
("ro", .readOnly),
|
||||
("noexec", .noExecution),
|
||||
("nosuid", .noSetUserID),
|
||||
("nodev", .noDevices),
|
||||
("noatime", .noAccessTime),
|
||||
]
|
||||
|
||||
// Only probe well-known local mounts. statfs on an arbitrary host mount
|
||||
// can hang (e.g. a stale NFS mount).
|
||||
let candidates: Set<String> = ["/", "/proc", "/sys", "/dev", "/dev/shm", "/run"]
|
||||
|
||||
var verified = 0
|
||||
for (mountPoint, options) in mounts where candidates.contains(mountPoint) {
|
||||
guard let statfs = try? StatFS(FilePath(mountPoint)) else { continue }
|
||||
for (option, flag) in checks {
|
||||
#expect(
|
||||
statfs.mountFlags.contains(flag) == options.contains(option),
|
||||
"\(mountPoint): flag \(flag) disagrees with options \(options)"
|
||||
)
|
||||
}
|
||||
verified += 1
|
||||
}
|
||||
|
||||
// Guard against a parser that silently matched nothing: "/" always works.
|
||||
#expect(verified > 0)
|
||||
}
|
||||
#endif
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
@available(System 1.9.0, *)
|
||||
@Test func typeIsMagicNumber() throws {
|
||||
// PROC_SUPER_MAGIC from <linux/magic.h>.
|
||||
#expect(try StatFS("/proc").type == FileSystemType(0x9FA0))
|
||||
|
||||
// Magic numbers from 0x80000000 up should round-trip correctly even
|
||||
// on platforms where they're signed.
|
||||
var statfs = StatFS(rawValue: CInterop.StatFS())
|
||||
statfs.type = FileSystemType(0x9123_683E) // BTRFS_SUPER_MAGIC
|
||||
#expect(statfs.type == FileSystemType(0x9123_683E))
|
||||
}
|
||||
|
||||
// The kernel sets ST_VALID (0x20) in every `f_flags` to mark the field as
|
||||
// filled in, though Bionic's `statfs()` clears it.
|
||||
@available(System 1.9.0, *)
|
||||
@Test func mountFlagsOmitValidBit() throws {
|
||||
var raw = CInterop.StatFS()
|
||||
raw.f_flags = 0x20 | 0x01 // ST_VALID | ST_RDONLY
|
||||
var statfs = StatFS(rawValue: raw)
|
||||
#expect(statfs.mountFlags == .readOnly)
|
||||
|
||||
statfs.mountFlags = .noExecution
|
||||
#expect(statfs.rawValue.f_flags == 0x20 | 0x08) // ST_VALID | ST_NOEXEC
|
||||
|
||||
let root = try StatFS("/")
|
||||
#if os(Linux)
|
||||
#expect(root.rawValue.f_flags & 0x20 != 0)
|
||||
#endif
|
||||
#expect(root.mountFlags.rawValue & 0x20 == 0)
|
||||
}
|
||||
#endif
|
||||
|
||||
#if os(Linux) || os(Android)
|
||||
@available(System 1.9.0, *)
|
||||
@Test func mountFlagBitsMatchLibc() throws {
|
||||
let expected: [(name: String, literal: CInterop.MountFlags, libc: UInt64)] = [
|
||||
("ST_RDONLY", _ST_RDONLY_BIT, _system_get_ST_RDONLY()),
|
||||
("ST_NOSUID", _ST_NOSUID_BIT, _system_get_ST_NOSUID()),
|
||||
("ST_NODEV", _ST_NODEV_BIT, _system_get_ST_NODEV()),
|
||||
("ST_NOEXEC", _ST_NOEXEC_BIT, _system_get_ST_NOEXEC()),
|
||||
("ST_SYNCHRONOUS", _ST_SYNCHRONOUS_BIT, _system_get_ST_SYNCHRONOUS()),
|
||||
("ST_MANDLOCK", _ST_MANDLOCK_BIT, _system_get_ST_MANDLOCK()),
|
||||
("ST_NOATIME", _ST_NOATIME_BIT, _system_get_ST_NOATIME()),
|
||||
("ST_NODIRATIME", _ST_NODIRATIME_BIT, _system_get_ST_NODIRATIME()),
|
||||
("ST_RELATIME", _ST_RELATIME_BIT, _system_get_ST_RELATIME()),
|
||||
("ST_NOSYMFOLLOW", _ST_NOSYMFOLLOW_BIT, _system_get_ST_NOSYMFOLLOW()),
|
||||
]
|
||||
|
||||
for (name, literal, libc) in expected {
|
||||
#expect(
|
||||
UInt64(literal) == libc,
|
||||
"\(name): literal \(literal) disagrees with libc value \(libc)"
|
||||
)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func fileSystemIDConformances() throws {
|
||||
let id = FileSystemID(_words: (1, 2))
|
||||
#expect(id == FileSystemID(_words: (1, 2)))
|
||||
#expect(id != FileSystemID(_words: (1, 3)))
|
||||
#expect(id != FileSystemID(_words: (3, 2)))
|
||||
#expect(id.hashValue != FileSystemID(_words: (1, 3)).hashValue)
|
||||
|
||||
#if canImport(Foundation)
|
||||
let data = try JSONEncoder().encode(id)
|
||||
#expect(String(decoding: data, as: UTF8.self) == "[1,2]")
|
||||
#expect(try JSONDecoder().decode(FileSystemID.self, from: data) == id)
|
||||
#endif
|
||||
}
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
@available(System 1.9.0, *)
|
||||
@Test func fileSystemTypeNameConformances() throws {
|
||||
let name: FileSystemTypeName = "apfs"
|
||||
#expect(name == FileSystemTypeName(rawValue: "apfs"))
|
||||
#expect(name == FileSystemTypeName("apfs"))
|
||||
#expect(name != "hfs")
|
||||
#expect(name.hashValue == FileSystemTypeName("apfs").hashValue)
|
||||
#expect(name.description == "apfs")
|
||||
#expect(name.debugDescription == #""apfs""#)
|
||||
|
||||
#if canImport(Foundation)
|
||||
let data = try JSONEncoder().encode(name)
|
||||
#expect(String(decoding: data, as: UTF8.self) == #""apfs""#)
|
||||
#expect(try JSONDecoder().decode(FileSystemTypeName.self, from: data) == name)
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
@available(System 1.9.0, *)
|
||||
@Test func fileSystemTypeNameConstants() throws {
|
||||
#expect(FileSystemTypeName.apfs.rawValue == "apfs")
|
||||
#expect(FileSystemTypeName.hfs.rawValue == "hfs")
|
||||
// The root volume is APFS on every supported Apple platform.
|
||||
#expect(try StatFS("/").typeName == .apfs)
|
||||
}
|
||||
#endif
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func descriptions() throws {
|
||||
#expect(MountFlags.readOnly.description == "[.readOnly]")
|
||||
let flags: MountFlags = [.readOnly, .noExecution]
|
||||
#expect(flags.description == "[.readOnly, .noExecution]")
|
||||
#expect(flags.debugDescription == flags.description)
|
||||
#expect(MountFlags(rawValue: 0).description == "[]")
|
||||
|
||||
#expect(FileSystemID(_words: (1, 2)).description == "FileSystemID(1, 2)")
|
||||
}
|
||||
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
// A name buffer with no NUL terminator (malformed) is read in full.
|
||||
@available(System 1.9.0, *)
|
||||
@Test func unterminatedNameBuffers() throws {
|
||||
var raw = CInterop.StatFS()
|
||||
withUnsafeMutableBytes(of: &raw.f_fstypename) { buffer in
|
||||
for i in buffer.indices { buffer[i] = UInt8(ascii: "a") }
|
||||
}
|
||||
withUnsafeMutableBytes(of: &raw.f_mntonname) { buffer in
|
||||
for i in buffer.indices { buffer[i] = UInt8(ascii: "b") }
|
||||
}
|
||||
|
||||
let s = StatFS(rawValue: raw)
|
||||
let typeNameLength = MemoryLayout.size(ofValue: raw.f_fstypename)
|
||||
let mountPointLength = MemoryLayout.size(ofValue: raw.f_mntonname)
|
||||
#expect(s.typeName.rawValue == String(repeating: "a", count: typeNameLength))
|
||||
#expect(s.mountPoint.string == String(repeating: "b", count: mountPointLength))
|
||||
}
|
||||
#endif
|
||||
|
||||
@available(System 1.9.0, *)
|
||||
@Test func equalityAndHashing() throws {
|
||||
try withTemporaryFilePath(basename: "StatFS_equality") { tempDir in
|
||||
let statfs = try StatFS(tempDir)
|
||||
let copy = statfs
|
||||
#expect(statfs == copy)
|
||||
#expect(statfs.hashValue == copy.hashValue)
|
||||
#expect(Set([statfs, copy]).count == 1)
|
||||
|
||||
var mutated = statfs
|
||||
mutated.totalBlocks &+= 1
|
||||
#expect(statfs != mutated)
|
||||
|
||||
// Reserved fields are not part of the value.
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
var reserved = statfs
|
||||
reserved.rawValue.f_reserved.0 &+= 1
|
||||
#expect(statfs == reserved)
|
||||
#expect(statfs.hashValue == reserved.hashValue)
|
||||
|
||||
// Fields without a property, like `f_flags_ext`, are.
|
||||
var extended = statfs
|
||||
extended.rawValue.f_flags_ext ^= 1
|
||||
#expect(statfs != extended)
|
||||
#endif
|
||||
|
||||
// Name buffers are read only up to their NUL terminator, so bytes past
|
||||
// it don't affect the value.
|
||||
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
|
||||
var trailing = statfs
|
||||
try withUnsafeMutableBytes(of: &trailing.rawValue.f_mntonname) { buffer in
|
||||
// The kernel always NUL-terminates the name buffers.
|
||||
let terminator = try #require(buffer.firstIndex(of: 0))
|
||||
if terminator + 1 < buffer.count {
|
||||
buffer[terminator + 1] &+= 1
|
||||
}
|
||||
}
|
||||
#expect(statfs == trailing)
|
||||
#expect(statfs.hashValue == trailing.hashValue)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -16,10 +16,8 @@ import Testing
|
||||
#if SYSTEM_PACKAGE_DARWIN
|
||||
import Darwin
|
||||
#elseif canImport(Glibc)
|
||||
import CSystem
|
||||
import Glibc
|
||||
#elseif canImport(Musl)
|
||||
import CSystem
|
||||
import Musl
|
||||
#elseif canImport(WASILibc)
|
||||
import CSystem
|
||||
|
||||
Reference in new issue
Block a user