Set of offset-based APIs for thread-safe file IO

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

@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        internal unsafe struct IOVector
+        {
+            public byte* Base;
+            public UIntPtr Count;
+        }
+    }
+}

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

@@ -8,12 +8,6 @@ internal static partial class Interop
 {
     internal static partial class Sys
     {
-        internal unsafe struct IOVector
-        {
-            public byte* Base;
-            public UIntPtr Count;
-        }
-
         internal unsafe struct MessageHeader
         {
             public byte* SocketAddress;

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

@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PRead", SetLastError = true)]
+        internal static extern unsafe int PRead(SafeHandle fd, byte* buffer, int count, long fileOffset);
+    }
+}

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

@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PReadV", SetLastError = true)]
+        internal static extern unsafe long PReadV(SafeHandle fd, IOVector* vectors, int vectorCount, long fileOffset);
+    }
+}

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

@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PWrite", SetLastError = true)]
+        internal static extern unsafe int PWrite(SafeHandle fd, byte* buffer, int bufferSize, long fileOffset);
+    }
+}

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

@@ -0,0 +1,13 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_PWriteV", SetLastError = true)]
+        internal static extern unsafe long PWriteV(SafeHandle fd, IOVector* vectors, int vectorCount, long fileOffset);
+    }
+}

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.FileScatterGather.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        internal unsafe struct FILE_SEGMENT_ELEMENT
+        {
+            [FieldOffset(0)]
+            public IntPtr Buffer;
+            [FieldOffset(0)]
+            public ulong Alignment;
+        }
+
+        [DllImport(Libraries.Kernel32, SetLastError = true)]
+        internal static extern unsafe int ReadFileScatter(
+            SafeHandle handle,
+            FILE_SEGMENT_ELEMENT* segments,
+            int numBytesToRead,
+            IntPtr reserved_mustBeZero,
+            NativeOverlapped* overlapped);
+
+        [DllImport(Libraries.Kernel32, SetLastError = true)]
+        internal static extern unsafe int WriteFileGather(
+            SafeHandle handle,
+            FILE_SEGMENT_ELEMENT* segments,
+            int numBytesToWrite,
+            IntPtr reserved_mustBeZero,
+            NativeOverlapped* overlapped);
+    }
+}

src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtCreateFile.cs

