Compare commits

..
Author SHA1 Message Date
Guillaume Lessard 0b30161977 Merge branch 'release/1.5.0' into ‘release/1.6.0’ 2026-07-16 13:02:41 -07:00
Guillaume Lessard b349ff8c05 Update pull request workflow 2026-07-16 12:41:01 -07:00
Guillaume Lessard 7cb32eb7a4 Cherry-pick: remove unnecessary type casting
The compiler now imports these as their canonical type, allowing us to directly use without the explicit type cast. Due to the floor of Swift 6.3, we must preserve the type cast values. Introduce an overlay to explicitly cast the values in the older compilers.

Cherry-pick of #308
2026-07-16 10:21:23 -07:00
David Smith 669763cfd5 Merge pull request #309 from apple/david/ioring-crash-fix
Fix a crash when work is interleaved between prepare and submit in IORing
2026-06-04 16:38:10 -07:00
David Smith 6fa5c8a6c1 Explain why this is a class 2026-06-04 16:05:44 -07:00
David Smith 2cae953181 Fix a crash when work is interleaved between prepare and submit in IORing 2026-06-04 16:05:28 -07:00
Guillaume Lessard 7c6ad0fc39 Merge pull request #286 from apple/dev/fix-pread-truncation-windows-1.6.0
[Windows] fix pread/pwrite truncation
2026-01-13 13:53:28 -08:00
lee 13851a3421 Fix silent buffer size truncation in Windows pread/pwrite 2026-01-13 13:37:44 -08:00
Guillaume Lessard 8f8d80a4fe Merge pull request #285 from glessard/fix-HRESULT_FACILITY-1.6.0
[Windows] Fix HRESULT_FACILITY
2026-01-13 13:33:25 -08:00
Guillaume Lessard 608a75b962 Merge pull request #284 from glessard/workflow-edits-1.6.0-again
[ci] re-allow 5.9 and 5.10 for 1.6.x
2026-01-13 12:49:27 -08:00
AZero13 0dbbab4aa1 Fix HRESULT_FACILITY
HRESULT_FACILITY is >> 16 & 0x1fff, not <<
2026-01-13 12:41:47 -08:00
Guillaume Lessard 2eb655e0b7 [ci] re-allow 5.9 and 5.10
- they were excluded in error.
2026-01-13 12:38:57 -08:00
Guillaume Lessard 07a3f090d7 Merge pull request #280 from glessard/workflow-edits-1.6.0
[ci] adjust the pull-request action
2026-01-08 17:06:26 -08:00
Guillaume Lessard dda2b535b7 [ci] adjust the pull-request action 2026-01-08 16:46:01 -08:00
34 changed files with 749 additions and 3222 deletions

No files matched your search

