AIO

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Aio.cs

@@ -0,0 +1,129 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct IoEvent
+        {
+            internal ulong Data;
+            internal ulong Obj;
+            internal long Res;
+            internal long Res2;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct IoControlBlock
+        {
+            internal ulong AioData;
+
+            // these fields swap for big endian
+            // https://github.com/torvalds/linux/blob/0a679e13ea30f85a1aef0669ee0c5a9fd7860b34/include/uapi/linux/aio_abi.h#L77-L83
+            private uint _swappedField_1;
+            private uint _swappedField_2;
+
+            internal ushort AioLioOpcode;
+            internal short AioReqprio;
+            internal uint AioFildes;
+
+            internal ulong AioBuf;
+            internal ulong AioNbytes;
+            internal long AioOffset;
+
+            internal ulong AioReserved2;
+
+            internal uint AioFlags;
+            internal uint AioResfd;
+
+            internal uint AioKey
+            {
+                get => BitConverter.IsLittleEndian ? _swappedField_1 : _swappedField_2;
+                set
+                {
+                    if (BitConverter.IsLittleEndian)
+                    {
+                        _swappedField_1 = value;
+                    }
+                    else
+                    {
+                        _swappedField_2 = value;
+                    }
+                }
+            }
+            internal int AioRwFlags
+            {
+                get => BitConverter.IsLittleEndian ? (int)_swappedField_2 : (int)_swappedField_1;
+                set
+                {
+                    if (BitConverter.IsLittleEndian)
+                    {
+                        _swappedField_2 = (uint)value;
+                    }
+                    else
+                    {
+                        _swappedField_1 = (uint)value;
+                    }
+                }
+            }
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct AioRing
+        {
+            internal uint Id;
+            internal uint Nr;
+            internal uint Head;
+            internal uint Tail;
+            internal uint Magic;
+            internal uint CompatFeatures;
+            internal uint IncompatFeatures;
+            internal uint HeaderLength;
+
+            internal static unsafe IoEvent* IoEvents(AioRing* ring, int idx)
+            {
+                IoEvent* ev = (IoEvent*)(ring + 1);
+                return ev + idx;
+            }
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct AioContext
+        {
+            internal unsafe AioRing* Ring;
+        }
+
+        internal static class IoControlBlockFlags
+        {
+            internal const int IOCB_CMD_PREAD   = 0;
+            internal const int IOCB_CMD_PWRITE  = 1;
+            internal const int IOCB_CMD_FSYNC   = 2;
+            internal const int IOCB_CMD_FDSYNC  = 3;
+            // 4 was the experimental IOCB_CMD_PREADX
+            internal const int IOCB_CMD_POLL    = 5;
+            internal const int IOCB_CMD_NOOP    = 6;
+            internal const int IOCB_CMD_PREADV  = 7;
+            internal const int IOCB_CMD_PWRITEV = 8;
+        }
+
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_IsAioSupported")]
+        internal static extern bool IsAioSupported();
+
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_IoSetup", SetLastError = true)]
+        internal static extern unsafe int IoSetup(uint eventsCount, AioContext* context);
+
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_IoDestroy", SetLastError = true)]
+        internal static extern unsafe int IoDestroy(AioRing* ring);
+
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_IoSubmit", SetLastError = true)]
+        internal static extern unsafe int IoSubmit(AioRing* ring, long controlBlocksCount, IoControlBlock** ioControlBlocks);
+
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_IoGetEvents", SetLastError = true)]
+        internal static extern unsafe int IoGetEvents(AioRing* ring, long minimumEventsCount, long maximumEventsCount, IoEvent* ioEvents);
+    }
+}

src/libraries/Native/Unix/Common/pal_config.h.in

@@ -96,6 +96,7 @@
 #cmakedefine01 HAVE_TCP_H_TCP_KEEPALIVE
 #cmakedefine01 HAVE_BUILTIN_MUL_OVERFLOW
 #cmakedefine01 HAVE_DISCONNECTX
+#cmakedefine01 HAVE_LINUX_AIO
 
 // Mac OS X has stat64, but it is deprecated since plain stat now
 // provides the same 64-bit aware struct when targeting OS X > 10.5

src/libraries/Native/Unix/System.Native/pal_networking.c

@@ -56,6 +56,10 @@
 #if HAVE_LINUX_CAN_H
 #include <linux/can.h>
 #endif
+#if HAVE_LINUX_AIO
+#include <linux/aio_abi.h>
+#include <sys/syscall.h>
+#endif
 #if HAVE_KQUEUE
 #if KEVENT_HAS_VOID_UDATA
 static void* GetKeventUdata(uintptr_t udata)
@@ -2879,3 +2883,52 @@ uint32_t SystemNative_InterfaceNameToIndex(char* interfaceName)
         interfaceName++;
     return if_nametoindex(interfaceName);
 }