@@ -10,10 +10,6 @@ internal static partial class Interop
 {
     internal static partial class NtDll
     {
-        internal const uint NT_ERROR_STATUS_DISK_FULL = 0xC000007F;
-        internal const uint NT_ERROR_STATUS_FILE_TOO_LARGE = 0xC0000904;
-        internal const uint NT_STATUS_INVALID_PARAMETER = 0xC000000D;
-
         // https://msdn.microsoft.com/en-us/library/bb432380.aspx
         // https://msdn.microsoft.com/en-us/library/windows/hardware/ff566424.aspx
         [DllImport(Libraries.NtDll, CharSet = CharSet.Unicode, ExactSpelling = true)]
@@ -138,9 +134,9 @@ private static DesiredAccess GetDesiredAccess(FileAccess access, FileMode fileMo
             {
                 result |= DesiredAccess.SYNCHRONIZE; // required by FILE_SYNCHRONOUS_IO_NONALERT
             }
-            if ((options & FileOptions.DeleteOnClose) != 0 || fileMode == FileMode.Create)
+            if ((options & FileOptions.DeleteOnClose) != 0)
             {
-                result |= DesiredAccess.DELETE; // required by FILE_DELETE_ON_CLOSE and FILE_SUPERSEDE (which deletes a file if it exists)
+                result |= DesiredAccess.DELETE; // required by FILE_DELETE_ON_CLOSE
             }
 
             return result;

src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtQueryInformationFile.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Win32.SafeHandles;
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop

src/libraries/Common/src/Interop/Windows/NtDll/Interop.NtStatus.cs

@@ -17,5 +17,7 @@ internal static class StatusOptions
         internal const uint STATUS_ACCOUNT_RESTRICTION    = 0xC000006E;
         internal const uint STATUS_NONE_MAPPED            = 0xC0000073;
         internal const uint STATUS_INSUFFICIENT_RESOURCES = 0xC000009A;
+        internal const uint STATUS_DISK_FULL = 0xC000007F;
+        internal const uint STATUS_FILE_TOO_LARGE = 0xC0000904;
     }
 }

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

@@ -36,6 +36,8 @@
 #cmakedefine01 HAVE_POSIX_ADVISE
 #cmakedefine01 HAVE_POSIX_FALLOCATE
 #cmakedefine01 HAVE_POSIX_FALLOCATE64
+#cmakedefine01 HAVE_PREADV
+#cmakedefine01 HAVE_PWRITEV
 #cmakedefine01 PRIORITY_REQUIRES_INT_WHO
 #cmakedefine01 KEVENT_REQUIRES_INT_PARAMS
 #cmakedefine01 HAVE_IOCTL

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

@@ -242,6 +242,10 @@ static const Entry s_sysNative[] =
     DllImportEntry(SystemNative_iOSSupportVersion)
     DllImportEntry(SystemNative_GetErrNo)
     DllImportEntry(SystemNative_SetErrNo)
+    DllImportEntry(SystemNative_PRead)
+    DllImportEntry(SystemNative_PWrite)
+    DllImportEntry(SystemNative_PReadV)
+    DllImportEntry(SystemNative_PWriteV)
 };
 
 EXTERN_C const void* SystemResolveDllImport(const char* name);

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

@@ -22,6 +22,7 @@
 #include <sys/file.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <sys/uio.h>
 #include <syslog.h>
 #include <termios.h>
 #include <unistd.h>
@@ -1454,3 +1455,101 @@ int32_t SystemNative_ReadProcessStatusInfo(pid_t pid, ProcessStatus* processStat
     return -1;
 #endif // __sun
 }
+
+int32_t SystemNative_PRead(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset)
+{
+    assert(buffer != NULL);
+    assert(bufferSize >= 0);
+
+    ssize_t count;
+    while ((count = pread(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize, (off_t)fileOffset)) < 0 && errno == EINTR);
+
+    assert(count >= -1 && count <= bufferSize);
+    return (int32_t)count;
+}
+
+int32_t SystemNative_PWrite(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset)
+{
+    assert(buffer != NULL);
+    assert(bufferSize >= 0);
+
+    ssize_t count;
+    while ((count = pwrite(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize, (off_t)fileOffset)) < 0 && errno == EINTR);
+
+    assert(count >= -1 && count <= bufferSize);
+    return (int32_t)count;
+}
+
+int64_t SystemNative_PReadV(intptr_t fd, struct iovec* vectors, int32_t vectorCount, int64_t fileOffset)
+{
+    assert(vectors != NULL);
+    assert(vectorCount >= 0);
+
+    ssize_t count = 0;
+    int fileDescriptor = ToFileDescriptor(fd);
+#if HAVE_PREADV
+    while ((count = preadv(fileDescriptor, vectors, (int)vectorCount, (off_t)fileOffset)) < 0 && errno == EINTR);
+#else
+    ssize_t current;
+    for (int i = 0; i < vectorCount; i++)
+    {
+        struct iovec vector = vectors[i];
+        while ((current = pread(fileDescriptor, vector.iov_base, vector.iov_len, (off_t)(fileOffset + count))) < 0 && errno == EINTR);
+
+        if (current < 0)
+        {
+            // if previous calls were succesfull, we return what we got so far
+            // otherwise, we return the error code
+            return count > 0 ? count : current;
+        }
+
+        count += current;
+
+        // we stop on the first incomplete operation (the next call would fail)
+        if (current != vector.iov_len)
+        {
+            return (int64_t)count;
+        }
+    }
+#endif
+
+    assert(count >= -1);
+    return (int64_t)count;
+}
+
+int64_t SystemNative_PWriteV(intptr_t fd, struct iovec* vectors, int32_t vectorCount, int64_t fileOffset)
+{
+    assert(vectors != NULL);
+    assert(vectorCount >= 0);
+
+    ssize_t count = 0;
+    int fileDescriptor = ToFileDescriptor(fd);
+#if HAVE_PWRITEV
+    while ((count = pwritev(fileDescriptor, vectors, (int)vectorCount, (off_t)fileOffset)) < 0 && errno == EINTR);
+#else
+    ssize_t current;
+    for (int i = 0; i < vectorCount; i++)
+    {
+        struct iovec vector = vectors[i];
+        while ((current = pwrite(fileDescriptor, vector.iov_base, vector.iov_len, (off_t)(fileOffset + count))) < 0 && errno == EINTR);
+
+        if (current < 0)
+        {
+            // if previous calls were succesfull, we return what we got so far
+            // otherwise, we return the error code
+            return count > 0 ? count : current;
+        }
+
+        count += current;
+
+        // we stop on the first incomplete operation (the next call would fail)
+        if (current != vector.iov_len)
+        {
+            return (int64_t)count;
+        }
+    }
+#endif
+
+    assert(count >= -1);
+    return (int64_t)count;
+}

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