+14 -2
View File
@@ -17,10 +17,14 @@ jobs:
linux_os_versions: '["noble", "jammy", "focal"]'
linux_exclude_swift_versions: |
[
{"swift_version": "5.9"},
{"swift_version": "5.10"},
{"os_version": "noble", "swift_version": "5.9"},
{"os_version": "noble", "swift_version": "5.10"},
{"os_version": "focal", "swift_version": "nightly-6.2"},
{"os_version": "focal", "swift_version": "6.2"},
{"os_version": "focal", "swift_version": "nightly-6.3"},
{"os_version": "focal", "swift_version": "6.3"},
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
{"os_version": "focal", "swift_version": "6.4.x"},
{"os_version": "focal", "swift_version": "nightly-main"},
]
enable_macos_checks: true
@@ -36,6 +40,10 @@ jobs:
[
{"os_version": "focal", "swift_version": "nightly-6.2"},
{"os_version": "focal", "swift_version": "6.2"},
{"os_version": "focal", "swift_version": "nightly-6.3"},
{"os_version": "focal", "swift_version": "6.3"},
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
{"os_version": "focal", "swift_version": "6.4.x"},
{"os_version": "focal", "swift_version": "nightly-main"},
]
enable_wasm_sdk_build: true
@@ -43,6 +51,10 @@ jobs:
[
{"os_version": "focal", "swift_version": "nightly-6.2"},
{"os_version": "focal", "swift_version": "6.2"},
{"os_version": "focal", "swift_version": "nightly-6.3"},
{"os_version": "focal", "swift_version": "6.3"},
{"os_version": "focal", "swift_version": "nightly-6.4.x"},
{"os_version": "focal", "swift_version": "6.4.x"},
{"os_version": "focal", "swift_version": "nightly-main"},
]
enable_android_sdk_build: true
+3 -6
View File
@@ -1,4 +1,4 @@
// swift-tools-version:6.0
// swift-tools-version:5.9
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
@@ -64,8 +64,6 @@ let availability: [Available] = [
Available("1.5.0", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.6.0", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.6.1", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("99", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
]
let swiftSettingsAvailability = availability.map(\.swiftSetting)
@@ -141,6 +139,5 @@ let package = Package(
exclude: testsToExclude,
cSettings: cSettings,
swiftSettings: swiftSettings),
],
swiftLanguageVersions: [.v5]
)
])
-982
View File
@@ -1,982 +0,0 @@
# Stat for Swift System
* Proposal: [SYS-0006](0006-system-stat.md)
* Authors: [Jonathan Flat](https://github.com/jrflat), [Michael Ilseman](https://github.com/milseman), [Rauhul Varma](https://github.com/rauhul)
* Review Manager: TBD
* Status: **Awaiting review**
* Implementation: [apple/swift-system#256](https://github.com/apple/swift-system/pull/256)
* Review: ([pitch](https://forums.swift.org/t/pitch-stat-types-for-swift-system/81616))
#### Revision history
* **v1** Initial version
* **v2** Moved `UTCClock.Instant` properties to **Future Directions** and exposed C `timespec` properties. Expanded **Alternatives Considered** for `Stat` name and time properties.
* **v3** Add `init(_:)` to wrapper types, clarify `FileType(rawValue:)` behavior with `S_IFMT`, rename `.pipe` to `.fifo`, mention `ALLPERMS` instead of `0o7777`, explain "is"-less flag names in **Alternatives Considered**, fix conditionals for FreeBSD flags, clarify that `.type` and `.permissions` depend on `.mode`, clarify that size property behaviors are file system-dependent.
## Introduction
This proposal introduces a Swift-native `Stat` type to the System library, providing comprehensive access to file metadata on Unix-like platforms through type-safe, platform-aware APIs that wrap the C `stat` types and system calls.
## Motivation
Currently, Swift developers who want to work with the file system's lowest level API can only do so through bridged C interfaces. These interfaces lack type safety and require writing non-idiomatic Swift, leading to errors and confusion.
The goal of the `Stat` type is to provide a faithful and performant Swift wrapper around the underlying C system calls while adding type safety, platform abstraction, and improved discoverability/usability with clear naming. For more on the motivation behind System, see [https://www.swift.org/blog/swift-system](https://www.swift.org/blog/swift-system)
## Proposed solution
This proposal adds a `struct Stat` that is available on Unix-like platforms. See discussion on Windows-specific API in **Future Directions**.
### `Stat` - File Metadata
A Swift wrapper around the C `stat` struct that provides type-safe access to file metadata:
```swift
// Get file status from path String
let stat = try Stat("/path/to/file")
// From FileDescriptor
let stat = try fd.stat()
// From FilePath
let stat = try filePath.stat()
// `followTargetSymlink: true` (default) behaves like `stat()`
// `followTargetSymlink: false` behaves like `lstat()`
let stat = try symlinkPath.stat(followTargetSymlink: false)
// Supply flags and optional file descriptor to use the `fstatat()` variant
let stat = try Stat("path/to/file", relativeTo: fd, flags: .symlinkNoFollow)
print("Size: \(stat.size) bytes")
print("Size allocated: \(stat.sizeAllocated) bytes")
print("Type: \(stat.type)") // .regular, .directory, .symbolicLink, etc.
print("Permissions: \(stat.permissions)")
print("Modified: \(stat.modificationTime)")
// Platform-specific information when available
#if canImport(Darwin) || os(FreeBSD)
print("Creation time: \(stat.creationTime)")
#endif
```
### Error Handling
All initializers throw the existing `Errno` type:
```swift
do {
let stat = try Stat("/nonexistent/file")
} catch Errno.noSuchFileOrDirectory {
print("File not found")
} catch {
print("Other error: \(error)")
}
```
These initializers use a typed `throws(Errno)` and require Swift 6.0 or later.
## Detailed design
See the **Appendix** section at the end of this proposal for a table view of Swift API to C mappings.
All API are marked `@_alwaysEmitIntoClient` for performance and back-dating of availability.
### FileType
This proposal introduces `FileType` and `FileMode` types to represent `mode_t` values from the C `stat` struct. The type and permissions of a `FileMode` can be modified for convenience, and `FileMode` handles the respective bit masking.
```swift
/// A file type matching those contained in a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
public struct FileType: RawRepresentable, Sendable, Hashable, Codable {
/// The raw file-type bits from the C mode.
public var rawValue: CInterop.Mode
/// Creates a strongly-typed file type from the raw C `mode_t`.
///
/// - Note: This initializer stores the `rawValue` directly and **does not**
/// mask the value with `S_IFMT`. If the supplied `rawValue` contains bits
/// outside of the `S_IFMT` mask, the resulting `FileType` will not compare
/// equal to constants like `.directory` and `.symbolicLink`, which may
/// be unexpected.
///
/// If you're unsure whether the `mode_t` contains bits outside of `S_IFMT`,
/// you can use `FileMode(rawValue:)` instead to get a strongly-typed
/// `FileMode`, then call `.type` to get the properly masked `FileType`.
public init(rawValue: CInterop.Mode)
/// Directory
///
/// The corresponding C constant is `S_IFDIR`.
public static var directory: FileType { get }
/// Character special device
///
/// The corresponding C constant is `S_IFCHR`.
public static var characterSpecial: FileType { get }
/// Block special device
///
/// The corresponding C constant is `S_IFBLK`.
public static var blockSpecial: FileType { get }
/// Regular file
///
/// The corresponding C constant is `S_IFREG`.
public static var regular: FileType { get }
/// FIFO (or named pipe)
///
/// The corresponding C constant is `S_IFIFO`.
public static var fifo: FileType { get }
/// Symbolic link
///
/// The corresponding C constant is `S_IFLNK`.
public static var symbolicLink: FileType { get }
/// Socket
///
/// The corresponding C constant is `S_IFSOCK`.
public static var socket: FileType { get }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Whiteout file
///
/// The corresponding C constant is `S_IFWHT`.
public static var whiteout: FileType { get }
#endif
}
```
### FileMode
```swift
/// A strongly-typed file mode representing a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
public struct FileMode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C mode.
public var rawValue: CInterop.Mode
/// Creates a strongly-typed `FileMode` from the raw C value.
public init(rawValue: CInterop.Mode)
/// Creates a strongly-typed `FileMode` from the raw C value.
public init(_ rawValue: CInterop.Mode)
/// Creates a `FileMode` from the given file type and permissions.
///
/// - Note: This initializer masks the inputs with their respective bit masks.
public init(type: FileType, permissions: FilePermissions)
/// The file's type, from the mode's file-type bits.
///
/// Setting this property will mask the `newValue` with the file-type bit mask `S_IFMT`.
public var type: FileType { get set }
/// The file's permissions, from the mode's permission bits.
///
/// Setting this property will mask the `newValue` with the permissions bit mask `ALLPERMS`.
public var permissions: FilePermissions { get set }
}
```
### Supporting ID Types
This proposal also uses new `DeviceID`, `UserID`, `GroupID`, and `Inode` types to represent the respective C data types found in `stat`. These are strongly-typed structs instead of `CInterop` typealiases to prevent ambiguity in future System implementations and to allow for added functionality.
For example, with an implementation of `chown`, a developer might accidentally misplace user and group parameters with no warning if both were a typealias of the underlying `unsigned int`. Furthermore, a strongly-typed `DeviceID` would allow us to add functionality such as a `makedev` function, or `major` and `minor` getters.
For now, we define the following for use in `Stat`.
```swift
@frozen
public struct UserID: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.UserID
public init(rawValue: CInterop.UserID)
public init(_ rawValue: CInterop.UserID)
}
@frozen
public struct GroupID: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.GroupID
public init(rawValue: CInterop.GroupID)
public init(_ rawValue: CInterop.GroupID)
}
@frozen
public struct DeviceID: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.DeviceID
public init(rawValue: CInterop.DeviceID)
public init(_ rawValue: CInterop.DeviceID)
}
@frozen
public struct Inode: RawRepresentable, Sendable, Hashable, Codable {
public var rawValue: CInterop.Inode
public init(rawValue: CInterop.Inode)
public init(_ rawValue: CInterop.Inode)
}
```
Each type stores a `CInterop` typealias to ensure an appropriate `rawValue` for the current platform. Added functionality is outside the scope of this proposal and will be included in a future proposal.
### FileFlags
A new `FileFlags` type represents file-specific flags found in a `stat` struct on Darwin, FreeBSD, and OpenBSD. This type would also be useful for an implementation of `chflags()`.
```swift
/// File-specific flags found in the `st_flags` property of a `stat` struct
/// or used as input to `chflags()`.
///
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@frozen
public struct FileFlags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
public let rawValue: CInterop.FileFlags
/// Creates a strongly-typed `FileFlags` from the raw C value.
public init(rawValue: CInterop.FileFlags)
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
/// Do not dump the file during backups.
///
/// The corresponding C constant is `UF_NODUMP`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var noDump: FileFlags { get }
/// File may not be changed.
///
/// The corresponding C constant is `UF_IMMUTABLE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var userImmutable: FileFlags { get }
/// Writes to the file may only append.
///
/// The corresponding C constant is `UF_APPEND`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var userAppend: FileFlags { get }
/// File has been archived.
///
/// The corresponding C constant is `SF_ARCHIVED`.
/// - Note: This flag may only be changed by the superuser.
public static var archived: FileFlags { get }
/// File may not be changed.
///
/// The corresponding C constant is `SF_IMMUTABLE`.
/// - Note: This flag may only be changed by the superuser.
public static var systemImmutable: FileFlags { get }
/// Writes to the file may only append.
///
/// The corresponding C constant is `SF_APPEND`.
/// - Note: This flag may only be changed by the superuser.
public static var systemAppend: FileFlags { get }
// MARK: Flags Available on Darwin and FreeBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Directory is opaque when viewed through a union mount.
///
/// The corresponding C constant is `UF_OPAQUE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var opaque: FileFlags { get }
/// File should not be displayed in a GUI.
///
/// The corresponding C constant is `UF_HIDDEN`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var hidden: FileFlags { get }
/// File may not be removed or renamed.
///
/// The corresponding C constant is `SF_NOUNLINK`.
/// - Note: This flag may only be changed by the superuser.
public static var systemNoUnlink: FileFlags { get }
#endif
// MARK: Flags Available on Darwin only
#if SYSTEM_PACKAGE_DARWIN
/// File is compressed at the file system level.
///
/// The corresponding C constant is `UF_COMPRESSED`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
public static var compressed: FileFlags { get }
/// File is tracked for the purpose of document IDs.
///
/// The corresponding C constant is `UF_TRACKED`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var tracked: FileFlags { get }
/// File requires an entitlement for reading and writing.
///
/// The corresponding C constant is `UF_DATAVAULT`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var dataVault: FileFlags { get }
/// File requires an entitlement for writing.
///
/// The corresponding C constant is `SF_RESTRICTED`.
/// - Note: This flag may only be changed by the superuser.
public static var restricted: FileFlags { get }
/// File is a firmlink.
///
/// Firmlinks are used by macOS to create transparent links between
/// the read-only system volume and writable data volume. For example,
/// the `/Applications` folder on the system volume is a firmlink to
/// the `/Applications` folder on the data volume, allowing the user
/// to see both system- and user-installed applications in a single folder.
///
/// The corresponding C constant is `SF_FIRMLINK`.
/// - Note: This flag may only be changed by the superuser.
public static var firmlink: FileFlags { get }
/// File is a dataless placeholder (content is stored remotely).
///
/// The system will attempt to materialize the file when accessed according to
/// the dataless file materialization policy of the accessing thread or process.
/// See `getiopolicy_np(3)`.
///
/// The corresponding C constant is `SF_DATALESS`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
public static var dataless: FileFlags { get }
#endif
// MARK: Flags Available on FreeBSD Only
#if os(FreeBSD)
/// File may not be removed or renamed.
///
/// The corresponding C constant is `UF_NOUNLINK`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var userNoUnlink: FileFlags { get }
/// File has the Windows offline attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_OFFLINE` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_OFFLINE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var offline: FileFlags { get }
/// File is read-only.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_READONLY` attribute.
///
/// The corresponding C constant is `UF_READONLY`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var readOnly: FileFlags { get }
/// File contains a Windows reparse point.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_REPARSE_POINT` attribute.
///
/// The corresponding C constant is `UF_REPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var reparse: FileFlags { get }
/// File is sparse.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SPARSE_FILE` attribute,
/// or to indicate a sparse file.
///
/// The corresponding C constant is `UF_SPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var sparse: FileFlags { get }
/// File has the Windows system attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SYSTEM` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_SYSTEM`.
/// - Note: This flag may be changed by the file owner or superuser.
public static var system: FileFlags { get }
/// File is a snapshot.
///
/// The corresponding C constant is `SF_SNAPSHOT`.
/// - Note: This flag may only be changed by the superuser.
public static var snapshot: FileFlags { get }
#endif
}
```
### Stat
`Stat` can be initialized from a `FilePath`, `UnsafePointer<CChar>`, or `FileDescriptor`. This proposal also includes functions on `FileDescriptor` and `FilePath` for creating a `Stat` object, seen in the section below.
The initializer accepting a `FileDescriptor` corresponds to `fstat()`. If the file descriptor points to a symlink, this will return information about the symlink itself.
In the non-`FileDescriptor` case, one form of the initializer takes a `followTargetSymlink: Bool = true` parameter. The default `true` corresponds to `stat()` and will follow a symlink at the end of the path. Setting `followTargetSymlink: false` corresponds to `lstat()` and will return information about the symlink itself.
The other form of the initializer receives a path, which can be optionally resolved against a given file descriptor, and a set of `Stat.Flags`. These APIs correspond to the `fstatat()` system call and use a default file descriptor of `AT_FDCWD` if one isn't supplied.
```swift
/// A Swift wrapper of the C `stat` struct.
///
/// - Note: Only available on Unix-like platforms.
@frozen
public struct Stat: RawRepresentable, Sendable {
/// The raw C `stat` struct.
public var rawValue: CInterop.Stat
/// Creates a Swift `Stat` from the raw C struct.
public init(rawValue: CInterop.Stat)
// MARK: Stat.Flags
/// Flags representing those passed to `fstatat()`.
@frozen
public struct Flags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
public let rawValue: CInt
/// Creates a strongly-typed `Stat.Flags` from raw C flags.
public init(rawValue: CInt)
/// If the path ends with a symbolic link, return information about the link itself.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW`.
public static var symlinkNoFollow: Flags { get }
#if SYSTEM_PACKAGE_DARWIN
/// If the path ends with a symbolic link, return information about the link itself.
/// If _any_ symbolic link is encountered during path resolution, return an error.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW_ANY`.
/// - Note: Only available on Darwin.
public static var symlinkNoFollowAny: Flags { get }
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// If the path does not reside in the hierarchy beneath the starting directory, return an error.
///
/// The corresponding C constant is `AT_RESOLVE_BENEATH`.
/// - Note: Only available on Darwin and FreeBSD.
@available(macOS 26.0, iOS 26.0, tvOS 26.0, watchOS 26.0, visionOS 26.0, *)
public static var resolveBeneath: Flags { get }
#endif
#if os(FreeBSD) || os(Linux) || os(Android)
/// If the path is an empty string (or `NULL` since Linux 6.11),
/// return information about the given file descriptor.
///
/// The corresponding C constant is `AT_EMPTY_PATH`.
/// - Note: Only available on FreeBSD, Linux, and Android.
public static var emptyPath: Flags { get }
#endif
}
// MARK: Initializers
/// Creates a `Stat` struct from a `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
public init(
_ path: FilePath,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
public init(
_ path: UnsafePointer<CChar>,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from a `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
public init(
_ fd: FileDescriptor,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from a `FilePath` and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: FilePath,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from a `FilePath` and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: FilePath,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: UnsafePointer<CChar>,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
public init(
_ path: UnsafePointer<CChar>,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno)
// MARK: Properties
/// ID of device containing file
///
/// The corresponding C property is `st_dev`.
public var deviceID: DeviceID { get set }
/// Inode number
///
/// The corresponding C property is `st_ino`.
public var inode: Inode { get set }
/// File mode
///
/// The corresponding C property is `st_mode`.
public var mode: FileMode { get set }
/// File type for the given mode
///
/// - Note: This property is equivalent to `mode.type`. Modifying this
/// property will update the underlying `st_mode` accordingly.
public var type: FileType { get set }
/// File permissions for the given mode
///
/// - Note: This property is equivalent to `mode.permissions`. Modifying
/// this property will update the underlying `st_mode` accordingly.
public var permissions: FilePermissions { get set }
/// Number of hard links
///
/// The corresponding C property is `st_nlink`.
public var linkCount: Int { get set }
/// User ID of owner
///
/// The corresponding C property is `st_uid`.
public var userID: UserID { get set }
/// Group ID of owner
///
/// The corresponding C property is `st_gid`.
public var groupID: GroupID { get set }
/// Device ID (if special file)
///
/// For character or block special files, the returned `DeviceID` may have
/// meaningful `.major` and `.minor` values. For non-special files, this
/// property is usually meaningless and often set to 0.
///
/// The corresponding C property is `st_rdev`.
public var specialDeviceID: DeviceID { get set }
/// Total size, in bytes
///
/// The semantics of this property are tied to the underlying C `st_size` field,
/// which can have file system-dependent behavior. For example, this property
/// can return different values for a file's data fork and resource fork, and some
/// file systems report logical size rather than actual disk usage for compressed
/// or cloned files.
///
/// The corresponding C property is `st_size`.
public var size: Int64 { get set }
/// Block size for filesystem I/O, in bytes
///
/// The corresponding C property is `st_blksize`.
public var preferredIOBlockSize: Int { get set }
/// Number of 512-byte blocks allocated
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file system-dependent behavior.
///
/// The corresponding C property is `st_blocks`.
public var blocksAllocated: Int64 { get set }
/// Total size allocated, in bytes
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file system-dependent behavior.
///
/// - Note: Calculated as `512 * blocksAllocated`.
public var sizeAllocated: Int64 { get }
// NOTE: "st_" property names are used for the `timespec` properties so
// we can reserve `accessTime`, `modificationTime`, etc. for potential
// `UTCClock.Instant` properties in the future.
// See Future Directions for more info.
/// Time of last access, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_atim` (or `st_atimespec` on Darwin).
public var st_atim: timespec { get set }
/// Time of last modification, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_mtim` (or `st_mtimespec` on Darwin).
public var st_mtim: timespec { get set }
/// Time of last status (inode) change, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_ctim` (or `st_ctimespec` on Darwin).
public var st_ctim: timespec { get set }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Time of file creation, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_birthtim` (or `st_birthtimespec` on Darwin).
/// - Note: Only available on Darwin and FreeBSD.
public var st_birthtim: timespec { get set }
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
/// File flags
///
/// The corresponding C property is `st_flags`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
public var flags: FileFlags { get set }
/// File generation number
///
/// The file generation number is used to distinguish between different files
/// that have used the same inode over time.
///
/// The corresponding C property is `st_gen`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
public var generationNumber: Int { get set }
#endif
}
// MARK: - Equatable and Hashable
extension Stat: Equatable {
/// Compares the raw bytes of two `Stat` structs for equality.
public static func == (lhs: Self, rhs: Self) -> Bool
}
extension Stat: Hashable {
/// Hashes the raw bytes of this `Stat` struct.
public func hash(into hasher: inout Hasher)
}
```
### FileDescriptor and FilePath Extensions
```swift
extension FileDescriptor {
/// Creates a `Stat` struct for the file referenced by this `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
public func stat(
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
}
extension FilePath {
/// Creates a `Stat` struct for the file referenced by this `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
public func stat(
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
public func stat(
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
public func stat(
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat
}
```
### CInterop Extensions
This proposal extends the existing `CInterop` namespace with platform-appropriate typealiases for the underlying C types. These typealiases are used as the `rawValue` for their strongly-typed representations.
```swift
extension CInterop {
public typealias Stat
public typealias Inode
public typealias UserID
public typealias GroupID
public typealias DeviceID
public typealias FileFlags
}
```
## Source compatibility
This proposal is additive and source-compatible with existing code.
## ABI compatibility
This proposal is additive and ABI-compatible with existing code.
## Implications on adoption
This feature can be freely adopted and un-adopted in source code with no deployment constraints and without affecting source or ABI compatibility.
## Future directions
To remain faithful to the underlying system calls, we don't anticipate extending `Stat`. However, the types introduced in this proposal could serve as the foundation of broader file system APIs in Swift.
While this proposal does not include `Stat` on Windows, a separate proposal should provide Swift-native wrappers of idiomatic `GetFileInformation` functions with their associated types.
A more general `FileInfo` API could then build on these OS-specific types to provide an ergonomic, cross-platform abstraction for file metadata. These future cross-platform APIs might be better implemented outside of System, such as in Foundation, the standard library, or somewhere in between. They could provide additional information or convenience features, such as reading and modifying extended attributes or setting file timestamps.
In the future, more functionality could be added to types such as `DeviceID`.
### Using `UTCClock.Instant` for time properties
When the `UTCClock` proposal and code destination is finalized, we could use the `UTCClock.Instant` type for `Stat` time properties:
```swift
extension Stat {
/// Time of last access, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_atim` (or `st_atimespec` on Darwin).
public var accessTime: UTCClock.Instant { get set }
/// Time of last modification, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_mtim` (or `st_mtimespec` on Darwin).
public var modificationTime: UTCClock.Instant { get set }
/// Time of last status (inode) change, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_ctim` (or `st_ctimespec` on Darwin).
public var changeTime: UTCClock.Instant { get set }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Time of file creation, given as a `UTCClock.Instant`
///
/// The corresponding C property is `st_birthtim` (or `st_birthtimespec` on Darwin).
/// - Note: Only available on Darwin and FreeBSD.
public var creationTime: UTCClock.Instant { get set }
#endif
}
```
We would reserve the more ergonomic `accessTime`, `modificationTime`, etc. names for these future extensions.
## Alternatives considered
### `FileInfo` as the lowest-level type
An alternative approach could be to have a more general `FileInfo` type be the lowest level of abstraction provided by the System library. This type would then handle all the `stat` or Windows-specific struct storage and accessors. However, this alternative:
- Is inconsistent with System's philosophy of providing low-level system abstractions.
- Introduces an even larger number of system-specific APIs on each type.
- Misses out on the familiarity of the `stat` name. Developers know what to look for and what to expect from this type.
### Single combined type for both file and file system metadata
Combining `Stat` and `StatFS` (separate proposal) into a single type was considered but rejected because file and file system information serve different purposes and are typically needed in different contexts. Storing and/or initializing both `stat` and `statfs` structs unnecessarily reduces performance when one isn't needed.
### Making `Stat` available on Windows
It's possible to make `Stat` available on Windows and use either the non-native `_stat` functions from CRT or populate the information via a separate `GetFileInformation` call. However, many of the `stat` fields are not- or less-applicable on Windows and are treated as such by `_stat`. For instance, `st_uid` is always zero on Windows, `st_ino` has no meaning in FAT, HPFS, or NTFS file systems, and `st_mode` can only specify a regular file, directory, or character special, with the executable bit depending entirely on the file's path extension.
Rather than forcing Windows file metadata semantics into a cross-platform `Stat` type, we should instead create Windows-specific types that give developers full access to platform-native file metadata. Combined with a higher-level `FileInfo` type that _is_ cross-platform, this gives the best of both low-level and platform-agnostic APIs.
### Only have `FilePath` and `FileDescriptor` extensions rather than initializers that accept these types
While having `.stat()` functions on `FilePath` and `FileDescriptor` is preferred for ergonomics and function chaining, this technique might lack the discoverability of having an initializer on `Stat` directly. This proposal therefore includes both the initializers and extensions.
### Types for time properties
`UTCClock.Instant` would ideally be chosen over alternatives such as `Duration` or a new `Timespec` type to provide a comparable instant in time rather than a duration since the Epoch. However, this would depend on lowering `UTCClock` to System or the standard library and depends on that separate proposal.
Exposing a `timespec` property directly also has benefits; it's faithful to the underlying system's type and already has conversion support to/from `Duration` in the standard library.
Given that `timespec` is not particularly crufty and already has public API supporting its conversions, we decided to expose the raw `timespec` for now under the original C property names (`st_atim`, `st_mtim`, etc.) and reserve more ergonomic names for future extensions.
### Type names
`Stat` was chosen over alternatives like `FileStat` or `FileStatus` for its brevity and likeness to the "stat" system call. Unlike generic names such as `FileInfo` or `FileMetadata`, `Stat` emphasizes the platform-specific nature of this type.
`Stat` and (possible future) `StatFS` names were chosen over `FileStat` and `FileSystemStat`, or a namespaced `File.Stat` and `FileSystem.Stat`, because `Stat` is recognized more as its own concept rather than shorthand for "status." Thus, using `FileSystem.Stat` or `FileSystemStat` for `statfs` in the future might lead to confusion. Also, precedence from other languages' `stat` APIs that use a "file system" namespace might add to this confusion:
```
Rust: fs::metadata() -> fs::Metadata
Python: os.stat() -> os.stat_result
Go: os.Stat() -> fs.FileInfo
```
`Inode` was chosen over alternatives like `FileIndex` or `FileID` to emphasize the platform-specific nature. `IndexNode` is a bit verbose, and despite its etymology, "inode" is now ubiquitous and understood as a single word, making the capitalization `Inode` preferable to `INode`.
### `FileFlags` naming conventions
`FileFlags` property names such as `hidden` and `compressed` could alternatively use an "is" prefix commonly seen in boolean properties to form `.isHidden` and `.isCompressed`. However, we chose to omit the "is" prefix for the following reasons:
- The "is"-less flag names are succinct and closely aligned with the underlying C constants they represent.
- `OptionSet` property names often use an adjective ("hidden") rather than a predicate ("is hidden") when describing a single subject, such as a file. This is likely because "is" does not add to the flow of `flags.contains(.isHidden)` like it does for a direct boolean property, such as `file.isHidden`.
- For both `OptionSet` APIs that describe a single subject and those that describe a collection of elements, there's precedence to omit the "is". Examples of single-subject `OptionSet` APIs include `UIControl.State`, which uses `.highlighted` and `.disabled` rather than `.isHighlighted` and `.isDisabled`, and `FilePermissions`, which uses `.ownerRead` rather than `.isOwnerReadable`. Examples of multi-subject `OptionSet` APIs include `Edge.Set`, which uses `.top` and `.bottom`, and `ShippingOptions` from the `OptionSet` documentation, which uses `.nextDay`, `.priority`, etc.
## Acknowledgments
These new APIs build on excellent types currently available in the System library.
## Appendix
### Swift API to C Mappings
The following tables show the mapping between Swift APIs and their underlying C system calls across different operating systems:
#### `Stat` Initializer Mappings
The `retryOnInterrupt: Bool = true` parameter is omitted for clarity.
| Swift API | Unix-like Platforms |
|-----------|---------------------|
| `Stat(_ path: FilePath, followTargetSymlink: true)` | `stat()` |
| `Stat(_ path: UnsafePointer<CChar>, followTargetSymlink: true)` | `stat()` |
||
| `Stat(_ path: FilePath, followTargetSymlink: false)` | `lstat()` |
| `Stat(_ path: UnsafePointer<CChar>, followTargetSymlink: false)` | `lstat()` |
||
| `Stat(_ path: FilePath, relativeTo: FileDescriptor, flags: Stat.Flags)` | `fstatat()` |
| `Stat(_ path: UnsafePointer<CChar>, relativeTo: FileDescriptor, flags: Stat.Flags)` | `fstatat()` |
||
| `Stat(_ fd: FileDescriptor)` | `fstat()` |
| `FileDescriptor.stat()` | `fstat()` |
||
| `FilePath.stat(followTargetSymlink: true)` | `stat()` |
| `FilePath.stat(followTargetSymlink: false)` | `lstat()` |
| `FilePath.stat(relativeTo: FileDescriptor, flags: Stat.Flags)` | `fstatat()` |
#### `Stat` Property Mappings
`"` denotes the same property name across all operating systems.
| Swift Property | Darwin | FreeBSD | OpenBSD | Linux | Android | WASI |
|----------------|--------|---------|---------|-------|---------|------|
| `deviceID` | `st_dev` | " | " | " | " | " |
| `inode` | `st_ino` | " | " | " | " | " |
| `mode` | `st_mode` | " | " | " | " | " |
| `linkCount` | `st_nlink` | " | " | " | " | " |
| `userID` | `st_uid` | " | " | " | " | " |
| `groupID` | `st_gid` | " | " | " | " | " |
| `specialDeviceID` | `st_rdev` | " | " | " | " | " |
| `size` | `st_size` | " | " | " | " | " |
| `preferredIOBlockSize` | `st_blksize` | " | " | " | " | " |
| `blocksAllocated` | `st_blocks` | " | " | " | " | " |
| `st_atim` | `st_atimespec` | `st_atim` | `st_atim` | `st_atim` | `st_atim` | `st_atim` |
| `st_mtim` | `st_mtimespec` | `st_mtim` | `st_mtim` | `st_mtim` | `st_mtim` | `st_mtim` |
| `st_ctim` | `st_ctimespec` | `st_ctim` | `st_ctim` | `st_ctim` | `st_ctim` | `st_ctim` |
| `st_birthtim` | `st_birthtimespec` | `st_birthtim` | N/A | N/A | N/A | N/A |
| `flags` | `st_flags` | `st_flags` | `st_flags` | N/A | N/A | N/A |
| `generationNumber` | `st_gen` | `st_gen` | `st_gen` | N/A | N/A | N/A |
#### `Stat.Flags` Mappings
| Swift Flag | Darwin | FreeBSD | OpenBSD | Linux | Android | WASI |
|------------|--------|---------|---------|-------|---------|------|
| `symlinkNoFollow` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` | `AT_SYMLINK_NOFOLLOW` |
| `symlinkNoFollowAny` | `AT_SYMLINK_NOFOLLOW_ANY` | N/A | N/A | N/A | N/A | N/A |
| `resolveBeneath` | `AT_RESOLVE_BENEATH` | `AT_RESOLVE_BENEATH` | N/A | N/A | N/A | N/A |
| `emptyPath` | N/A | `AT_EMPTY_PATH` | N/A | `AT_EMPTY_PATH` | `AT_EMPTY_PATH` | N/A |
#### `FileFlags` Mappings
**Note:** `FileFlags` is only available on Darwin, FreeBSD, and OpenBSD.
| Swift Flag | Darwin | FreeBSD | OpenBSD |
|------------|--------|---------|---------|
| `noDump` | `UF_NODUMP` | `UF_NODUMP` | `UF_NODUMP` |
| `userImmutable` | `UF_IMMUTABLE` | `UF_IMMUTABLE` | `UF_IMMUTABLE` |
| `userAppend` | `UF_APPEND` | `UF_APPEND` | `UF_APPEND` |
| `archived` | `SF_ARCHIVED` | `SF_ARCHIVED` | `SF_ARCHIVED` |
| `systemImmutable` | `SF_IMMUTABLE` | `SF_IMMUTABLE` | `SF_IMMUTABLE` |
| `systemAppend` | `SF_APPEND` | `SF_APPEND` | `SF_APPEND` |
| `opaque` | `UF_OPAQUE` | `UF_OPAQUE` | N/A |
| `hidden` | `UF_HIDDEN` | `UF_HIDDEN` | N/A |
| `systemNoUnlink` | `SF_NOUNLINK` | `SF_NOUNLINK` | N/A |
| `compressed` | `UF_COMPRESSED` | N/A | N/A |
| `tracked` | `UF_TRACKED` | N/A | N/A |
| `dataVault` | `UF_DATAVAULT` | N/A | N/A |
| `restricted` | `SF_RESTRICTED` | N/A | N/A |
| `firmlink` | `SF_FIRMLINK` | N/A | N/A |
| `dataless` | `SF_DATALESS` | N/A | N/A |
| `userNoUnlink` | N/A | `UF_NOUNLINK` | N/A |
| `offline` | N/A | `UF_OFFLINE` | N/A |
| `readOnly` | N/A | `UF_READONLY` | N/A |
| `reparse` | N/A | `UF_REPARSE` | N/A |
| `sparse` | N/A | `UF_SPARSE` | N/A |
| `system` | N/A | `UF_SYSTEM` | N/A |
| `snapshot` | N/A | `SF_SNAPSHOT` | N/A |
-2
View File
@@ -134,8 +134,6 @@ typedef struct __SWIFT_IORING_SQE_FALLBACK_STRUCT swift_io_uring_sqe;
#define IORING_FEAT_RW_ATTR (1U << 16)
#define IORING_FEAT_NO_IOWAIT (1U << 17)
#define IORING_POLL_ADD_MULTI (1U << 0)
#if !defined(_ASM_GENERIC_INT_LL64_H) && !defined(_ASM_GENERIC_INT_L64_H) && !defined(_UAPI_ASM_GENERIC_INT_LL64_H) && !defined(_UAPI_ASM_GENERIC_INT_L64_H)
typedef uint8_t __u8;
typedef uint16_t __u16;
+2 -2
View File
@@ -160,7 +160,7 @@ public struct Errno: RawRepresentable, Error, Hashable, Codable {
/// No child processes.
///
/// A `wait(2)` or `waitpid(2)` function was executed
/// by a process that dosn't have any existing child processes
/// by a process that doesn't have any existing child processes
/// or whose child processes are all already being waited for.
///
/// The corresponding C error is `ECHILD`.
@@ -961,7 +961,7 @@ public struct Errno: RawRepresentable, Error, Hashable, Codable {
/// Stale NFS file handle.
///
/// You attempted access an open file on an NFS file system,
/// You attempted access an open file on an NFS filesystem,
/// which is now unavailable as referenced by the given file descriptor.
/// This may indicate that the file was deleted on the NFS server
/// or that some other catastrophic event occurred.
@@ -73,7 +73,7 @@ internal func _recursiveRemove(
) throws {
// First, deal with subdirectories
try forEachFile(at: path) { findData in
if (findData.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY)) != 0 {
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 {
let name = withUnsafeBytes(of: findData.cFileName) {
return SystemString(platformString: $0.assumingMemoryBound(
to: CInterop.PlatformChar.self).baseAddress!)
@@ -94,7 +94,7 @@ internal func _recursiveRemove(
let component = FilePath.Component(name)!
let subpath = path.appending(component)
if (findData.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY)) == 0 {
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 {
try subpath.withPlatformString { subpath in
if try !subpath.withCanonicalPathRepresentation({ DeleteFileW($0) }) {
throw Errno(windowsError: GetLastError())
@@ -517,7 +517,7 @@ fileprivate func HRESULT_CODE(_ hr: HRESULT) -> DWORD {
@inline(__always)
fileprivate func HRESULT_FACILITY(_ hr: HRESULT) -> DWORD {
DWORD(hr << 16) & 0x1fff
DWORD(hr >> 16) & 0x1fff
}
@inline(__always)
@@ -529,7 +529,7 @@ fileprivate func SUCCEEDED(_ hr: HRESULT) -> Bool {
// an HRESULT to a Win32 error code.
@inline(__always)
fileprivate func WIN32_FROM_HRESULT(_ hr: HRESULT) -> DWORD {
if SUCCEEDED(hr) { return DWORD(ERROR_SUCCESS) }
if SUCCEEDED(hr) { return ERROR_SUCCESS }
if HRESULT_FACILITY(hr) == FACILITY_WIN32 {
return HRESULT_CODE(hr)
}
-250
View File
@@ -1,250 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
// |------------------------|
// | Swift API to C Mapping |
// |------------------------------------------------------------------|
// | FileFlags | Darwin | FreeBSD | OpenBSD |
// |------------------|---------------|---------------|---------------|
// | noDump | UF_NODUMP | UF_NODUMP | UF_NODUMP |
// | userImmutable | UF_IMMUTABLE | UF_IMMUTABLE | UF_IMMUTABLE |
// | userAppend | UF_APPEND | UF_APPEND | UF_APPEND |
// | archived | SF_ARCHIVED | SF_ARCHIVED | SF_ARCHIVED |
// | systemImmutable | SF_IMMUTABLE | SF_IMMUTABLE | SF_IMMUTABLE |
// | systemAppend | SF_APPEND | SF_APPEND | SF_APPEND |
// | opaque | UF_OPAQUE | UF_OPAQUE | N/A |
// | hidden | UF_HIDDEN | UF_HIDDEN | N/A |
// | systemNoUnlink | SF_NOUNLINK | SF_NOUNLINK | N/A |
// | compressed | UF_COMPRESSED | N/A | N/A |
// | tracked | UF_TRACKED | N/A | N/A |
// | dataVault | UF_DATAVAULT | N/A | N/A |
// | restricted | SF_RESTRICTED | N/A | N/A |
// | firmlink | SF_FIRMLINK | N/A | N/A |
// | dataless | SF_DATALESS | N/A | N/A |
// | userNoUnlink | N/A | UF_NOUNLINK | N/A |
// | offline | N/A | UF_OFFLINE | N/A |
// | readOnly | N/A | UF_READONLY | N/A |
// | reparse | N/A | UF_REPARSE | N/A |
// | sparse | N/A | UF_SPARSE | N/A |
// | system | N/A | UF_SYSTEM | N/A |
// | snapshot | N/A | SF_SNAPSHOT | N/A |
// |------------------|---------------|---------------|---------------|
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
/// File-specific flags found in the `st_flags` property of a `stat` struct
/// or used as input to `chflags()`.
///
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@frozen
@available(System 99, *)
public struct FileFlags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
@_alwaysEmitIntoClient
public let rawValue: CInterop.FileFlags
/// Creates a strongly-typed `FileFlags` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.FileFlags) { self.rawValue = rawValue }
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
/// Do not dump the file during backups.
///
/// The corresponding C constant is `UF_NODUMP`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var noDump: FileFlags { FileFlags(rawValue: _UF_NODUMP) }
/// File may not be changed.
///
/// The corresponding C constant is `UF_IMMUTABLE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var userImmutable: FileFlags { FileFlags(rawValue: _UF_IMMUTABLE) }
/// Writes to the file may only append.
///
/// The corresponding C constant is `UF_APPEND`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var userAppend: FileFlags { FileFlags(rawValue: _UF_APPEND) }
/// File has been archived.
///
/// The corresponding C constant is `SF_ARCHIVED`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var archived: FileFlags { FileFlags(rawValue: _SF_ARCHIVED) }
/// File may not be changed.
///
/// The corresponding C constant is `SF_IMMUTABLE`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var systemImmutable: FileFlags { FileFlags(rawValue: _SF_IMMUTABLE) }
/// Writes to the file may only append.
///
/// The corresponding C constant is `SF_APPEND`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var systemAppend: FileFlags { FileFlags(rawValue: _SF_APPEND) }
// MARK: Flags Available on Darwin and FreeBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Directory is opaque when viewed through a union mount.
///
/// The corresponding C constant is `UF_OPAQUE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var opaque: FileFlags { FileFlags(rawValue: _UF_OPAQUE) }
/// File should not be displayed in a GUI.
///
/// The corresponding C constant is `UF_HIDDEN`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var hidden: FileFlags { FileFlags(rawValue: _UF_HIDDEN) }
/// File may not be removed or renamed.
///
/// The corresponding C constant is `SF_NOUNLINK`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var systemNoUnlink: FileFlags { FileFlags(rawValue: _SF_NOUNLINK) }
#endif
// MARK: Flags Available on Darwin only
#if SYSTEM_PACKAGE_DARWIN
/// File is compressed at the file system level.
///
/// The corresponding C constant is `UF_COMPRESSED`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
@_alwaysEmitIntoClient
public static var compressed: FileFlags { FileFlags(rawValue: _UF_COMPRESSED) }
/// File is tracked for the purpose of document IDs.
///
/// The corresponding C constant is `UF_TRACKED`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var tracked: FileFlags { FileFlags(rawValue: _UF_TRACKED) }
/// File requires an entitlement for reading and writing.
///
/// The corresponding C constant is `UF_DATAVAULT`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var dataVault: FileFlags { FileFlags(rawValue: _UF_DATAVAULT) }
/// File requires an entitlement for writing.
///
/// The corresponding C constant is `SF_RESTRICTED`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var restricted: FileFlags { FileFlags(rawValue: _SF_RESTRICTED) }
/// File is a firmlink.
///
/// Firmlinks are used by macOS to create transparent links between
/// the read-only system volume and writable data volume. For example,
/// the `/Applications` folder on the system volume is a firmlink to
/// the `/Applications` folder on the data volume, allowing the user
/// to see both system- and user-installed applications in a single folder.
///
/// The corresponding C constant is `SF_FIRMLINK`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var firmlink: FileFlags { FileFlags(rawValue: _SF_FIRMLINK) }
/// File is a dataless placeholder (content is stored remotely).
///
/// The system will attempt to materialize the file when accessed according to
/// the dataless file materialization policy of the accessing thread or process.
/// See `getiopolicy_np(3)`.
///
/// The corresponding C constant is `SF_DATALESS`.
/// - Note: This flag is read-only. Attempting to change it will result in undefined behavior.
@_alwaysEmitIntoClient
public static var dataless: FileFlags { FileFlags(rawValue: _SF_DATALESS) }
#endif
// MARK: Flags Available on FreeBSD Only
#if os(FreeBSD)
/// File may not be removed or renamed.
///
/// The corresponding C constant is `UF_NOUNLINK`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var userNoUnlink: FileFlags { FileFlags(rawValue: _UF_NOUNLINK) }
/// File has the Windows offline attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_OFFLINE` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_OFFLINE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var offline: FileFlags { FileFlags(rawValue: _UF_OFFLINE) }
/// File is read-only.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_READONLY` attribute.
///
/// The corresponding C constant is `UF_READONLY`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var readOnly: FileFlags { FileFlags(rawValue: _UF_READONLY) }
/// File contains a Windows reparse point.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_REPARSE_POINT` attribute.
///
/// The corresponding C constant is `UF_REPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var reparse: FileFlags { FileFlags(rawValue: _UF_REPARSE) }
/// File is sparse.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SPARSE_FILE` attribute,
/// or to indicate a sparse file.
///
/// The corresponding C constant is `UF_SPARSE`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var sparse: FileFlags { FileFlags(rawValue: _UF_SPARSE) }
/// File has the Windows system attribute.
///
/// File systems may use this flag for compatibility with the Windows `FILE_ATTRIBUTE_SYSTEM` attribute,
/// but otherwise provide no special handling when it's set.
///
/// The corresponding C constant is `UF_SYSTEM`.
/// - Note: This flag may be changed by the file owner or superuser.
@_alwaysEmitIntoClient
public static var system: FileFlags { FileFlags(rawValue: _UF_SYSTEM) }
/// File is a snapshot.
///
/// The corresponding C constant is `SF_SNAPSHOT`.
/// - Note: This flag may only be changed by the superuser.
@_alwaysEmitIntoClient
public static var snapshot: FileFlags { FileFlags(rawValue: _SF_SNAPSHOT) }
#endif
}
#endif
-54
View File
@@ -1,54 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
/// A strongly-typed file mode representing a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 99, *)
public struct FileMode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C mode.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Mode
/// Creates a strongly-typed `FileMode` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Mode) { self.rawValue = rawValue }
/// Creates a `FileMode` from the given file type and permissions.
///
/// - Note: This initializer masks the inputs with their respective bit masks.
@_alwaysEmitIntoClient
public init(type: FileType, permissions: FilePermissions) {
self.rawValue = (type.rawValue & _MODE_FILETYPE_MASK) | (permissions.rawValue & _MODE_PERMISSIONS_MASK)
}
/// The file's type, from the mode's file-type bits.
///
/// Setting this property will mask the `newValue` with the file-type bit mask `S_IFMT`.
@_alwaysEmitIntoClient
public var type: FileType {
get { FileType(rawValue: rawValue & _MODE_FILETYPE_MASK) }
set { rawValue = (rawValue & ~_MODE_FILETYPE_MASK) | (newValue.rawValue & _MODE_FILETYPE_MASK) }
}
/// The file's permissions, from the mode's permission bits.
///
/// Setting this property will mask the `newValue` with the permissions bit mask `ALLPERMS`.
@_alwaysEmitIntoClient
public var permissions: FilePermissions {
get { FilePermissions(rawValue: rawValue & _MODE_PERMISSIONS_MASK) }
set { rawValue = (rawValue & ~_MODE_PERMISSIONS_MASK) | (newValue.rawValue & _MODE_PERMISSIONS_MASK) }
}
}
#endif
-108
View File
@@ -1,108 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
// |------------------------|
// | Swift API to C Mapping |
// |----------------------------------------|
// | FileType | Unix-like Platforms |
// |------------------|---------------------|
// | directory | S_IFDIR |
// | characterSpecial | S_IFCHR |
// | blockSpecial | S_IFBLK |
// | regular | S_IFREG |
// | fifo | S_IFIFO |
// | symbolicLink | S_IFLNK |
// | socket | S_IFSOCK |
// |------------------|---------------------|
//
// |------------------------------------------------------------------|
// | FileType | Darwin | FreeBSD | Other Unix-like Platforms |
// |------------------|---------|---------|---------------------------|
// | whiteout | S_IFWHT | S_IFWHT | N/A |
// |------------------|---------|---------|---------------------------|
#if !os(Windows)
/// A file type matching those contained in a C `mode_t`.
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 99, *)
public struct FileType: RawRepresentable, Sendable, Hashable, Codable {
/// The raw file-type bits from the C mode.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Mode
/// Creates a strongly-typed file type from the raw C `mode_t`.
///
/// - Note: This initializer stores the `rawValue` directly and **does not**
/// mask the value with `S_IFMT`. If the supplied `rawValue` contains bits
/// outside of the `S_IFMT` mask, the resulting `FileType` will not compare
/// equal to constants like `.directory` and `.symbolicLink`, which may
/// be unexpected.
///
/// If you're unsure whether the `mode_t` contains bits outside of `S_IFMT`,
/// you can use `FileMode(rawValue:)` instead to get a strongly-typed
/// `FileMode`, then call `.type` to get the properly masked `FileType`.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Mode) { self.rawValue = rawValue }
/// Directory
///
/// The corresponding C constant is `S_IFDIR`.
@_alwaysEmitIntoClient
public static var directory: FileType { FileType(rawValue: _S_IFDIR) }
/// Character special device
///
/// The corresponding C constant is `S_IFCHR`.
@_alwaysEmitIntoClient
public static var characterSpecial: FileType { FileType(rawValue: _S_IFCHR) }
/// Block special device
///
/// The corresponding C constant is `S_IFBLK`.
@_alwaysEmitIntoClient
public static var blockSpecial: FileType { FileType(rawValue: _S_IFBLK) }
/// Regular file
///
/// The corresponding C constant is `S_IFREG`.
@_alwaysEmitIntoClient
public static var regular: FileType { FileType(rawValue: _S_IFREG) }
/// FIFO (or named pipe)
///
/// The corresponding C constant is `S_IFIFO`.
@_alwaysEmitIntoClient
public static var fifo: FileType { FileType(rawValue: _S_IFIFO) }
/// Symbolic link
///
/// The corresponding C constant is `S_IFLNK`.
@_alwaysEmitIntoClient
public static var symbolicLink: FileType { FileType(rawValue: _S_IFLNK) }
/// Socket
///
/// The corresponding C constant is `S_IFSOCK`.
@_alwaysEmitIntoClient
public static var socket: FileType { FileType(rawValue: _S_IFSOCK) }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Whiteout file
///
/// The corresponding C constant is `S_IFWHT`.
@_alwaysEmitIntoClient
public static var whiteout: FileType { FileType(rawValue: _S_IFWHT) }
#endif
}
#endif
@@ -1,84 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
/// A Swift wrapper of the C `uid_t` type.
@frozen
@available(System 99, *)
public struct UserID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `uid_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.UserID
/// Creates a strongly-typed `UserID` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.UserID) { self.rawValue = rawValue }
/// Creates a strongly-typed `UserID` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.UserID) { self.rawValue = rawValue }
}
/// A Swift wrapper of the C `gid_t` type.
@frozen
@available(System 99, *)
public struct GroupID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `gid_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.GroupID
/// Creates a strongly-typed `GroupID` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.GroupID) { self.rawValue = rawValue }
/// Creates a strongly-typed `GroupID` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.GroupID) { self.rawValue = rawValue }
}
/// A Swift wrapper of the C `dev_t` type.
@frozen
@available(System 99, *)
public struct DeviceID: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `dev_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.DeviceID
/// Creates a strongly-typed `DeviceID` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.DeviceID) { self.rawValue = rawValue }
/// Creates a strongly-typed `DeviceID` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.DeviceID) { self.rawValue = rawValue }
}
/// A Swift wrapper of the C `ino_t` type.
@frozen
@available(System 99, *)
public struct Inode: RawRepresentable, Sendable, Hashable, Codable {
/// The raw C `ino_t`.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Inode
/// Creates a strongly-typed `Inode` from the raw C value.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Inode) { self.rawValue = rawValue }
/// Creates a strongly-typed `Inode` from the raw C value.
@_alwaysEmitIntoClient
public init(_ rawValue: CInterop.Inode) { self.rawValue = rawValue }
}
#endif // !os(Windows)
-632
View File
@@ -1,632 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
// Must import here to use C stat properties in @_alwaysEmitIntoClient APIs.
#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")
#endif
// MARK: - Stat
/// A Swift wrapper of the C `stat` struct.
///
/// - Note: Only available on Unix-like platforms.
@frozen
@available(System 99, *)
public struct Stat: RawRepresentable, Sendable {
/// The raw C `stat` struct.
@_alwaysEmitIntoClient
public var rawValue: CInterop.Stat
/// Creates a Swift `Stat` from the raw C struct.
@_alwaysEmitIntoClient
public init(rawValue: CInterop.Stat) { self.rawValue = rawValue }
// MARK: Stat.Flags
/// Flags representing those passed to `fstatat()`.
@frozen
public struct Flags: OptionSet, Sendable, Hashable, Codable {
/// The raw C flags.
@_alwaysEmitIntoClient
public let rawValue: CInt
/// Creates a strongly-typed `Stat.Flags` from raw C flags.
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
/// If the path ends with a symbolic link, return information about the link itself.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW`.
@_alwaysEmitIntoClient
public static var symlinkNoFollow: Flags { Flags(rawValue: _AT_SYMLINK_NOFOLLOW) }
#if SYSTEM_PACKAGE_DARWIN
/// If the path ends with a symbolic link, return information about the link itself.
/// If _any_ symbolic link is encountered during path resolution, return an error.
///
/// The corresponding C constant is `AT_SYMLINK_NOFOLLOW_ANY`.
/// - Note: Only available on Darwin.
@_alwaysEmitIntoClient
public static var symlinkNoFollowAny: Flags { Flags(rawValue: _AT_SYMLINK_NOFOLLOW_ANY) }
#endif
#if canImport(Darwin, _version: 346) || os(FreeBSD)
/// If the path does not reside in the hierarchy beneath the starting directory, return an error.
///
/// The corresponding C constant is `AT_RESOLVE_BENEATH`.
/// - Note: Only available on Darwin and FreeBSD.
@_alwaysEmitIntoClient
public static var resolveBeneath: Flags { Flags(rawValue: _AT_RESOLVE_BENEATH) }
#endif
}
// MARK: Initializers
/// Creates a `Stat` struct from a `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
@_alwaysEmitIntoClient
public init(
_ path: FilePath,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try path.withPlatformString {
Self._stat(
$0,
followTargetSymlink: followTargetSymlink,
retryOnInterrupt: retryOnInterrupt
)
}.get()
}
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
@_alwaysEmitIntoClient
public init(
_ path: UnsafePointer<CChar>,
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._stat(
path,
followTargetSymlink: followTargetSymlink,
retryOnInterrupt: retryOnInterrupt
).get()
}
@usableFromInline
internal static func _stat(
_ ptr: UnsafePointer<CChar>,
followTargetSymlink: Bool,
retryOnInterrupt: Bool
) -> Result<CInterop.Stat, Errno> {
var result = CInterop.Stat()
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
if followTargetSymlink {
system_stat(ptr, &result)
} else {
system_lstat(ptr, &result)
}
}.map { result }
}
/// Creates a `Stat` struct from a `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
@_alwaysEmitIntoClient
public init(
_ fd: FileDescriptor,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._fstat(
fd,
retryOnInterrupt: retryOnInterrupt
).get()
}
@usableFromInline
internal static func _fstat(
_ fd: FileDescriptor,
retryOnInterrupt: Bool
) -> Result<CInterop.Stat, Errno> {
var result = CInterop.Stat()
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_fstat(fd.rawValue, &result)
}.map { result }
}
/// Creates a `Stat` struct from a `FilePath` and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: FilePath,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try path.withPlatformString {
Self._fstatat(
$0,
relativeTo: _AT_FDCWD,
flags: flags,
retryOnInterrupt: retryOnInterrupt
)
}.get()
}
/// Creates a `Stat` struct from a `FilePath` and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: FilePath,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try path.withPlatformString {
Self._fstatat(
$0,
relativeTo: fd.rawValue,
flags: flags,
retryOnInterrupt: retryOnInterrupt
)
}.get()
}
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: UnsafePointer<CChar>,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._fstatat(
path,
relativeTo: _AT_FDCWD,
flags: flags,
retryOnInterrupt: retryOnInterrupt
).get()
}
/// Creates a `Stat` struct from an `UnsafePointer<CChar>` path and `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public init(
_ path: UnsafePointer<CChar>,
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) {
self.rawValue = try Self._fstatat(
path,
relativeTo: fd.rawValue,
flags: flags,
retryOnInterrupt: retryOnInterrupt
).get()
}
@usableFromInline
internal static func _fstatat(
_ path: UnsafePointer<CChar>,
relativeTo fd: FileDescriptor.RawValue,
flags: Stat.Flags,
retryOnInterrupt: Bool
) -> Result<CInterop.Stat, Errno> {
var result = CInterop.Stat()
return nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_fstatat(fd, path, &result, flags.rawValue)
}.map { result }
}
// MARK: Properties
/// ID of device containing file
///
/// The corresponding C property is `st_dev`.
@_alwaysEmitIntoClient
public var deviceID: DeviceID {
get { DeviceID(rawValue: numericCast(rawValue.st_dev)) }
set { rawValue.st_dev = numericCast(newValue.rawValue) }
}
/// Inode number
///
/// The corresponding C property is `st_ino`.
@_alwaysEmitIntoClient
public var inode: Inode {
get { Inode(rawValue: numericCast(rawValue.st_ino)) }
set { rawValue.st_ino = numericCast(newValue.rawValue) }
}
/// File mode
///
/// The corresponding C property is `st_mode`.
@_alwaysEmitIntoClient
public var mode: FileMode {
get { FileMode(rawValue: numericCast(rawValue.st_mode)) }
set { rawValue.st_mode = numericCast(newValue.rawValue) }
}
/// File type for the given mode
///
/// - Note: This property is equivalent to `mode.type`. Modifying this
/// property will update the underlying `st_mode` accordingly.
@_alwaysEmitIntoClient
public var type: FileType {
get { mode.type }
set {
var newMode = mode
newMode.type = newValue
mode = newMode
}
}
/// File permissions for the given mode
///
/// - Note: This property is equivalent to `mode.permissions`. Modifying
/// this property will update the underlying `st_mode` accordingly.
@_alwaysEmitIntoClient
public var permissions: FilePermissions {
get { mode.permissions }
set {
var newMode = mode
newMode.permissions = newValue
mode = newMode
}
}
/// Number of hard links
///
/// The corresponding C property is `st_nlink`.
@_alwaysEmitIntoClient
public var linkCount: Int {
get { Int(rawValue.st_nlink) }
set { rawValue.st_nlink = numericCast(newValue) }
}
/// User ID of owner
///
/// The corresponding C property is `st_uid`.
@_alwaysEmitIntoClient
public var userID: UserID {
get { UserID(rawValue: rawValue.st_uid) }
set { rawValue.st_uid = newValue.rawValue }
}
/// Group ID of owner
///
/// The corresponding C property is `st_gid`.
@_alwaysEmitIntoClient
public var groupID: GroupID {
get { GroupID(rawValue: rawValue.st_gid) }
set { rawValue.st_gid = newValue.rawValue }
}
/// Device ID (if special file)
///
/// For character or block special files, the returned `DeviceID` may have
/// meaningful major and minor values. For non-special files, this
/// property is usually meaningless and often set to 0.
///
/// The corresponding C property is `st_rdev`.
@_alwaysEmitIntoClient
public var specialDeviceID: DeviceID {
get { DeviceID(rawValue: numericCast(rawValue.st_rdev)) }
set { rawValue.st_rdev = numericCast(newValue.rawValue) }
}
/// Total size, in bytes
///
/// The semantics of this property are tied to the underlying C `st_size` field,
/// which can have file-system–dependent behavior. For example, this property
/// can return different values for a file's data fork and resource fork, and some
/// file systems report logical size rather than actual disk usage for compressed
/// or cloned files.
///
/// The corresponding C property is `st_size`.
@_alwaysEmitIntoClient
public var size: Int64 {
get { Int64(rawValue.st_size) }
set { rawValue.st_size = numericCast(newValue) }
}
/// Block size for file system I/O, in bytes
///
/// The corresponding C property is `st_blksize`.
@_alwaysEmitIntoClient
public var preferredIOBlockSize: Int {
get { Int(rawValue.st_blksize) }
set { rawValue.st_blksize = numericCast(newValue) }
}
/// Number of 512-byte blocks allocated
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file-system–dependent behavior.
///
/// The corresponding C property is `st_blocks`.
@_alwaysEmitIntoClient
public var blocksAllocated: Int64 {
get { Int64(rawValue.st_blocks) }
set { rawValue.st_blocks = numericCast(newValue) }
}
/// Total size allocated, in bytes
///
/// The semantics of this property are tied to the underlying C `st_blocks` field,
/// which can have file-system–dependent behavior.
///
/// - Note: Calculated as `512 * blocksAllocated`.
@_alwaysEmitIntoClient
public var sizeAllocated: Int64 {
512 * blocksAllocated
}
// NOTE: "st_" property names are used for the `timespec` properties so
// we can reserve `accessTime`, `modificationTime`, etc. for potential
// `UTCClock.Instant` properties in the future.
/// Time of last access, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_atim` (or `st_atimespec` on Darwin).
@_alwaysEmitIntoClient
public var st_atim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_atimespec
#else
rawValue.st_atim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_atimespec = newValue
#else
rawValue.st_atim = newValue
#endif
}
}
/// Time of last modification, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_mtim` (or `st_mtimespec` on Darwin).
@_alwaysEmitIntoClient
public var st_mtim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_mtimespec
#else
rawValue.st_mtim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_mtimespec = newValue
#else
rawValue.st_mtim = newValue
#endif
}
}
/// Time of last status (inode) change, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_ctim` (or `st_ctimespec` on Darwin).
@_alwaysEmitIntoClient
public var st_ctim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_ctimespec
#else
rawValue.st_ctim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_ctimespec = newValue
#else
rawValue.st_ctim = newValue
#endif
}
}
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Time of file creation, given as a C `timespec` since the Epoch.
///
/// The corresponding C property is `st_birthtim` (or `st_birthtimespec` on Darwin).
/// - Note: Only available on Darwin and FreeBSD.
@_alwaysEmitIntoClient
public var st_birthtim: timespec {
get {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_birthtimespec
#else
rawValue.st_birthtim
#endif
}
set {
#if SYSTEM_PACKAGE_DARWIN
rawValue.st_birthtimespec = newValue
#else
rawValue.st_birthtim = newValue
#endif
}
}
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
/// File flags
///
/// The corresponding C property is `st_flags`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@_alwaysEmitIntoClient
public var flags: FileFlags {
get { FileFlags(rawValue: rawValue.st_flags) }
set { rawValue.st_flags = newValue.rawValue }
}
/// File generation number
///
/// The file generation number is used to distinguish between different files
/// that have used the same inode over time.
///
/// The corresponding C property is `st_gen`.
/// - Note: Only available on Darwin, FreeBSD, and OpenBSD.
@_alwaysEmitIntoClient
public var generationNumber: Int {
get { Int(rawValue.st_gen) }
set { rawValue.st_gen = numericCast(newValue)}
}
#endif
}
// MARK: - Equatable and Hashable
@available(System 99, *)
extension Stat: Equatable {
@_alwaysEmitIntoClient
/// Compares the raw bytes of two `Stat` structs for equality.
public static func == (lhs: Self, rhs: Self) -> Bool {
return withUnsafeBytes(of: lhs.rawValue) { lhsBytes in
withUnsafeBytes(of: rhs.rawValue) { rhsBytes in
lhsBytes.elementsEqual(rhsBytes)
}
}
}
}
@available(System 99, *)
extension Stat: Hashable {
@_alwaysEmitIntoClient
/// Hashes the raw bytes of this `Stat` struct.
public func hash(into hasher: inout Hasher) {
withUnsafeBytes(of: rawValue) { bytes in
hasher.combine(bytes: bytes)
}
}
}
// MARK: - CustomStringConvertible and CustomDebugStringConvertible
// MARK: - FileDescriptor Extensions
@available(System 99, *)
extension FileDescriptor {
/// Creates a `Stat` struct for the file referenced by this `FileDescriptor`.
///
/// The corresponding C function is `fstat()`.
@_alwaysEmitIntoClient
public func stat(
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, retryOnInterrupt: retryOnInterrupt)
}
}
// MARK: - FilePath Extensions
@available(System 99, *)
extension FilePath {
/// Creates a `Stat` struct for the file referenced by this `FilePath`.
///
/// `followTargetSymlink` determines the behavior if `path` ends with a symbolic link.
/// By default, `followTargetSymlink` is `true` and this initializer behaves like `stat()`.
/// If `followTargetSymlink` is set to `false`, this initializer behaves like `lstat()` and
/// returns information about the symlink itself.
///
/// The corresponding C function is `stat()` or `lstat()` as described above.
@_alwaysEmitIntoClient
public func stat(
followTargetSymlink: Bool = true,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, followTargetSymlink: followTargetSymlink, retryOnInterrupt: retryOnInterrupt)
}
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`.
///
/// If `path` is relative, it is resolved against the current working directory.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public func stat(
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, flags: flags, retryOnInterrupt: retryOnInterrupt)
}
/// Creates a `Stat` struct for the file referenced by this `FilePath` using the given `Flags`,
/// including a `FileDescriptor` to resolve a relative path.
///
/// If `path` is absolute (starts with a forward slash), then `fd` is ignored.
/// If `path` is relative, it is resolved against the directory given by `fd`.
///
/// The corresponding C function is `fstatat()`.
@_alwaysEmitIntoClient
public func stat(
relativeTo fd: FileDescriptor,
flags: Stat.Flags,
retryOnInterrupt: Bool = true
) throws(Errno) -> Stat {
try Stat(self, relativeTo: fd, flags: flags, retryOnInterrupt: retryOnInterrupt)
}
}
#endif // !os(Windows)
+10 -142
View File
@@ -2,7 +2,6 @@
#if os(Linux)
import CSystem
import Glibc
@usableFromInline
internal enum IORequestCore {
@@ -24,22 +23,6 @@ internal enum IORequestCore {
intoSlot: IORing.RegisteredFile,
context: UInt64 = 0
)
case pollAdd(
file: FileDescriptor,
pollEvents: IORing.Request.PollEvents,
isMultiShot: Bool = true,
context: UInt64 = 0
)
case connect(
socketFD: FileDescriptor,
sockaddr: UnsafePointer<sockaddr>,
addrLen: socklen_t,
context: UInt64 = 0
)
case accept(
file: FileDescriptor,
context: UInt64 = 0
)
case read(
file: FileDescriptor,
buffer: IORing.RegisteredBuffer,
@@ -72,7 +55,7 @@ internal enum IORequestCore {
)
case writeUnregistered(
file: FileDescriptor,
buffer: UnsafeRawBufferPointer,
buffer: UnsafeMutableRawBufferPointer,
offset: UInt64 = 0,
context: UInt64 = 0
)
@@ -204,88 +187,6 @@ extension IORing.Request {
.init(core: .nop)
}
/// Adds a poll operation to monitor a file descriptor for specific I/O events.
///
/// This method creates an io_uring poll operation that monitors the specified file descriptor
/// for I/O readiness events. The operation completes when any of the requested events become
/// active on the file descriptor, such as data becoming available for reading or the descriptor
/// becoming ready for writing.
///
/// Poll operations are useful for implementing efficient I/O multiplexing, allowing you to
/// monitor multiple file descriptors concurrently within a single io_uring instance. When used
/// with multishot mode, a single poll operation can deliver multiple completion events without
/// needing to be resubmitted.
///
/// ## Multishot Behavior
///
/// When `isMultiShot` is `true`, the poll operation automatically rearms after each completion
/// event, continuing to monitor the file descriptor for subsequent events. This reduces
/// submission overhead for long-lived monitoring operations. The operation continues until
/// explicitly cancelled or the file descriptor is closed.
///
/// When `isMultiShot` is `false`, the poll operation completes once after the first matching
/// event occurs, requiring resubmission to continue monitoring.
///
/// ## Example Usage
///
/// ```swift
/// // Monitor a socket for incoming connections
/// let pollRequest = IORing.Request.pollAdd(
/// listenSocket,
/// pollEvents: .pollin,
/// isMultiShot: true,
/// context: 1
/// )
/// try ring.submit(pollRequest)
///
/// // Process completions
/// for completion in try ring.completions() {
/// if completion.context == 1 {
/// // Handle incoming connection
/// }
/// }
/// ```
///
/// - Parameters:
/// - file: The file descriptor to monitor for I/O events.
/// - pollEvents: The I/O events to monitor on the file descriptor.
/// - isMultiShot: If `true`, the poll operation automatically rearms after each event,
/// continuing to monitor the file descriptor. If `false`, the operation completes after
/// the first matching event. Defaults to `true`.
/// - context: An application-specific value passed through to the completion event,
/// allowing you to identify which operation completed. Defaults to `0`.
///
/// - Returns: An I/O ring request that monitors the file descriptor for the specified events.
///
/// ## See Also
///
/// - ``PollEvents``: The events that can be monitored.
/// - ``IORing/Request/cancel(_:matching:)``: Cancelling poll operations.
@inlinable public static func pollAdd(
_ file: FileDescriptor,
pollEvents: PollEvents,
isMultiShot: Bool = true,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .pollAdd(file: file, pollEvents: pollEvents, context: context))
}
@inlinable public static func accept(
_ file: FileDescriptor,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .accept(file: file, context: context))
}
@inlinable public static func connect(
socketFD: FileDescriptor,
sockAddr: UnsafePointer<sockaddr>,
addrLen: socklen_t,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .connect(socketFD: socketFD, sockaddr: sockAddr, addrLen: addrLen, context: context))
}
@inlinable public static func read(
_ file: IORing.RegisteredFile,
into buffer: IORing.RegisteredBuffer,
@@ -351,7 +252,7 @@ extension IORing.Request {
}
@inlinable public static func write(
_ buffer: UnsafeRawBufferPointer,
_ buffer: UnsafeMutableRawBufferPointer,
into file: FileDescriptor,
at offset: UInt64 = 0,
context: UInt64 = 0
@@ -419,7 +320,7 @@ extension IORing.Request {
* ASYNC_CANCEL flags.
*
* IORING_ASYNC_CANCEL_ALL Cancel all requests that match the given key
* IORING_ASYNC_CANCEL_FD Key off 'fd' for cancellation rather than the
* IORING_ASYNC_CANCEL_FD Key off 'fd' for cancelation rather than the
* request 'user_data'
* IORING_ASYNC_CANCEL_ANY Match any request
* IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor
@@ -487,7 +388,9 @@ extension IORing.Request {
}
@inline(__always) @inlinable
internal consuming func makeRawRequest() -> RawIORequest {
internal consuming func makeRawRequest(
pathBuffers: PendingPathBuffers
) -> RawIORequest {
var request = RawIORequest()
switch extractCore() {
case .nop:
@@ -499,27 +402,19 @@ extension IORing.Request {
request.operation = .openAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
}))
UInt(bitPattern: pathBuffers.pin(path)))
request.rawValue.open_flags = UInt32(bitPattern: options.rawValue | mode.rawValue)
request.rawValue.len = permissions?.rawValue ?? 0
request.rawValue.file_index = UInt32(fileSlot.index + 1)
request.path = path
request.rawValue.user_data = context
case .openat(
let atDirectory, let path, let mode, let options, let permissions, let context):
request.operation = .openAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
}))
UInt(bitPattern: pathBuffers.pin(path)))
request.rawValue.open_flags = UInt32(bitPattern: options.rawValue | mode.rawValue)
request.rawValue.len = permissions?.rawValue ?? 0
request.path = path
request.rawValue.user_data = context
case .write(let file, let buffer, let offset, let context):
request.operation = .writeFixed
@@ -532,7 +427,7 @@ extension IORing.Request {
case .writeUnregistered(let file, let buffer, let offset, let context):
request.operation = .write
return makeRawRequest_readWrite_unregistered(
file: file, buffer: UnsafeMutableRawBufferPointer(mutating: buffer), offset: offset, context: context, request: request)
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .writeUnregisteredSlot(let file, let buffer, let offset, let context):
request.operation = .write
return makeRawRequest_readWrite_unregistered_slot(
@@ -565,12 +460,7 @@ extension IORing.Request {
request.operation = .unlinkAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
})
)
request.path = path
UInt(bitPattern: pathBuffers.pin(path)))
request.rawValue.user_data = context
case .cancelContext(let flags, let targetContext):
request.operation = .asyncCancel
@@ -587,28 +477,6 @@ extension IORing.Request {
case .cancel(let flags):
request.operation = .asyncCancel
request.cancel_flags = flags
case .pollAdd(let file, let pollEvents, let isMultiShot, let context):
request.operation = .pollAdd
request.fileDescriptor = file
request.rawValue.user_data = context
if isMultiShot {
request.rawValue.len = IORING_POLL_ADD_MULTI
}
request.rawValue.poll32_events = pollEvents.rawValue
case .connect(let socketFD, let sockaddrPtr, let addrLen, let context):
request.operation = .connect
request.fileDescriptor = socketFD
request.rawValue.user_data = context
request.rawValue.addr = UInt64(UInt(bitPattern: sockaddrPtr))
request.rawValue.addr2 = UInt64(MemoryLayout<sockaddr_in>.size)
case .accept(let file, let context):
request.operation = .accept
request.fileDescriptor = file
request.rawValue.user_data = context
// For accept, we can set addr and len to 0 to ignore client address
request.rawValue.addr = 0
request.rawValue.len = 0
request.rawValue.accept_flags = 0
}
return request
+54 -6
View File
@@ -41,6 +41,33 @@ extension UnsafeMutableRawBufferPointer {
}
}
/// Owns the FilePaths whose interior pointers have been written into pending
/// SQEs. The kernel copies SQE-referenced data out during io_uring_enter (due to
/// IORING_FEAT_SUBMIT_STABLE), so the paths only need to live across the prepare->submit gap
/// This is a class purely to avoid making methods calling `pin` mutating, which would be an API break
@usableFromInline
internal final class PendingPathBuffers {
@usableFromInline
var paths: [FilePath] = []
init(reservedCapacity: Int) {
paths.reserveCapacity(reservedCapacity)
}
@usableFromInline
func pin(_ path: FilePath) -> UnsafePointer<CInterop.PlatformChar> {
paths.append(path)
// Safe to escape: `paths` keeps the FilePath (and its underlying
// [SystemChar] buffer) alive until clear() or class deinit.
return paths.last!.withPlatformString { $0 }
}
@usableFromInline
func clear() {
paths.removeAll(keepingCapacity: true)
}
}
// all pointers in this struct reference kernel-visible memory
@usableFromInline struct SQRing: ~Copyable {
@usableFromInline let kernelHead: UnsafePointer<Atomic<UInt32>>
@@ -200,7 +227,14 @@ private func setUpRing(
throw err
}
if params.features & IORing.Features.nonDroppingCompletions.rawValue == 0
// We require IORING_FEAT_SUBMIT_STABLE so the kernel copies SQE-referenced
// pathnames (and other inline data) out of userspace before io_uring_enter
// returns; the path-buffer side store on IORing relies on this to free
// path buffers as soon as a submission completes.
let requiredFeatures =
IORing.Features.nonDroppingCompletions.rawValue
| IORing.Features.stableSubmissions.rawValue
if params.features & requiredFeatures != requiredFeatures
{
close(ringDescriptor)
throw Errno.invalidArgument
@@ -324,6 +358,8 @@ public struct IORing: ~Copyable {
@usableFromInline var _registeredFiles: [UInt32]
@usableFromInline var _registeredBuffers: [iovec]
@usableFromInline let _pendingPathBuffers: PendingPathBuffers
var features = Features(rawValue: 0)
/// RegisteredResource is used via its typealiases, RegisteredFile and RegisteredBuffer. Registering file descriptors and buffers with the IORing allows for more efficient access to them.
@@ -444,6 +480,7 @@ public struct IORing: ~Copyable {
self.completionRingSize = tmpCQSize
self._registeredFiles = []
self._registeredBuffers = []
self._pendingPathBuffers = PendingPathBuffers(reservedCapacity: Int(params.sq_entries))
self.submissionRing = submissionRing
self.completionRing = completionRing
self.submissionQueueEntries = submissionQueueEntries
@@ -765,6 +802,10 @@ public struct IORing: ~Copyable {
@inlinable
public func submitPreparedRequests() throws(Errno) {
try _submitRequests(ring: submissionRing, ringDescriptor: ringDescriptor)
// IORING_FEAT_SUBMIT_STABLE guarantees the kernel has copied any
// SQE-referenced data (e.g. openat/unlinkAt pathnames) before
// io_uring_enter returns; safe to release path storage now.
_pendingPathBuffers.clear()
}
/// Sends all prepared requests to the kernel for processing, and then dequeues at least `minimumCount` completions, waiting up to `timeout` for them to become available. `consumer` is called to process each completed IO operation as it becomes available.
@@ -790,9 +831,14 @@ public struct IORing: ~Copyable {
/// Attempts to prepare an IO request for submission to the kernel. Returns false if no space is available to enqueue the request
@inlinable
public mutating func prepare(request: __owned Request) -> Bool {
var raw: RawIORequest? = request.makeRawRequest()
return _tryWriteRequest(
guard _getRemainingSubmissionQueueCapacity(ring: submissionRing) >= 1 else {
return false
}
var raw: RawIORequest? = request.makeRawRequest(pathBuffers: _pendingPathBuffers)
let ok = _tryWriteRequest(
raw.take()!, ring: &submissionRing, submissionQueueEntries: submissionQueueEntries)
assert(ok)
return ok
}
/// Attempts to prepare a chain of linked IO requests for submission to the kernel. Returns false if not enough space is available to enqueue the request. If any linked operation fails, subsequent operations will be canceled. Linked operations always execute in order.
@@ -806,18 +852,20 @@ public struct IORing: ~Copyable {
return false
}
let last = linkedRequests.last!
var allAdded = true
for req in linkedRequests.dropLast() {
var raw = req.makeRawRequest()
var raw = req.makeRawRequest(pathBuffers: _pendingPathBuffers)
raw.linkToNextRequest()
let successfullyAdded = _tryWriteRequest(
raw, ring: &submissionRing, submissionQueueEntries: submissionQueueEntries)
assert(successfullyAdded)
allAdded = allAdded && successfullyAdded
}
let successfullyAdded = _tryWriteRequest(
last.makeRawRequest(), ring: &submissionRing,
last.makeRawRequest(pathBuffers: _pendingPathBuffers), ring: &submissionRing,
submissionQueueEntries: submissionQueueEntries)
assert(successfullyAdded)
return true
return allAdded && successfullyAdded
}
/// Prepares a sequence of requests for submission to the ring. Returns false if the submission queue doesn't have enough available space.
-59
View File
@@ -1,59 +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 compiler(>=6.2) && $Lifetimes
#if os(Linux)
extension IORing.Request {
/// A set of I/O events that can be monitored on a file descriptor.
///
/// `PollEvents` represents the event mask used with io_uring poll operations to specify
/// which I/O conditions to monitor on a file descriptor. These events correspond to the
/// standard Posix poll events defined in the kernel's `poll.h` header.
///
/// Use `PollEvents` with ``IORing/Request/pollAdd(_:pollEvents:isMultiShot:context:)``
/// to register interest in specific I/O events. The poll operation completes when any of
/// the specified events become active on the file descriptor.
///
/// ## Usage
///
/// ```swift
/// // Monitor a socket for incoming data
/// let request = IORing.Request.pollAdd(
/// socketFD,
/// pollEvents: .pollin,
/// isMultiShot: true
/// )
/// ```
public struct PollEvents: OptionSet, Hashable, Codable {
public var rawValue: UInt32
@inlinable
public init(rawValue: UInt32) {
self.rawValue = rawValue
}
/// An event indicating data is available for reading.
///
/// This event becomes active when data arrives on the file descriptor and can be read
/// without blocking. For sockets, this includes when a new connection is available on
/// a listening socket. Corresponds to the Posix `POLLIN` event flag.
@inlinable
public static var pollin: PollEvents { PollEvents(rawValue: 0x0001) }
/// An event indicating the file descriptor is ready for writing.
///
/// This event becomes active when writing to the file descriptor will not block. For
/// sockets, this indicates that send buffer space is available. Corresponds to the
/// Posix `POLLOUT` event flag.
@inlinable
public static var pollout: PollEvents { PollEvents(rawValue: 0x0004) }
}
}
#endif
#endif
-3
View File
@@ -8,7 +8,6 @@ internal struct RawIORequest: ~Copyable {
// swift_io_uring_sqe is a typedef of io_uring_sqe on platforms where
// IORing is supported (currently requires kernel version >= 5.15).
@usableFromInline var rawValue: swift_io_uring_sqe
@usableFromInline var path: FilePath? //buffer owner for the path pointer that the sqe may have
@inlinable public init() {
self.rawValue = swift_io_uring_sqe()
@@ -30,10 +29,8 @@ extension RawIORequest {
case sendMessage = 9
case receiveMessage = 10
// ...
case accept = 13
case asyncCancel = 14
case link_timeout = 15
case connect = 16
// ...
case openAt = 18
case close = 19
+2 -16
View File
@@ -5,7 +5,7 @@
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
*/
#if SYSTEM_PACKAGE_DARWIN
import Darwin
@@ -21,7 +21,7 @@ import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Bionic)
import CSystem
@_implementationOnly import CSystem
import Bionic
#else
#error("Unsupported Platform")
@@ -79,17 +79,3 @@ public enum CInterop {
public typealias PlatformUnicodeEncoding = UTF8
#endif
}
#if !os(Windows)
@available(System 99, *)
extension CInterop {
public typealias Stat = stat
public typealias DeviceID = dev_t
public typealias Inode = ino_t
public typealias UserID = uid_t
public typealias GroupID = gid_t
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
public typealias FileFlags = UInt32
#endif
}
#endif
+2 -145
View File
@@ -5,7 +5,7 @@
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
*/
// For platform constants redefined in Swift. We define them here so that
// they can be used anywhere without imports and without confusion to
@@ -17,7 +17,6 @@ import Darwin
import CSystem
import ucrt
#elseif canImport(Glibc)
import CSystem
import Glibc
#elseif canImport(Musl)
import CSystem
@@ -439,7 +438,7 @@ internal var _ENOSR: CInt { ENOSR }
@_alwaysEmitIntoClient
internal var _ENOSTR: CInt { ENOSTR }
#endif
#endif
#endif
@_alwaysEmitIntoClient
@@ -640,145 +639,3 @@ internal var _SEEK_HOLE: CInt { SEEK_HOLE }
@_alwaysEmitIntoClient
internal var _SEEK_DATA: CInt { SEEK_DATA }
#endif
// MARK: - File System
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _AT_FDCWD: CInt { AT_FDCWD }
// MARK: - fstatat Flags
@_alwaysEmitIntoClient
internal var _AT_SYMLINK_NOFOLLOW: CInt { AT_SYMLINK_NOFOLLOW }
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _AT_SYMLINK_NOFOLLOW_ANY: CInt { AT_SYMLINK_NOFOLLOW_ANY }
#endif
#if canImport(Darwin, _version: 346) || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _AT_RESOLVE_BENEATH: CInt { AT_RESOLVE_BENEATH }
#endif
// MARK: - File Mode / File Type
@_alwaysEmitIntoClient
internal var _MODE_FILETYPE_MASK: mode_t { S_IFMT }
@_alwaysEmitIntoClient
internal var _MODE_PERMISSIONS_MASK: mode_t { 0o7777 }
@_alwaysEmitIntoClient
internal var _S_IFDIR: mode_t { S_IFDIR }
@_alwaysEmitIntoClient
internal var _S_IFCHR: mode_t { S_IFCHR }
@_alwaysEmitIntoClient
internal var _S_IFBLK: mode_t { S_IFBLK }
@_alwaysEmitIntoClient
internal var _S_IFREG: mode_t { S_IFREG }
@_alwaysEmitIntoClient
internal var _S_IFIFO: mode_t { S_IFIFO }
@_alwaysEmitIntoClient
internal var _S_IFLNK: mode_t { S_IFLNK }
@_alwaysEmitIntoClient
internal var _S_IFSOCK: mode_t { S_IFSOCK }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _S_IFWHT: mode_t { S_IFWHT }
#endif
// MARK: - stat/chflags File Flags
// MARK: Flags Available on Darwin, FreeBSD, and OpenBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
@_alwaysEmitIntoClient
internal var _UF_NODUMP: UInt32 { UInt32(bitPattern: UF_NODUMP) }
@_alwaysEmitIntoClient
internal var _UF_IMMUTABLE: UInt32 { UInt32(bitPattern: UF_IMMUTABLE) }
@_alwaysEmitIntoClient
internal var _UF_APPEND: UInt32 { UInt32(bitPattern: UF_APPEND) }
@_alwaysEmitIntoClient
internal var _SF_ARCHIVED: UInt32 { UInt32(bitPattern: SF_ARCHIVED) }
@_alwaysEmitIntoClient
internal var _SF_IMMUTABLE: UInt32 { UInt32(bitPattern: SF_IMMUTABLE) }
@_alwaysEmitIntoClient
internal var _SF_APPEND: UInt32 { UInt32(bitPattern: SF_APPEND) }
#endif
// MARK: Flags Available on Darwin and FreeBSD
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _UF_OPAQUE: UInt32 { UInt32(bitPattern: UF_OPAQUE) }
@_alwaysEmitIntoClient
internal var _UF_HIDDEN: UInt32 { UInt32(bitPattern: UF_HIDDEN) }
@_alwaysEmitIntoClient
internal var _SF_NOUNLINK: UInt32 { UInt32(bitPattern: SF_NOUNLINK) }
#endif
// MARK: Flags Available on Darwin Only
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _UF_COMPRESSED: UInt32 { UInt32(bitPattern: UF_COMPRESSED) }
@_alwaysEmitIntoClient
internal var _UF_TRACKED: UInt32 { UInt32(bitPattern: UF_TRACKED) }
@_alwaysEmitIntoClient
internal var _UF_DATAVAULT: UInt32 { UInt32(bitPattern: UF_DATAVAULT) }
@_alwaysEmitIntoClient
internal var _SF_RESTRICTED: UInt32 { UInt32(bitPattern: SF_RESTRICTED) }
@_alwaysEmitIntoClient
internal var _SF_FIRMLINK: UInt32 { UInt32(bitPattern: SF_FIRMLINK) }
@_alwaysEmitIntoClient
internal var _SF_DATALESS: UInt32 { UInt32(bitPattern: SF_DATALESS) }
#endif
// MARK: Flags Available on FreeBSD Only
#if os(FreeBSD)
@_alwaysEmitIntoClient
internal var _UF_NOUNLINK: UInt32 { UInt32(bitPattern: UF_NOUNLINK) }
@_alwaysEmitIntoClient
internal var _UF_OFFLINE: UInt32 { UInt32(bitPattern: UF_OFFLINE) }
@_alwaysEmitIntoClient
internal var _UF_READONLY: UInt32 { UInt32(bitPattern: UF_READONLY) }
@_alwaysEmitIntoClient
internal var _UF_REPARSE: UInt32 { UInt32(bitPattern: UF_REPARSE) }
@_alwaysEmitIntoClient
internal var _UF_SPARSE: UInt32 { UInt32(bitPattern: UF_SPARSE) }
@_alwaysEmitIntoClient
internal var _UF_SYSTEM: UInt32 { UInt32(bitPattern: UF_SYSTEM) }
@_alwaysEmitIntoClient
internal var _SF_SNAPSHOT: UInt32 { UInt32(bitPattern: SF_SNAPSHOT) }
#endif
#endif // !os(Windows)
+7 -26
View File
@@ -5,7 +5,7 @@
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
*/
// Internal wrappers and typedefs which help reduce #if littering in System's
// code base.
@@ -90,25 +90,6 @@ internal func system_strlen(_ s: UnsafeMutablePointer<CChar>) -> Int {
strlen(s)
}
#if !os(Windows)
@available(System 99, *)
internal func system_stat(_ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
stat(p, &s)
}
@available(System 99, *)
internal func system_lstat(_ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat) -> Int32 {
lstat(p, &s)
}
@available(System 99, *)
internal func system_fstat(_ fd: CInt, _ s: inout CInterop.Stat) -> Int32 {
fstat(fd, &s)
}
@available(System 99, *)
internal func system_fstatat(_ fd: CInt, _ p: UnsafePointer<CChar>, _ s: inout CInterop.Stat, _ flags: CInt) -> Int32 {
fstatat(fd, p, &s, flags)
}
#endif
// Convention: `system_platform_foo` is a
// platform-representation-abstracted wrapper around `foo`-like functionality.
// Type and layout differences such as the `char` vs `wchar` are abstracted.
@@ -159,7 +140,7 @@ extension String {
return
#else
self.init(validatingCString: platformString)
self.init(validatingUTF8: platformString)
#endif
}
@@ -186,20 +167,20 @@ internal typealias _PlatformTLSKey = DWORD
#elseif os(WASI) && (swift(<6.1) || !_runtime(_multithreaded))
// Mock TLS storage for single-threaded WASI
internal final class _PlatformTLSKey {
fileprivate init() {}
fileprivate init() {}
}
private final class TLSStorage: @unchecked Sendable {
var storage = [ObjectIdentifier: UnsafeMutableRawPointer]()
var storage = [ObjectIdentifier: UnsafeMutableRawPointer]()
}
private let sharedTLSStorage = TLSStorage()
func pthread_setspecific(_ key: _PlatformTLSKey, _ p: UnsafeMutableRawPointer?) -> Int {
sharedTLSStorage.storage[ObjectIdentifier(key)] = p
return 0
sharedTLSStorage.storage[ObjectIdentifier(key)] = p
return 0
}
func pthread_getspecific(_ key: _PlatformTLSKey) -> UnsafeMutableRawPointer? {
sharedTLSStorage.storage[ObjectIdentifier(key)]
sharedTLSStorage.storage[ObjectIdentifier(key)]
}
#else
internal typealias _PlatformTLSKey = pthread_key_t
@@ -38,9 +38,9 @@ internal func open(
guard let hFile = try? path.withCanonicalPathRepresentation({ path in
CreateFileW(path,
decodedFlags.dwDesiredAccess,
DWORD(FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE),
FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE,
&saAttrs,
decodedFlags.dwCreationDisposition,
decodedFlags.dwFlagsAndAttributes,
@@ -80,9 +80,9 @@ internal func open(
guard let hFile = try? path.withCanonicalPathRepresentation({ path in
CreateFileW(path,
decodedFlags.dwDesiredAccess,
DWORD(FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE),
FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE,
&saAttrs,
decodedFlags.dwCreationDisposition,
decodedFlags.dwFlagsAndAttributes,
@@ -149,6 +149,12 @@ internal func pread(
let handle: intptr_t = _get_osfhandle(fd)
if handle == /* INVALID_HANDLE_VALUE */ -1 { ucrt._set_errno(EBADF); return -1 }
// Windows ReadFile accepts DWORD (32-bit) for buffer size, so validate nbyte doesn't exceed it
if nbyte > Int(DWORD.max) {
ucrt._set_errno(EINVAL)
return -1
}
// NOTE: this is a non-owning handle, do *not* call CloseHandle on it
let hFile: HANDLE = HANDLE(bitPattern: handle)!
@@ -171,6 +177,12 @@ internal func pwrite(
let handle: intptr_t = _get_osfhandle(fd)
if handle == /* INVALID_HANDLE_VALUE */ -1 { ucrt._set_errno(EBADF); return -1 }
// Windows WriteFile accepts DWORD (32-bit) for buffer size, so validate nbyte doesn't exceed it
if nbyte > Int(DWORD.max) {
ucrt._set_errno(EINVAL)
return -1
}
// NOTE: this is a non-owning handle, do *not* call CloseHandle on it
let hFile: HANDLE = HANDLE(bitPattern: handle)!
@@ -206,16 +218,16 @@ internal func ftruncate(_ fd: Int32, _ length: off_t) -> Int32 {
// Save the current position and restore it when we're done
if !SetFilePointerEx(hFile, liCurrentOffset, &liCurrentOffset,
DWORD(FILE_CURRENT)) {
FILE_CURRENT) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
defer {
_ = SetFilePointerEx(hFile, liCurrentOffset, nil, DWORD(FILE_BEGIN));
_ = SetFilePointerEx(hFile, liCurrentOffset, nil, FILE_BEGIN);
}
// Truncate (or extend) the file
if !SetFilePointerEx(hFile, liDesiredLength, nil, DWORD(FILE_BEGIN))
if !SetFilePointerEx(hFile, liDesiredLength, nil, FILE_BEGIN)
|| !SetEndOfFile(hFile) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
@@ -267,7 +279,7 @@ internal func rmdir(
}
internal func _mapWindowsErrorToErrno(_ errorCode: DWORD) -> CInt {
switch Int32(errorCode) {
switch errorCode {
case ERROR_SUCCESS:
return 0
case ERROR_INVALID_FUNCTION,
@@ -346,28 +358,28 @@ fileprivate func rightsFromModeBits(
var rights: DWORD = 0
if (bits & 0o4) != 0 {
rights |= DWORD(FILE_READ_ATTRIBUTES
| FILE_READ_DATA
| FILE_READ_EA
| STANDARD_RIGHTS_READ
| SYNCHRONIZE)
rights |= (FILE_READ_ATTRIBUTES
| FILE_READ_DATA
| FILE_READ_EA
| STANDARD_RIGHTS_READ
| SYNCHRONIZE)
}
if (bits & 0o2) != 0 {
rights |= DWORD(FILE_APPEND_DATA
| FILE_WRITE_ATTRIBUTES
| FILE_WRITE_DATA
| FILE_WRITE_EA
| STANDARD_RIGHTS_WRITE
| SYNCHRONIZE)
rights |= (FILE_APPEND_DATA
| FILE_WRITE_ATTRIBUTES
| FILE_WRITE_DATA
| FILE_WRITE_EA
| STANDARD_RIGHTS_WRITE
| SYNCHRONIZE)
if fileOrDirectory == .directory && !sticky {
rights |= DWORD(FILE_DELETE_CHILD)
rights |= FILE_DELETE_CHILD
}
}
if (bits & 0o1) != 0 {
rights |= DWORD(FILE_EXECUTE
| FILE_READ_ATTRIBUTES
| STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE)
rights |= (FILE_EXECUTE
| FILE_READ_ATTRIBUTES
| STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE)
}
return rights
@@ -435,7 +447,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
var everyone: PSID? = nil
guard AllocateAndInitializeSid(&SIDAuthWorld, 1,
DWORD(SECURITY_WORLD_RID),
SECURITY_WORLD_RID,
0, 0, 0, 0, 0, 0, 0,
&everyone) else {
return nil
@@ -476,7 +488,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: ownerRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -489,7 +501,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: groupRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -502,7 +514,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: otherRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -519,7 +531,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: ownerDenyRights,
grfAccessMode: DENY_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -537,7 +549,7 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
EXPLICIT_ACCESS_W(
grfAccessPermissions: groupDenyRights,
grfAccessMode: DENY_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
grfInheritance: NO_INHERITANCE,
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
@@ -566,13 +578,13 @@ internal func _createSecurityDescriptor(from mode: CInterop.Mode,
var descriptor = SECURITY_DESCRIPTOR()
guard InitializeSecurityDescriptor(&descriptor,
DWORD(SECURITY_DESCRIPTOR_REVISION)) else {
SECURITY_DESCRIPTOR_REVISION) else {
return nil
}
guard SetSecurityDescriptorControl(&descriptor,
SECURITY_DESCRIPTOR_CONTROL(SE_DACL_PROTECTED),
SECURITY_DESCRIPTOR_CONTROL(SE_DACL_PROTECTED))
SE_DACL_PROTECTED,
SE_DACL_PROTECTED)
&& SetSecurityDescriptorOwner(&descriptor, user, false)
&& SetSecurityDescriptorGroup(&descriptor, group, false)
&& SetSecurityDescriptorDacl(&descriptor,
@@ -612,15 +624,15 @@ fileprivate struct DecodedOpenFlags {
init(_ oflag: Int32) {
switch oflag & (_O_CREAT | _O_EXCL | _O_TRUNC) {
case _O_CREAT | _O_EXCL, _O_CREAT | _O_EXCL | _O_TRUNC:
dwCreationDisposition = DWORD(CREATE_NEW)
dwCreationDisposition = CREATE_NEW
case _O_CREAT:
dwCreationDisposition = DWORD(OPEN_ALWAYS)
dwCreationDisposition = OPEN_ALWAYS
case _O_CREAT | _O_TRUNC:
dwCreationDisposition = DWORD(CREATE_ALWAYS)
dwCreationDisposition = CREATE_ALWAYS
case _O_TRUNC:
dwCreationDisposition = DWORD(TRUNCATE_EXISTING)
dwCreationDisposition = TRUNCATE_EXISTING
default:
dwCreationDisposition = DWORD(OPEN_EXISTING)
dwCreationDisposition = OPEN_EXISTING
}
// The _O_RDONLY, _O_WRONLY and _O_RDWR flags are non-overlapping
@@ -629,11 +641,11 @@ fileprivate struct DecodedOpenFlags {
dwDesiredAccess = 0
switch (oflag & (_O_RDONLY|_O_WRONLY|_O_RDWR)) {
case _O_RDONLY:
dwDesiredAccess |= DWORD(GENERIC_READ)
dwDesiredAccess |= GENERIC_READ
case _O_WRONLY:
dwDesiredAccess |= DWORD(GENERIC_WRITE)
dwDesiredAccess |= GENERIC_WRITE
case _O_RDWR:
dwDesiredAccess |= DWORD(GENERIC_READ) | DWORD(GENERIC_WRITE)
dwDesiredAccess |= GENERIC_READ | GENERIC_WRITE
default:
break
}
@@ -642,19 +654,19 @@ fileprivate struct DecodedOpenFlags {
dwFlagsAndAttributes = 0
if (oflag & _O_SEQUENTIAL) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_SEQUENTIAL_SCAN)
dwFlagsAndAttributes |= FILE_FLAG_SEQUENTIAL_SCAN
}
if (oflag & _O_RANDOM) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_RANDOM_ACCESS)
dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS
}
if (oflag & _O_TEMPORARY) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_DELETE_ON_CLOSE)
dwFlagsAndAttributes |= FILE_FLAG_DELETE_ON_CLOSE
}
if (oflag & _O_SHORT_LIVED) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_ATTRIBUTE_TEMPORARY)
dwFlagsAndAttributes |= FILE_ATTRIBUTE_TEMPORARY
} else {
dwFlagsAndAttributes |= DWORD(FILE_ATTRIBUTE_NORMAL)
dwFlagsAndAttributes |= FILE_ATTRIBUTE_NORMAL
}
}
}
+2 -2
View File
@@ -52,13 +52,13 @@ extension Slice where Element: Equatable {
return self[...idx]
}
// If `e` is present, eat up to first occurrence of `e`
// If `e` is present, eat up to first occurence of `e`
internal mutating func _eatUntil(_ e: Element) -> Slice? {
guard let idx = self.firstIndex(of: e) else { return nil }
return _eatUntil(idx)
}
// If `e` is present, eat up to and through first occurrence of `e`
// If `e` is present, eat up to and through first occurence of `e`
internal mutating func _eatThrough(_ e: Element) -> Slice? {
guard let idx = self.firstIndex(of: e) else { return nil }
return _eatThrough(idx)
+439
View File
@@ -0,0 +1,439 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
#if os(Windows)
import WinSDK
@_transparent
internal var CREATE_ALWAYS: DWORD {
DWORD(WinSDK.CREATE_ALWAYS)
}
@_transparent
internal var CREATE_NEW: DWORD {
DWORD(WinSDK.CREATE_NEW)
}
@_transparent
internal var ERROR_ACCESS_DENIED: DWORD {
DWORD(WinSDK.ERROR_ACCESS_DENIED)
}
@_transparent
internal var ERROR_ALREADY_EXISTS: DWORD {
DWORD(WinSDK.ERROR_ALREADY_EXISTS)
}
@_transparent
internal var ERROR_ARENA_TRASHED: DWORD {
DWORD(WinSDK.ERROR_ARENA_TRASHED)
}
@_transparent
internal var ERROR_BAD_ENVIRONMENT: DWORD {
DWORD(WinSDK.ERROR_BAD_ENVIRONMENT)
}
@_transparent
internal var ERROR_BAD_FORMAT: DWORD {
DWORD(WinSDK.ERROR_BAD_FORMAT)
}
@_transparent
internal var ERROR_BAD_NET_NAME: DWORD {
DWORD(WinSDK.ERROR_BAD_NET_NAME)
}
@_transparent
internal var ERROR_BAD_NETPATH: DWORD {
DWORD(WinSDK.ERROR_BAD_NETPATH)
}
@_transparent
internal var ERROR_BAD_PATHNAME: DWORD {
DWORD(WinSDK.ERROR_BAD_PATHNAME)
}
@_transparent
internal var ERROR_BROKEN_PIPE: DWORD {
DWORD(WinSDK.ERROR_BROKEN_PIPE)
}
@_transparent
internal var ERROR_CANNOT_MAKE: DWORD {
DWORD(WinSDK.ERROR_CANNOT_MAKE)
}
@_transparent
internal var ERROR_CHILD_NOT_COMPLETE: DWORD {
DWORD(WinSDK.ERROR_CHILD_NOT_COMPLETE)
}
@_transparent
internal var ERROR_CURRENT_DIRECTORY: DWORD {
DWORD(WinSDK.ERROR_CURRENT_DIRECTORY)
}
@_transparent
internal var ERROR_DIR_NOT_EMPTY: DWORD {
DWORD(WinSDK.ERROR_DIR_NOT_EMPTY)
}
@_transparent
internal var ERROR_DISK_FULL: DWORD {
DWORD(WinSDK.ERROR_DISK_FULL)
}
@_transparent
internal var ERROR_DRIVE_LOCKED: DWORD {
DWORD(WinSDK.ERROR_DRIVE_LOCKED)
}
@_transparent
internal var ERROR_DIRECT_ACCESS_HANDLE: DWORD {
DWORD(WinSDK.ERROR_DIRECT_ACCESS_HANDLE)
}
@_transparent
internal var ERROR_FILE_EXISTS: DWORD {
DWORD(WinSDK.ERROR_FILE_EXISTS)
}
@_transparent
internal var ERROR_FILE_NOT_FOUND: DWORD {
DWORD(WinSDK.ERROR_FILE_NOT_FOUND)
}
@_transparent
internal var ERROR_FAIL_I24: DWORD {
DWORD(WinSDK.ERROR_FAIL_I24)
}
@_transparent
internal var ERROR_FILENAME_EXCED_RANGE: DWORD {
DWORD(WinSDK.ERROR_FILENAME_EXCED_RANGE)
}
@_transparent
internal var ERROR_NEGATIVE_SEEK: DWORD {
DWORD(WinSDK.ERROR_NEGATIVE_SEEK)
}
@_transparent
internal var ERROR_NO_MORE_FILES: DWORD {
DWORD(WinSDK.ERROR_NO_MORE_FILES)
}
@_transparent
internal var ERROR_NO_UNICODE_TRANSLATION: DWORD {
DWORD(WinSDK.ERROR_NO_UNICODE_TRANSLATION)
}
@_transparent
internal var ERROR_NOT_ENOUGH_MEMORY: DWORD {
DWORD(WinSDK.ERROR_NOT_ENOUGH_MEMORY)
}
@_transparent
internal var ERROR_INVALID_ACCESS: DWORD {
DWORD(WinSDK.ERROR_INVALID_ACCESS)
}
@_transparent
internal var ERROR_INVALID_BLOCK: DWORD {
DWORD(WinSDK.ERROR_INVALID_BLOCK)
}
@_transparent
internal var ERROR_INVALID_DATA: DWORD {
DWORD(WinSDK.ERROR_INVALID_DATA)
}
@_transparent
internal var ERROR_INVALID_DRIVE: DWORD {
DWORD(WinSDK.ERROR_INVALID_DRIVE)
}
@_transparent
internal var ERROR_INVALID_FUNCTION: DWORD {
DWORD(WinSDK.ERROR_INVALID_FUNCTION)
}
@_transparent
internal var ERROR_INVALID_HANDLE: DWORD {
DWORD(WinSDK.ERROR_INVALID_HANDLE)
}
@_transparent
internal var ERROR_INFLOOP_IN_RELOC_CHAIN: DWORD {
DWORD(WinSDK.ERROR_INFLOOP_IN_RELOC_CHAIN)
}
@_transparent
internal var ERROR_INVALID_PARAMETER: DWORD {
DWORD(WinSDK.ERROR_INVALID_PARAMETER)
}
@_transparent
internal var ERROR_INVALID_STARTING_CODESEG: DWORD {
DWORD(WinSDK.ERROR_INVALID_STARTING_CODESEG)
}
@_transparent
internal var ERROR_INVALID_TARGET_HANDLE: DWORD {
DWORD(WinSDK.ERROR_INVALID_TARGET_HANDLE)
}
@_transparent
internal var ERROR_LOCK_FAILED: DWORD {
DWORD(WinSDK.ERROR_LOCK_FAILED)
}
@_transparent
internal var ERROR_LOCK_VIOLATION: DWORD {
DWORD(WinSDK.ERROR_LOCK_VIOLATION)
}
@_transparent
internal var ERROR_MAX_THRDS_REACHED: DWORD {
DWORD(WinSDK.ERROR_MAX_THRDS_REACHED)
}
@_transparent
internal var ERROR_NESTING_NOT_ALLOWED: DWORD {
DWORD(WinSDK.ERROR_NESTING_NOT_ALLOWED)
}
@_transparent
internal var ERROR_NETWORK_ACCESS_DENIED: DWORD {
DWORD(WinSDK.ERROR_NETWORK_ACCESS_DENIED)
}
@_transparent
internal var ERROR_NO_PROC_SLOTS: DWORD {
DWORD(WinSDK.ERROR_NO_PROC_SLOTS)
}
@_transparent
internal var ERROR_NOT_ENOUGH_QUOTA: DWORD {
DWORD(WinSDK.ERROR_NOT_ENOUGH_QUOTA)
}
@_transparent
internal var ERROR_NOT_LOCKED: DWORD {
DWORD(WinSDK.ERROR_NOT_LOCKED)
}
@_transparent
internal var ERROR_NOT_SAME_DEVICE: DWORD {
DWORD(WinSDK.ERROR_NOT_SAME_DEVICE)
}
@_transparent
internal var ERROR_PATH_NOT_FOUND: DWORD {
DWORD(WinSDK.ERROR_PATH_NOT_FOUND)
}
@_transparent
internal var ERROR_SEEK_ON_DEVICE: DWORD {
DWORD(WinSDK.ERROR_SEEK_ON_DEVICE)
}
@_transparent
internal var ERROR_SHARING_BUFFER_EXCEEDED: DWORD {
DWORD(WinSDK.ERROR_SHARING_BUFFER_EXCEEDED)
}
@_transparent
internal var ERROR_SUCCESS: DWORD {
DWORD(WinSDK.ERROR_SUCCESS)
}
@_transparent
internal var ERROR_WAIT_NO_CHILDREN: DWORD {
DWORD(WinSDK.ERROR_WAIT_NO_CHILDREN)
}
@_transparent
internal var ERROR_WRITE_PROTECT: DWORD {
DWORD(WinSDK.ERROR_WRITE_PROTECT)
}
@_transparent
internal var ERROR_TOO_MANY_OPEN_FILES: DWORD {
DWORD(WinSDK.ERROR_TOO_MANY_OPEN_FILES)
}
@_transparent
internal var FILE_APPEND_DATA: DWORD {
DWORD(WinSDK.FILE_APPEND_DATA)
}
@_transparent
internal var FILE_ATTRIBUTE_DIRECTORY: DWORD {
DWORD(WinSDK.FILE_ATTRIBUTE_DIRECTORY)
}
@_transparent
internal var FILE_ATTRIBUTE_NORMAL: DWORD {
DWORD(WinSDK.FILE_ATTRIBUTE_NORMAL)
}
@_transparent
internal var FILE_ATTRIBUTE_TEMPORARY: DWORD {
DWORD(WinSDK.FILE_ATTRIBUTE_TEMPORARY)
}
@_transparent
internal var FILE_BEGIN: DWORD {
DWORD(WinSDK.FILE_BEGIN)
}
@_transparent
internal var FILE_CURRENT: DWORD {
DWORD(WinSDK.FILE_CURRENT)
}
@_transparent
internal var FILE_DELETE_CHILD: DWORD {
DWORD(WinSDK.FILE_DELETE_CHILD)
}
@_transparent
package var FILE_EXECUTE: DWORD {
DWORD(WinSDK.FILE_EXECUTE)
}
@_transparent
internal var FILE_FLAG_DELETE_ON_CLOSE: DWORD {
DWORD(WinSDK.FILE_FLAG_DELETE_ON_CLOSE)
}
@_transparent
internal var FILE_FLAG_RANDOM_ACCESS: DWORD {
DWORD(WinSDK.FILE_FLAG_RANDOM_ACCESS)
}
@_transparent
internal var FILE_FLAG_SEQUENTIAL_SCAN: DWORD {
DWORD(WinSDK.FILE_FLAG_SEQUENTIAL_SCAN)
}
@_transparent
package var FILE_READ_ATTRIBUTES: DWORD {
DWORD(WinSDK.FILE_READ_ATTRIBUTES)
}
@_transparent
internal var FILE_READ_DATA: DWORD {
DWORD(WinSDK.FILE_READ_DATA)
}
@_transparent
internal var FILE_READ_EA: DWORD {
DWORD(WinSDK.FILE_READ_EA)
}
@_transparent
internal var FILE_SHARE_DELETE: DWORD {
DWORD(WinSDK.FILE_SHARE_DELETE)
}
@_transparent
internal var FILE_SHARE_READ: DWORD {
DWORD(WinSDK.FILE_SHARE_READ)
}
@_transparent
internal var FILE_SHARE_WRITE: DWORD {
DWORD(WinSDK.FILE_SHARE_WRITE)
}
@_transparent
package var FILE_WRITE_ATTRIBUTES: DWORD {
DWORD(WinSDK.FILE_WRITE_ATTRIBUTES)
}
@_transparent
internal var FILE_WRITE_DATA: DWORD {
DWORD(WinSDK.FILE_WRITE_DATA)
}
@_transparent
internal var FILE_WRITE_EA: DWORD {
DWORD(WinSDK.FILE_WRITE_EA)
}
@_transparent
internal var GENERIC_READ: DWORD {
DWORD(WinSDK.GENERIC_READ)
}
@_transparent
internal var GENERIC_WRITE: DWORD {
DWORD(WinSDK.GENERIC_WRITE)
}
@_transparent
internal var NO_INHERITANCE: DWORD {
DWORD(WinSDK.NO_INHERITANCE)
}
@_transparent
internal var OPEN_ALWAYS: DWORD {
DWORD(WinSDK.OPEN_ALWAYS)
}
@_transparent
internal var OPEN_EXISTING: DWORD {
DWORD(WinSDK.OPEN_EXISTING)
}
@_transparent
internal var SE_DACL_PROTECTED: SECURITY_DESCRIPTOR_CONTROL {
SECURITY_DESCRIPTOR_CONTROL(WinSDK.SE_DACL_PROTECTED)
}
@_transparent
internal var SECURITY_DESCRIPTOR_REVISION: DWORD {
DWORD(WinSDK.SECURITY_DESCRIPTOR_REVISION)
}
@_transparent
internal var SECURITY_WORLD_RID: DWORD {
DWORD(WinSDK.SECURITY_WORLD_RID)
}
@_transparent
internal var STANDARD_RIGHTS_READ: DWORD {
DWORD(WinSDK.STANDARD_RIGHTS_READ)
}
@_transparent
internal var STANDARD_RIGHTS_EXECUTE: DWORD {
DWORD(WinSDK.STANDARD_RIGHTS_EXECUTE)
}
@_transparent
internal var STANDARD_RIGHTS_WRITE: DWORD {
DWORD(WinSDK.STANDARD_RIGHTS_WRITE)
}
@_transparent
internal var SYNCHRONIZE: DWORD {
DWORD(WinSDK.SYNCHRONIZE)
}
@_transparent
internal var TRUNCATE_EXISTING: DWORD {
DWORD(WinSDK.TRUNCATE_EXISTING)
}
#endif
-136
View File
@@ -1,136 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
import Testing
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@Suite("FileMode")
private struct FileModeTests {
@available(System 99, *)
@Test func basics() async throws {
var mode = FileMode(rawValue: S_IFREG | 0o644) // Regular file, rw-r--r--
#expect(mode.type == .regular)
#expect(mode.permissions == [.ownerReadWrite, .groupRead, .otherRead])
mode.type = .directory // Directory, rw-r--r--
#expect(mode.type == .directory)
#expect(mode.permissions == [.ownerReadWrite, .groupRead, .otherRead])
mode.permissions.insert([.ownerExecute, .groupExecute, .otherExecute]) // Directory, rwxr-xr-x
#expect(mode.type == .directory)
#expect(mode.permissions == [.ownerReadWriteExecute, .groupReadExecute, .otherReadExecute])
mode.type = .symbolicLink // Symbolic link, rwxr-xr-x
#expect(mode.type == .symbolicLink)
#expect(mode.permissions == [.ownerReadWriteExecute, .groupReadExecute, .otherReadExecute])
let mode1 = FileMode(rawValue: S_IFLNK | 0o755) // Symbolic link, rwxr-xr-x
let mode2 = FileMode(type: .symbolicLink, permissions: [.ownerReadWriteExecute, .groupReadExecute, .otherReadExecute])
#expect(mode == mode1)
#expect(mode1 == mode2)
mode.permissions.remove([.otherReadExecute]) // Symbolic link, rwxr-x---
#expect(mode.permissions == [.ownerReadWriteExecute, .groupReadExecute])
#expect(mode != mode1)
#expect(mode != mode2)
#expect(mode.type == mode1.type)
#expect(mode.type == mode2.type)
}
@available(System 99, *)
@Test func invalidInput() async throws {
// No permissions, all other bits set
var invalidMode = FileMode(rawValue: ~0o7777)
#expect(invalidMode.permissions.isEmpty)
#expect(invalidMode.type != .directory)
#expect(invalidMode.type != .characterSpecial)
#expect(invalidMode.type != .blockSpecial)
#expect(invalidMode.type != .regular)
#expect(invalidMode.type != .fifo)
#expect(invalidMode.type != .symbolicLink)
#expect(invalidMode.type != .socket)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(invalidMode.type != .whiteout)
#endif
// All file-type bits set
invalidMode = FileMode(rawValue: S_IFMT)
#expect(invalidMode.type != .directory)
#expect(invalidMode.type != .characterSpecial)
#expect(invalidMode.type != .blockSpecial)
#expect(invalidMode.type != .regular)
#expect(invalidMode.type != .fifo)
#expect(invalidMode.type != .symbolicLink)
#expect(invalidMode.type != .socket)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(invalidMode.type != .whiteout)
#endif
// FileMode(type:permissions:) masks its inputs so
// they don't accidentally modify the other bits.
let emptyPermissions = FileMode(type: FileType(rawValue: ~0), permissions: [])
#expect(emptyPermissions.permissions.isEmpty)
#expect(emptyPermissions.type == FileType(rawValue: S_IFMT))
#expect(emptyPermissions == invalidMode)
let regularFile = FileMode(type: .regular, permissions: FilePermissions(rawValue: ~0))
#expect(regularFile.type == .regular)
#expect(regularFile.permissions == FilePermissions(rawValue: 0o7777))
#expect(regularFile.permissions == [
.ownerReadWriteExecute,
.groupReadWriteExecute,
.otherReadWriteExecute,
.setUserID, .setGroupID, .saveText
])
// Setting properties should not modify the other bits, either.
var mode = FileMode(rawValue: 0)
mode.type = FileType(rawValue: ~0)
#expect(mode.type == FileType(rawValue: S_IFMT))
#expect(mode.permissions.isEmpty)
mode.type.rawValue = 0
#expect(mode.type == FileType(rawValue: 0))
#expect(mode.permissions.isEmpty)
mode.permissions = FilePermissions(rawValue: ~0)
#expect(mode.permissions == FilePermissions(rawValue: 0o7777))
#expect(mode.type == FileType(rawValue: 0))
mode.permissions = []
#expect(mode.permissions.isEmpty)
#expect(mode.type == FileType(rawValue: 0))
}
}
#endif
+2 -4
View File
@@ -22,7 +22,7 @@ import CSystem
@available(System 0.0.1, *)
final class FileOperationsTest: XCTestCase {
#if ENABLE_MOCKING && !os(WASI) // Would need to use _getConst funcs from CSystem
#if !os(WASI) // Would need to use _getConst funcs from CSystem
func testSyscalls() {
let fd = FileDescriptor(rawValue: 1)
@@ -91,7 +91,7 @@ final class FileOperationsTest: XCTestCase {
for test in syscallTestCases { test.runAllTests() }
}
#endif // ENABLE_MOCKING && !os(WASI)
#endif // !os(WASI)
func testWriteFromEmptyBuffer() throws {
#if os(Windows)
@@ -215,7 +215,6 @@ final class FileOperationsTest: XCTestCase {
}
}
#if ENABLE_MOCKING
func testGithubIssues() {
// https://github.com/apple/swift-system/issues/26
#if os(WASI)
@@ -234,7 +233,6 @@ final class FileOperationsTest: XCTestCase {
}
issue26.runAllTests()
}
#endif // ENABLE_MOCKING
func testResizeFile() throws {
try withTemporaryFilePath(basename: "testResizeFile") { path in
@@ -19,6 +19,10 @@ import XCTest
import WinSDK
private let FILE_APPEND_DATA = DWORD(WinSDK.FILE_APPEND_DATA)
private let FILE_EXECUTE = DWORD(WinSDK.FILE_EXECUTE)
private let FILE_READ_ATTRIBUTES = DWORD(WinSDK.FILE_READ_ATTRIBUTES)
@available(iOS 8, *)
final class FileOperationsTestWindows: XCTestCase {
private let r = ACCESS_MASK(
@@ -43,6 +47,8 @@ final class FileOperationsTestWindows: XCTestCase {
| SYNCHRONIZE
)
private let none = ACCESS_MASK(0)
private struct Test {
var permissions: CModeT
var ownerAccess: ACCESS_MASK
@@ -72,7 +78,7 @@ final class FileOperationsTestWindows: XCTestCase {
var psidEveryone: PSID? = nil
XCTAssert(AllocateAndInitializeSid(&SIDAuthWorld, 1,
DWORD(SECURITY_WORLD_RID),
SECURITY_WORLD_RID,
0, 0, 0, 0, 0, 0, 0,
&psidEveryone))
defer {
@@ -106,7 +112,7 @@ final class FileOperationsTestWindows: XCTestCase {
&psidGroup,
&pDacl,
nil,
&pSD), DWORD(ERROR_SUCCESS))
&pSD), ERROR_SUCCESS)
defer {
LocalFree(pSD)
}
@@ -135,15 +141,15 @@ final class FileOperationsTestWindows: XCTestCase {
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&owner,
&ownerAccess), DWORD(ERROR_SUCCESS))
&ownerAccess), ERROR_SUCCESS)
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&group,
&groupAccess), DWORD(ERROR_SUCCESS))
&groupAccess), ERROR_SUCCESS)
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&everyone,
&otherAccess), DWORD(ERROR_SUCCESS))
&otherAccess), ERROR_SUCCESS)
return (ownerAccess, groupAccess, otherAccess)
}
@@ -182,9 +188,9 @@ final class FileOperationsTestWindows: XCTestCase {
try withTemporaryFilePath(basename: "testUmask") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r|x, 0),
Test(0o000, none, none, none),
Test(0o700, r|w|x, none, none),
Test(0o770, r|w|x, r|x, none),
Test(0o777, r|w|x, r|x, r|x)
]
@@ -195,9 +201,9 @@ final class FileOperationsTestWindows: XCTestCase {
.otherWrite, .otherExecute]) {
try withTemporaryFilePath(basename: "testUmask") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r, 0),
Test(0o000, none, none, none),
Test(0o700, r|w|x, none, none),
Test(0o770, r|w|x, r, none),
Test(0o777, r|w|x, r, r)
]
@@ -214,34 +220,81 @@ final class FileOperationsTestWindows: XCTestCase {
try FilePermissions.withCreationMask([]) {
try withTemporaryFilePath(basename: "testPermissions") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o000, none, none, none),
Test(0o400, r, 0, 0),
Test(0o200, w, 0, 0),
Test(0o100, x, 0, 0),
Test(0o040, 0, r, 0),
Test(0o020, 0, w, 0),
Test(0o010, 0, x, 0),
Test(0o004, 0, 0, r),
Test(0o002, 0, 0, w),
Test(0o001, 0, 0, x),
Test(0o400, r, none, none),
Test(0o200, w, none, none),
Test(0o100, x, none, none),
Test(0o040, none, r, none),
Test(0o020, none, w, none),
Test(0o010, none, x, none),
Test(0o004, none, none, r),
Test(0o002, none, none, w),
Test(0o001, none, none, x),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r|w|x, 0),
Test(0o700, r|w|x, none, none),
Test(0o770, r|w|x, r|w|x, none),
Test(0o777, r|w|x, r|w|x, r|w|x),
Test(0o755, r|w|x, r|x, r|x),
Test(0o644, r|w, r, r),
Test(0o007, 0, 0, r|w|x),
Test(0o070, 0, r|w|x, 0),
Test(0o077, 0, r|w|x, r|w|x),
Test(0o007, none, none, r|w|x),
Test(0o070, none, r|w|x, none),
Test(0o077, none, r|w|x, r|w|x),
]
try runTests(tests, at: path)
}
}
}
/// Test that buffer sizes exceeding DWORD.max (4GB) are properly rejected
func testBufferSizeLimit() throws {
try withTemporaryFilePath(basename: "testBufferSizeLimit") { path in
let fd = try FileDescriptor.open(
path.appending("test.txt"),
.readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite
)
defer { try? fd.close() }
// Write some data first
try fd.writeAll("test data".utf8)
// Allocate a small buffer for testing
let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 1024, alignment: 1)
defer { buffer.deallocate() }
// Test that a count exceeding DWORD.max (UInt32.max = 4,294,967,295) returns EINVAL
// We use a buffer pointer but pass a count > DWORD.max
let oversizedCount = Int(DWORD.max) + 1
let oversizedBuffer = UnsafeMutableRawBufferPointer(
start: buffer.baseAddress,
count: oversizedCount
)
// pread should fail with EINVAL
do {
_ = try fd.read(fromAbsoluteOffset: 0, into: oversizedBuffer)
XCTFail("Expected EINVAL for buffer size exceeding DWORD.max")
} catch let err as Errno {
XCTAssertEqual(err, .invalidArgument, "Expected EINVAL, got \(err)")
}
// pwrite should also fail with EINVAL
do {
_ = try fd.write(toAbsoluteOffset: 0, UnsafeRawBufferPointer(oversizedBuffer))
XCTFail("Expected EINVAL for buffer size exceeding DWORD.max")
} catch let err as Errno {
XCTAssertEqual(err, .invalidArgument, "Expected EINVAL, got \(err)")
}
// Verify that exactly DWORD.max works (if we had a buffer that large)
// We can't easily test this without allocating 4GB, but the boundary is correct
}
}
}
#endif // os(Windows)
@@ -107,7 +107,7 @@ final class FilePathComponentsTest: XCTestCase {
func expect(
_ s: String,
_ file: StaticString = #filePath,
_ file: StaticString = #file,
_ line: UInt = #line
) {
if path == FilePath(s) { return }
@@ -7,7 +7,6 @@
See https://swift.org/LICENSE.txt for license information
*/
#if ENABLE_MOCKING
import XCTest
#if SYSTEM_PACKAGE
@@ -106,4 +105,3 @@ final class FilePathParsingTest: XCTestCase {
}
}
}
#endif // ENABLE_MOCKING
@@ -7,7 +7,6 @@
See https://swift.org/LICENSE.txt for license information
*/
#if ENABLE_MOCKING
import XCTest
#if SYSTEM_PACKAGE
@@ -850,7 +849,7 @@ final class FilePathSyntaxTest: XCTestCase {
func expect(
_ s: String,
_ file: StaticString = #filePath,
_ file: StaticString = #file,
_ line: UInt = #line
) {
if path == FilePath(s) { return }
@@ -1239,4 +1238,3 @@ final class FilePathSyntaxTest: XCTestCase {
}
}
#endif // ENABLE_MOCKING
+2 -1
View File
@@ -22,7 +22,8 @@ func requestBytes(_ request: consuming RawIORequest) -> [UInt8] {
// which are known to work correctly.
final class IORequestTests: XCTestCase {
func testNop() {
let req = IORing.Request.nop().makeRawRequest()
let req = IORing.Request.nop().makeRawRequest(
pathBuffers: PendingPathBuffers(reservedCapacity: 0))
let sourceBytes = requestBytes(req)
// convenient property of nop: it's all zeros!
// for some unknown reason, liburing sets the fd field to -1.
+63 -46
View File
@@ -122,68 +122,85 @@ final class IORingTests: XCTestCase {
let bytesRead = try nonRingFD.read(into: rawBuffer)
XCTAssert(bytesRead == 13)
let result2 = String(cString: rawBuffer.assumingMemoryBound(to: CChar.self).baseAddress!)
XCTAssertEqual(result2, "Hello, World!")
XCTAssertEqual(result2, "Hello, World!")
try cleanUpHelloWorldFile(parent)
efdBuf.deallocate()
rawBuffer.deallocate()
}
func testPollAddPollIn() throws {
// Prior to the fix this is testing, prepare() escaped a pointer obtained
// inside `path.withPlatformString { ... }` into the SQE and dropped the
// owning FilePath before submit, so io_uring_enter handed the kernel a
// dangling pointer. Here we deliberately let the FilePath go out of scope
// between prepare and submit, then churn the heap to make UAFs observable.
func testPathBufferLifetimeAcrossPrepareSubmit() throws {
guard try uringEnabled() else { return }
var ring = try IORing(queueDepth: 32, flags: [])
let (parent, _) = try makeHelloWorldFile()
var ring = try IORing(queueDepth: 6)
// Test POLLIN: Create an eventfd to monitor for read readiness
let testEventFD = FileDescriptor(rawValue: eventfd(0, 0))
defer {
// Clean up
try! testEventFD.close()
func enqueueOpen() {
let path: FilePath = "/tmp/IORingTests/test.txt"
let ok = ring.prepare(request: .open(path, in: parent, mode: .readOnly))
XCTAssertTrue(ok)
}
let pollInContext: UInt64 = 42
enqueueOpen()
// Submit a pollAdd request to monitor for POLLIN events (data available for reading)
let enqueued = try ring.submit(linkedRequests:
.pollAdd(testEventFD, pollEvents: .pollin, isMultiShot: false, context: pollInContext))
XCTAssert(enqueued)
// Write to the eventfd to trigger the POLLIN event
var value: UInt64 = 1
withUnsafeBytes(of: &value) { bufferPtr in
_ = try? testEventFD.write(bufferPtr)
var churn: [UnsafeMutableRawBufferPointer] = []
for _ in 0..<256 {
let buf = UnsafeMutableRawBufferPointer.allocate(byteCount: 64, alignment: 1)
memset(buf.baseAddress!, 0x41, 64)
churn.append(buf)
}
for buf in churn { buf.deallocate() }
churn.removeAll()
// Consume the completion from the poll operation
try ring.submitPreparedRequests()
let completion = try ring.blockingConsumeCompletion()
XCTAssertEqual(completion.context, pollInContext)
XCTAssertGreaterThan(completion.result, 0) // Poll should return mask of ready events
}
XCTAssertGreaterThanOrEqual(
completion.result, 0,
"open should succeed; got \(completion.result)")
func testPollAddPollOut() throws {
guard try uringEnabled() else { return }
var ring = try IORing(queueDepth: 32, flags: [])
// Test POLLOUT: Create a pipe to monitor for write readiness
var pipeFDs: [Int32] = [0, 0]
let pipeResult = pipe(&pipeFDs)
XCTAssertEqual(pipeResult, 0)
let writeFD = FileDescriptor(rawValue: pipeFDs[1])
let readFD = FileDescriptor(rawValue: pipeFDs[0])
defer {
// Clean up
try! writeFD.close()
try! readFD.close()
if completion.result >= 0 {
let fd = FileDescriptor(rawValue: Int32(completion.result))
try fd.close()
}
let pollOutContext: UInt64 = 43
try cleanUpHelloWorldFile(parent)
}
func testPathBufferLifetimeAcrossLinkedRequests() throws {
guard try uringEnabled() else { return }
let (parent, _) = try makeHelloWorldFile()
let rawBuffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 13, alignment: 16)
var ring = try setupTestRing(depth: 6, fileSlots: 1, buffers: [rawBuffer])
// Submit a pollAdd request to monitor for POLLOUT events (ready for writing)
// Pipes are typically ready for writing when empty
let enqueuedOut = try ring.submit(linkedRequests:
.pollAdd(writeFD, pollEvents: .pollout, isMultiShot: false, context: pollOutContext))
XCTAssert(enqueuedOut)
func enqueueLinkedReadback() {
let path: FilePath = "/tmp/IORingTests/test.txt"
let ok = ring.prepare(linkedRequests:
.open(path, in: parent, into: ring.registeredFileSlots[0], mode: .readOnly),
.read(ring.registeredFileSlots[0], into: ring.registeredBuffers[0]),
.close(ring.registeredFileSlots[0]))
XCTAssertTrue(ok)
}
enqueueLinkedReadback()
// Consume the completion from the poll operation
let completionOut = try ring.blockingConsumeCompletion()
XCTAssertEqual(completionOut.context, pollOutContext)
XCTAssertGreaterThan(completionOut.result, 0) // Poll should return mask of ready events
var churn: [UnsafeMutableRawBufferPointer] = []
for _ in 0..<256 {
let buf = UnsafeMutableRawBufferPointer.allocate(byteCount: 64, alignment: 1)
memset(buf.baseAddress!, 0x41, 64)
churn.append(buf)
}
for buf in churn { buf.deallocate() }
try ring.submitPreparedRequests()
_ = try ring.blockingConsumeCompletion() // open
_ = try ring.blockingConsumeCompletion() // read
_ = try ring.blockingConsumeCompletion() // close
let result = String(cString: rawBuffer.assumingMemoryBound(to: CChar.self).baseAddress!)
XCTAssertEqual(result, "Hello, World!")
try cleanUpHelloWorldFile(parent)
rawBuffer.deallocate()
}
}
#endif // os(Linux)
-2
View File
@@ -7,7 +7,6 @@
See https://swift.org/LICENSE.txt for license information
*/
#if ENABLE_MOCKING
import XCTest
#if SYSTEM_PACKAGE
@@ -49,4 +48,3 @@ final class MockingTest: XCTestCase {
XCTAssertFalse(mockingEnabled)
}
}
#endif // ENABLE_MOCKING
-420
View File
@@ -1,420 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift System project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !os(Windows)
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
import WASILibc
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@Suite("Stat")
private struct StatTests {
@available(System 99, *)
@Test func basics() async throws {
try withTemporaryFilePath(basename: "Stat_basics") { tempDir in
let dirStatFromFilePath = try tempDir.stat()
#expect(dirStatFromFilePath.type == .directory)
let dirFD = try FileDescriptor.open(tempDir, .readOnly)
defer {
try? dirFD.close()
}
let dirStatFromFD = try dirFD.stat()
#expect(dirStatFromFD.type == .directory)
let dirStatFromCString = try tempDir.withPlatformString { try Stat($0) }
#expect(dirStatFromCString.type == .directory)
#expect(dirStatFromFilePath == dirStatFromFD)
#expect(dirStatFromFD == dirStatFromCString)
let tempFile = tempDir.appending("test.txt")
let fileFD = try FileDescriptor.open(tempFile, .readWrite, options: .create, permissions: [.ownerReadWrite, .groupRead, .otherRead])
defer {
try? fileFD.close()
}
try fileFD.writeAll("Hello, world!".utf8)
let fileStatFromFD = try fileFD.stat()
#expect(fileStatFromFD.type == .regular)
#expect(fileStatFromFD.permissions == [.ownerReadWrite, .groupRead, .otherRead])
#expect(fileStatFromFD.size == "Hello, world!".utf8.count)
let fileStatFromFilePath = try tempFile.stat()
#expect(fileStatFromFilePath.type == .regular)
let fileStatFromCString = try tempFile.withPlatformString { try Stat($0) }
#expect(fileStatFromCString.type == .regular)
#expect(fileStatFromFD == fileStatFromFilePath)
#expect(fileStatFromFilePath == fileStatFromCString)
}
}
@available(System 99, *)
@Test func followSymlinkInits() async throws {
try withTemporaryFilePath(basename: "Stat_followSymlinkInits") { tempDir in
let targetFilePath = tempDir.appending("target.txt")
let symlinkPath = tempDir.appending("symlink")
let targetFD = try FileDescriptor.open(targetFilePath, .readWrite, options: .create, permissions: .ownerReadWrite)
defer {
try? targetFD.close()
}
try targetFD.writeAll(Array(repeating: UInt8(ascii: "A"), count: 1025))
try targetFilePath.withPlatformString { targetPtr in
try symlinkPath.withPlatformString { symlinkPtr in
try #require(symlink(targetPtr, symlinkPtr) == 0, "\(Errno.current)")
}
}
// Can't open an fd to a symlink on WASI (no O_PATH)
// On non-Darwin, we need O_PATH | O_NOFOLLOW to open the symlink
// directly, but O_PATH requires _GNU_SOURCE be defined (TODO).
#if SYSTEM_PACKAGE_DARWIN
let symlinkFD = try FileDescriptor.open(symlinkPath, .readOnly, options: .symlink)
defer {
try? symlinkFD.close()
}
#endif
let targetStat = try targetFilePath.stat()
let originalTargetAccessTime = targetStat.st_atim
let symlinkStat = try symlinkPath.stat(followTargetSymlink: false)
let originalSymlinkAccessTime = symlinkStat.st_atim
#expect(targetStat != symlinkStat)
#expect(targetStat.type == .regular)
#expect(symlinkStat.type == .symbolicLink)
#expect(symlinkStat.size < targetStat.size)
#expect(symlinkStat.sizeAllocated < targetStat.sizeAllocated)
// Set each .st_atim back to its original value for comparison
// FileDescriptor Extensions
var stat = try targetFD.stat()
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
#if SYSTEM_PACKAGE_DARWIN
stat = try symlinkFD.stat()
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
#endif
// Initializing Stat with FileDescriptor
stat = try Stat(targetFD)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
#if SYSTEM_PACKAGE_DARWIN
stat = try Stat(symlinkFD)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
#endif
// FilePath Extensions
stat = try symlinkPath.stat(followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try symlinkPath.stat(followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
// Initializing Stat with UnsafePointer<CChar>
try symlinkPath.withPlatformString { pathPtr in
stat = try Stat(pathPtr, followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try Stat(pathPtr, followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
}
// Initializing Stat with FilePath
stat = try Stat(symlinkPath, followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try Stat(symlinkPath, followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
// Initializing Stat with String
stat = try Stat(symlinkPath.string, followTargetSymlink: true)
stat.st_atim = originalTargetAccessTime
#expect(stat == targetStat)
stat = try Stat(symlinkPath.string, followTargetSymlink: false)
stat.st_atim = originalSymlinkAccessTime
#expect(stat == symlinkStat)
}
}
@available(System 99, *)
@Test func permissions() async throws {
try withTemporaryFilePath(basename: "Stat_permissions") { tempDir in
let testFile = tempDir.appending("test.txt")
let fd = try FileDescriptor.open(testFile, .writeOnly, options: .create, permissions: [.ownerReadWrite, .groupRead, .otherRead])
try fd.close()
let stat = try testFile.stat()
#expect(stat.type == .regular)
#expect(stat.permissions == [.ownerReadWrite, .groupRead, .otherRead])
var newMode = stat.mode
newMode.permissions.insert(.ownerExecute)
try testFile.withPlatformString { pathPtr in
try #require(chmod(pathPtr, newMode.permissions.rawValue) == 0, "\(Errno.current)")
}
let updatedStat = try testFile.stat()
#expect(updatedStat.permissions == newMode.permissions)
newMode.permissions.remove(.ownerWriteExecute)
try testFile.withPlatformString { pathPtr in
try #require(chmod(pathPtr, newMode.permissions.rawValue) == 0, "\(Errno.current)")
}
let readOnlyStat = try testFile.stat()
#expect(readOnlyStat.permissions == newMode.permissions)
}
}
@available(System 99, *)
@Test func times() async throws {
var start = timespec()
try #require(clock_gettime(CLOCK_REALTIME, &start) == 0, "\(Errno.current)")
start.tv_sec -= 1 // A little wiggle room
try withTemporaryFilePath(basename: "Stat_times") { tempDir in
var dirStat = try tempDir.stat()
let dirAccessTime0 = dirStat.st_atim
let dirModificationTime0 = dirStat.st_mtim
let dirChangeTime0 = dirStat.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let dirCreationTime0 = dirStat.st_birthtim
#endif
var startUpperBound = start
startUpperBound.tv_sec += 5
#expect(dirAccessTime0 >= start)
#expect(dirAccessTime0 < startUpperBound)
#expect(dirModificationTime0 >= start)
#expect(dirModificationTime0 < startUpperBound)
#expect(dirChangeTime0 >= start)
#expect(dirChangeTime0 < startUpperBound)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirCreationTime0 >= start)
#expect(dirCreationTime0 < startUpperBound)
#endif
// Fails intermittently if less than 5ms
usleep(10000)
let file1 = tempDir.appending("test1.txt")
let fd1 = try FileDescriptor.open(file1, .writeOnly, options: .create, permissions: .ownerReadWrite)
defer {
try? fd1.close()
}
dirStat = try tempDir.stat()
let dirAccessTime1 = dirStat.st_atim
let dirModificationTime1 = dirStat.st_mtim
let dirChangeTime1 = dirStat.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let dirCreationTime1 = dirStat.st_birthtim
#endif
// Creating a file updates directory modification and change time.
// Access time may not be updated depending on mount options like NOATIME.
#expect(dirModificationTime1 > dirModificationTime0)
#expect(dirChangeTime1 > dirChangeTime0)
#expect(dirAccessTime1 >= dirAccessTime0)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirCreationTime1 == dirCreationTime0)
#endif
usleep(10000)
// Changing permissions only updates directory change time
try tempDir.withPlatformString { pathPtr in
var newMode = dirStat.mode
// tempDir only starts with .ownerReadWriteExecute
newMode.permissions.insert(.groupReadWriteExecute)
try #require(chmod(pathPtr, newMode.rawValue) == 0, "\(Errno.current)")
}
dirStat = try tempDir.stat()
let dirChangeTime2 = dirStat.st_ctim
#expect(dirChangeTime2 > dirChangeTime1)
#expect(dirStat.st_atim == dirAccessTime1)
#expect(dirStat.st_mtim == dirModificationTime1)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirStat.st_birthtim == dirCreationTime1)
#endif
var stat1 = try file1.stat()
let file1AccessTime1 = stat1.st_atim
let file1ModificationTime1 = stat1.st_mtim
let file1ChangeTime1 = stat1.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let file1CreationTime1 = stat1.st_birthtim
#endif
usleep(10000)
try fd1.writeAll("Hello, world!".utf8)
stat1 = try file1.stat()
let file1AccessTime2 = stat1.st_atim
let file1ModificationTime2 = stat1.st_mtim
let file1ChangeTime2 = stat1.st_ctim
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
let file1CreationTime2 = stat1.st_birthtim
#endif
#expect(file1AccessTime2 >= file1AccessTime1)
#expect(file1ModificationTime2 > file1ModificationTime1)
#expect(file1ChangeTime2 > file1ChangeTime1)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(file1CreationTime2 == file1CreationTime1)
#endif
// Changing file metadata or content does not update directory times
dirStat = try tempDir.stat()
#expect(dirStat.st_ctim == dirChangeTime2)
#expect(dirStat.st_atim == dirAccessTime1)
#expect(dirStat.st_mtim == dirModificationTime1)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(dirStat.st_birthtim == dirCreationTime1)
#endif
usleep(10000)
let file2 = tempDir.appending("test2.txt")
let fd2 = try FileDescriptor.open(file2, .writeOnly, options: .create, permissions: .ownerReadWrite)
defer {
try? fd2.close()
}
let stat2 = try file2.stat()
#expect(stat2.st_atim > file1AccessTime2)
#expect(stat2.st_mtim > file1ModificationTime2)
#expect(stat2.st_ctim > file1ChangeTime2)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
#expect(stat2.st_birthtim > file1CreationTime2)
#endif
}
}
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD) || os(OpenBSD)
@available(System 99, *)
@Test func flags() async throws {
try withTemporaryFilePath(basename: "Stat_flags") { tempDir in
let filePath = tempDir.appending("test.txt")
let fd = try FileDescriptor.open(filePath, .writeOnly, options: .create, permissions: .ownerReadWrite)
defer {
try? fd.close()
}
var stat = try fd.stat()
var flags = stat.flags
#if SYSTEM_PACKAGE_DARWIN
let userSettableFlags: FileFlags = [
.noDump, .userImmutable, .userAppend,
.opaque, .tracked, .hidden,
/* .dataVault (throws EPERM when testing) */
]
#elseif os(FreeBSD)
let userSettableFlags: FileFlags = [
.noDump, .userImmutable, .userAppend,
.opaque, .tracked, .hidden,
.userNoUnlink,
.offline,
.readOnly,
.reparse,
.sparse,
.system
]
#else // os(OpenBSD)
let userSettableFlags: FileFlags = [
.noDump, .userImmutable, .userAppend
]
#endif
flags.insert(userSettableFlags)
try #require(fchflags(fd.rawValue, flags.rawValue) == 0, "\(Errno.current)")
stat = try fd.stat()
#expect(stat.flags == flags)
flags.remove(userSettableFlags)
try #require(fchflags(fd.rawValue, flags.rawValue) == 0, "\(Errno.current)")
stat = try fd.stat()
#expect(stat.flags == flags)
}
}
#endif
}
// Comparison operators for timespec until UTCClock.Instant properties are available
private func >= (lhs: timespec, rhs: timespec) -> Bool {
(lhs.tv_sec, lhs.tv_nsec) >= (rhs.tv_sec, rhs.tv_nsec)
}
private func < (lhs: timespec, rhs: timespec) -> Bool {
(lhs.tv_sec, lhs.tv_nsec) < (rhs.tv_sec, rhs.tv_nsec)
}
private func > (lhs: timespec, rhs: timespec) -> Bool {
(lhs.tv_sec, lhs.tv_nsec) > (rhs.tv_sec, rhs.tv_nsec)
}
private func == (lhs: timespec, rhs: timespec) -> Bool {
lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec
}
#endif
@@ -17,7 +17,6 @@ import XCTest
internal struct Wildcard: Hashable {}
#if ENABLE_MOCKING
extension Trace.Entry {
/// This implements `==` with wildcard matching.
/// (`Entry` cannot conform to `Equatable`/`Hashable` this way because
@@ -34,10 +33,9 @@ extension Trace.Entry {
return true
}
}
#endif // ENABLE_MOCKING
// To aid debugging, force failures to fatal error
internal let forceFatalFailures = false
internal var forceFatalFailures = false
internal protocol TestCase {
// TODO: want a source location stack, more fidelity, kinds of stack entries, etc
@@ -83,7 +81,6 @@ extension TestCase {
fail(message)
}
}
#if ENABLE_MOCKING
func expectMatch(
_ expected: Trace.Entry?, _ actual: Trace.Entry?,
_ message: String? = nil
@@ -105,7 +102,6 @@ extension TestCase {
fail(message)
}
}
#endif // ENABLE_MOCKING
func expectNil<T>(
_ actual: T?,
_ message: String? = nil
@@ -146,7 +142,6 @@ extension TestCase {
}
#if ENABLE_MOCKING
internal struct MockTestCase: TestCase {
var file: StaticString
var line: UInt
@@ -246,7 +241,6 @@ internal struct MockTestCase: TestCase {
}
}
}
#endif // ENABLE_MOCKING
internal func withWindowsPaths(enabled: Bool, _ body: () -> ()) {
_withWindowsPaths(enabled: enabled, body)
+1 -1
View File
@@ -34,7 +34,7 @@ class UtilTests: XCTestCase {
func testCStringArray() {
func check(
_ array: [String],
file: StaticString = #filePath,
file: StaticString = #file,
line: UInt = #line
) {
array._withCStringArray { carray in