+
+int32_t SystemNative_IsAioSupported(void)
+{
+#if HAVE_LINUX_AIO
+    return true;
+#else
+    return false;
+#endif
+}
+
+int32_t SystemNative_IoSetup(uint32_t eventsCount, AioContext* context)
+{
+#if HAVE_LINUX_AIO
+    return (int32_t)syscall(__NR_io_setup, eventsCount, context);
+#else
+    errno = ENOTSUP;
+    return -1;
+#endif
+}
+
+int32_t SystemNative_IoDestroy(AioRing* ring)
+{
+#if HAVE_LINUX_AIO
+    return (int32_t)syscall(__NR_io_destroy, ring);
+#else
+    errno = ENOTSUP;
+    return -1;
+#endif
+}
+
+int32_t SystemNative_IoSubmit(AioRing* ring, int64_t controlBlocksCount, IoControlBlock** ioControlBlocks)
+{
+#if HAVE_LINUX_AIO
+    return (int32_t)syscall(__NR_io_submit, ring, controlBlocksCount, ioControlBlocks);
+#else
+    errno = ENOTSUP;
+    return -1;
+#endif
+}
+
+int32_t SystemNative_IoGetEvents(AioRing* ring, int64_t minEventsCount, int64_t maxEventsCount, IoEvent* ioEvents)
+{
+#if HAVE_LINUX_AIO
+    return (int32_t)syscall(__NR_io_getevents, ring, minEventsCount, maxEventsCount, ioEvents, NULL); // NULL is the timeout
+#else
+    errno = ENOTSUP;
+    return -1;
+#endif
+}

src/libraries/Native/Unix/System.Native/pal_networking.h

@@ -310,6 +310,47 @@ typedef struct
     uint32_t Padding;    // Pad out to 8-byte alignment
 } SocketEvent;
 
+typedef struct
+{
+    uint64_t Data;
+    uint64_t Obj;
+    int64_t Res;
+    int64_t Res2;
+} IoEvent;
+
+typedef struct
+{
+    uint64_t AioData;
+    uint32_t AioKey;
+    int32_t AioRwFlags;
+    uint16_t AioLioOpcode;
+    int16_t AioReqprio;
+    uint32_t AioFildes;
+    uint64_t AioBuf;
+    uint64_t AioNbytes;
+    int64_t AioOffset;
+    uint64_t AioReserved2;
+    uint32_t AioFlags;
+    uint32_t AioResfd;
+} IoControlBlock;
+
+typedef struct
+{
+    uint32_t Id;
+    uint32_t Nr;
+    uint32_t Head;
+    uint32_t Tail;
+    uint32_t Magic;
+    uint32_t CompatFeatures;
+    uint32_t IncompatFeatures;
+    uint32_t HeaderLength;
+} AioRing;
+
+typedef struct
+{
+    AioRing* Ring;
+} AioContext;
+
 DLLEXPORT int32_t SystemNative_GetHostEntryForName(const uint8_t* address, HostEntry* entry);
 
 DLLEXPORT void SystemNative_FreeHostEntry(HostEntry* entry);
@@ -424,3 +465,13 @@ DLLEXPORT int32_t SystemNative_SendFile(intptr_t out_fd, intptr_t in_fd, int64_t
 DLLEXPORT int32_t SystemNative_Disconnect(intptr_t socket);
 
 DLLEXPORT uint32_t SystemNative_InterfaceNameToIndex(char* interfaceName);
+
+DLLEXPORT int32_t SystemNative_IsAioSupported(void);
+
+DLLEXPORT int32_t SystemNative_IoSetup(uint32_t eventsCount, AioContext* context);
+
+DLLEXPORT int32_t SystemNative_IoDestroy(AioRing* ring);
+
+DLLEXPORT int32_t SystemNative_IoSubmit(AioRing* ring, int64_t controlBlocksCount, IoControlBlock** ioControlBlocks);
+
+DLLEXPORT int32_t SystemNative_IoGetEvents(AioRing* ring, int64_t minEventsCount, int64_t maxEventsCount, IoEvent* ioEvents);

src/libraries/Native/Unix/configure.cmake

@@ -839,6 +839,17 @@ check_c_source_compiles(
     "
     HAVE_BUILTIN_MUL_OVERFLOW)
 
+check_c_source_compiles(
+    "
+    #include <linux/aio_abi.h>
+    int main(void)
+    {
+        int x = IOCB_CMD_PREAD;
+        return x;
+    }
+    "
+    HAVE_LINUX_AIO)
+
 configure_file(
     ${CMAKE_CURRENT_SOURCE_DIR}/Common/pal_config.h.in
     ${CMAKE_CURRENT_BINARY_DIR}/Common/pal_config.h)

src/libraries/System.Net.Sockets/src/System.Net.Sockets.csproj

@@ -287,6 +287,9 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Accept.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.Accept.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Aio.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.Aio.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Bind.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.Bind.cs</Link>
     </Compile>
@@ -403,7 +406,4 @@
     <Reference Include="System.Threading.Overlapped" />
     <Reference Include="System.Threading.ThreadPool" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <Reference Include="System.Threading.ThreadPool" />
-  </ItemGroup>
 </Project>