@@ -730,3 +730,31 @@ PALEXPORT int32_t SystemNative_LChflagsCanSetHiddenFlag(void);
  * Returns 1 if the process status was read; otherwise, 0.
  */
 PALEXPORT int32_t SystemNative_ReadProcessStatusInfo(pid_t pid, ProcessStatus* processStatus);
+
+/**
+ * Reads the number of bytes specified into the provided buffer from the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes read on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int32_t SystemNative_PRead(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset);
+
+/**
+ * Writes the number of bytes specified in the buffer into the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes written on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int32_t SystemNative_PWrite(intptr_t fd, void* buffer, int32_t bufferSize, int64_t fileOffset);
+
+/**
+ * Reads the number of bytes specified into the provided buffers from the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes read on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int64_t SystemNative_PReadV(intptr_t fd, struct iovec* vectors, int32_t vectorCount, int64_t fileOffset);
+
+/**
+ * Writes the number of bytes specified in the buffers into the specified, opened file descriptor at specified offset.
+ *
+ * Returns the number of bytes written on success; otherwise, -1 is returned an errno is set.
+ */
+PALEXPORT int64_t SystemNative_PWriteV(intptr_t fd, struct iovec* vectors, int32_t vectorCount, int64_t fileOffset);

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

@@ -276,7 +276,7 @@ typedef struct
 } LingerOption;
 
 // NOTE: the layout of this type is intended to exactly  match the layout of a `struct iovec`. There are
-//       assertions in pal_networking.cpp that validate this.
+//       assertions in pal_networking.c that validate this.
 typedef struct
 {
     uint8_t* Base;

src/libraries/Native/Unix/configure.cmake

@@ -219,6 +219,16 @@ check_symbol_exists(
     fcntl.h
     HAVE_POSIX_FALLOCATE64)
 
+check_symbol_exists(
+    preadv
+    sys/uio.h
+    HAVE_PREADV)
+
+check_symbol_exists(
+    pwritev
+    sys/uio.h
+    HAVE_PWRITEV)
+
 check_symbol_exists(
     ioctl
     sys/ioctl.h

src/libraries/System.IO.FileSystem/ref/System.IO.FileSystem.Forwards.cs

@@ -16,6 +16,7 @@
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.MatchCasing))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.MatchType))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.SearchOption))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.RandomAccess))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Enumeration.FileSystemEntry))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Enumeration.FileSystemEnumerable<>))]
 [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.Enumeration.FileSystemEnumerator<>))]