Add io_uring support to System

Package.swift

@@ -22,8 +22,21 @@ let swiftSettings: [SwiftSetting] = [
     .when(platforms: [.macOS, .macCatalyst, .iOS, .watchOS, .tvOS, .visionOS])),
   .define("SYSTEM_PACKAGE"),
   .define("ENABLE_MOCKING", .when(configuration: .debug)),
+  .enableExperimentalFeature("Lifetimes"),
 ]
 
+#if os(Linux)
+let filesToExclude = ["CMakeLists.txt"]
+#else
+let filesToExclude = ["CMakeLists.txt", "IORing"]
+#endif
+
+#if os(Linux)
+let testsToExclude:[String] = []
+#else
+let testsToExclude = ["IORequestTests.swift", "IORingTests.swift"]
+#endif
+
 let package = Package(
   name: "swift-system",
   products: [
@@ -40,12 +53,13 @@ let package = Package(
       name: "SystemPackage",
       dependencies: ["CSystem"],
       path: "Sources/System",
-      exclude: ["CMakeLists.txt"],
+      exclude: filesToExclude,
       cSettings: cSettings,
       swiftSettings: swiftSettings),
     .testTarget(
       name: "SystemTests",
       dependencies: ["SystemPackage"],
+      exclude: testsToExclude,
       cSettings: cSettings,
       swiftSettings: swiftSettings),
   ])

Sources/CSystem/include/CSystemLinux.h

@@ -21,5 +21,6 @@
 #include <pthread.h>
 #include <sched.h>
 #include <unistd.h>
+#include "io_uring.h"
 #endif
 

Sources/CSystem/include/io_uring.h

@@ -0,0 +1,60 @@
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/uio.h>
+
+#include <signal.h>
+#include <linux/io_uring.h>
+
+#ifndef SWIFT_IORING_C_WRAPPER
+#define SWIFT_IORING_C_WRAPPER
+
+# ifndef __NR_io_uring_setup
+#  define __NR_io_uring_setup		425
+# endif
+# ifndef __NR_io_uring_enter
+#  define __NR_io_uring_enter		426
+# endif
+# ifndef __NR_io_uring_register
+#  define __NR_io_uring_register	427
+# endif
+
+/*
+struct io_uring_getevents_arg {
+	__u64	sigmask;
+	__u32	sigmask_sz;
+	__u32	min_wait_usec; //used to be called `pad`. This compatibility wrapper avoids dealing with that.
+	__u64	ts;
+};
+*/
+struct swift_io_uring_getevents_arg {
+	__u64	sigmask;
+	__u32	sigmask_sz;
+	__u32	min_wait_usec;
+	__u64	ts;
+};
+
+static inline int io_uring_register(int fd, unsigned int opcode, void *arg,
+		      unsigned int nr_args)
+{
+	return syscall(__NR_io_uring_register, fd, opcode, arg, nr_args);
+}
+
+static inline int io_uring_setup(unsigned int entries, struct io_uring_params *p)
+{
+	return syscall(__NR_io_uring_setup, entries, p);
+}
+
+static inline int io_uring_enter2(int fd, unsigned int to_submit, unsigned int min_complete,
+		   unsigned int flags, void *args, size_t sz)
+{
+	return syscall(__NR_io_uring_enter, fd, to_submit, min_complete,
+			flags, args, _NSIG / 8);
+}
+
+static inline int io_uring_enter(int fd, unsigned int to_submit, unsigned int min_complete,
+		   unsigned int flags, sigset_t *sig)
+{
+	return io_uring_enter2(fd, to_submit, min_complete, flags, sig, _NSIG / 8);
+}
+
+#endif

Sources/System/IORing/IOCompletion.swift

@@ -0,0 +1,71 @@
+#if compiler(>=6.2)
+#if os(Linux)
+
+import CSystem
+
+public extension IORing {
+    struct Completion: ~Copyable {
+        @inlinable init(rawValue inRawValue: io_uring_cqe) {
+            rawValue = inRawValue
+        }
+        @usableFromInline let rawValue: io_uring_cqe
+    }
+}
+
+public extension IORing.Completion {
+    struct Flags: OptionSet, Hashable, Codable {
+        public let rawValue: UInt32
+
+        @inlinable public init(rawValue: UInt32) {
+            self.rawValue = rawValue
+        }
+
+        ///`IORING_CQE_F_BUFFER` Indicates the buffer ID is stored in the upper 16 bits
+        @inlinable public static var allocatedBuffer: Flags { Flags(rawValue: 1 << 0) }
+        ///`IORING_CQE_F_MORE`  Indicates more completions will be generated from the request that generated this
+        @inlinable public static var moreCompletions: Flags { Flags(rawValue: 1 << 1) }
+        //`IORING_CQE_F_SOCK_NONEMPTY`, but currently unused
+        //@inlinable public static var socketNotEmpty: Flags { Flags(rawValue: 1 << 2) }
+        //`IORING_CQE_F_NOTIF`, but currently unused
+        //@inlinable public static var isNotificationEvent: Flags { Flags(rawValue: 1 << 3) }
+        //IORING_CQE_F_BUF_MORE  will eventually be  (1U << 4) if we add IOU_PBUF_RING_INC support
+    }
+}
+
+public extension IORing.Completion {
+    @inlinable var context: UInt64 {
+        get {
+            rawValue.user_data
+        }
+    }
+
+    @inlinable var userPointer: UnsafeRawPointer? {
+        get {
+            UnsafeRawPointer(bitPattern: UInt(rawValue.user_data))
+        }
+    }
+
+    @inlinable var result: Int32 {
+        get {
+            rawValue.res
+        }
+    }
+
+    @inlinable var flags: IORing.Completion.Flags {
+        get {
+            Flags(rawValue: rawValue.flags & 0x0000FFFF)
+        }
+    }
+
+    @inlinable var bufferIndex: UInt16? {
+        get {
+            if self.flags.contains(.allocatedBuffer) {
+                return UInt16(rawValue.flags >> 16)
+            } else {
+                return nil
+            }
+        }
+    }
+}
+#endif
+#endif