Add UnixFileStreamStrategy

src/libraries/System.IO.FileSystem/tests/FileStream/WriteAsync.cs

@@ -179,11 +179,12 @@ public static IEnumerable<object[]> MemberData_FileStreamAsyncWriting()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] // Browser PNSE: Cannot wait on monitors
+        [PlatformSpecific(TestPlatforms.Windows)]
         public Task ManyConcurrentWriteAsyncs()
         {
             // For inner loop, just test one case
             return ManyConcurrentWriteAsyncs_OuterLoop(
-                useAsync: OperatingSystem.IsWindows(),
+                useAsync: true,
                 presize: false,
                 exposeHandle: false,
                 cancelable: true,
@@ -193,6 +194,7 @@ public Task ManyConcurrentWriteAsyncs()
         }
 
         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
+        [PlatformSpecific(TestPlatforms.Windows)] // testing undocumented feature that's legacy in the Windows implementation
         [MemberData(nameof(MemberData_FileStreamAsyncWriting))]
         [OuterLoop] // many combinations: we test just one in inner loop and the rest outer
         public async Task ManyConcurrentWriteAsyncs_OuterLoop(

src/libraries/System.IO.FileSystem/tests/Net5CompatTests/System.IO.FileSystem.Net5Compat.Tests.csproj

@@ -1,9 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
-    <!-- Windows is currently the only OS for which we provide a new strategy, so we test the Net5Compat only for Windows -->
-    <TargetFrameworks>$(NetCoreAppCurrent)-windows</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix</TargetFrameworks>
 
     <WasmXHarnessMonoArgs>--working-dir=/test-dir</WasmXHarnessMonoArgs>
   </PropertyGroup>

src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.ThreadPoolValueTaskSource.cs

@@ -21,17 +21,12 @@ public sealed partial class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
         internal ThreadPoolValueTaskSource GetThreadPoolValueTaskSource() =>
             Interlocked.Exchange(ref _reusableThreadPoolValueTaskSource, null) ?? new ThreadPoolValueTaskSource(this);
 
-        private void TryToReuse(ThreadPoolValueTaskSource source)
-        {
-            Interlocked.CompareExchange(ref _reusableThreadPoolValueTaskSource, source, null);
-        }
-
         /// <summary>
         /// A reusable <see cref="IValueTaskSource"/> implementation that
         /// queues asynchronous <see cref="RandomAccess"/> operations to
         /// be completed synchronously on the thread pool.
         /// </summary>
-        internal sealed class ThreadPoolValueTaskSource : IThreadPoolWorkItem, IValueTaskSource<int>, IValueTaskSource<long>
+        internal sealed class ThreadPoolValueTaskSource : IThreadPoolWorkItem, IValueTaskSource<int>, IValueTaskSource<long>, IValueTaskSource
         {
             private readonly SafeFileHandle _fileHandle;
             private ManualResetValueTaskSourceCore<long> _source;
@@ -68,7 +63,7 @@ private long GetResultAndRelease(short token)
                 finally
                 {
                     _source.Reset();
-                    _fileHandle.TryToReuse(this);
+                    Volatile.Write(ref _fileHandle._reusableThreadPoolValueTaskSource, this);
                 }
             }
 
@@ -77,6 +72,7 @@ public void OnCompleted(Action<object?> continuation, object? state, short token
                 _source.OnCompleted(continuation, state, token, flags);
             int IValueTaskSource<int>.GetResult(short token) => (int) GetResultAndRelease(token);
             long IValueTaskSource<long>.GetResult(short token) => GetResultAndRelease(token);
+            void IValueTaskSource.GetResult(short token) => GetResultAndRelease(token);
 
             private void ExecuteInternal()
             {

src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.IO.Strategies;
+using System.Threading;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -28,6 +29,10 @@ private SafeFileHandle(bool ownsHandle)
 
         internal bool CanSeek => !IsClosed && GetCanSeek();
 
+        internal ThreadPoolBoundHandle? ThreadPoolBinding => null;
+
+        internal void EnsureThreadPoolBindingInitialized() { /* nop */ }
+
         /// <summary>Opens the specified file with the requested flags and mode.</summary>
         /// <param name="path">The path to the file.</param>
         /// <param name="flags">The flags with which to open the file.</param>

src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Windows.cs

@@ -24,8 +24,6 @@ public SafeFileHandle() : base(true)
 
         internal bool CanSeek => !IsClosed && GetFileType() == Interop.Kernel32.FileTypes.FILE_TYPE_DISK;
 
-        internal bool IsPipe => GetFileType() == Interop.Kernel32.FileTypes.FILE_TYPE_PIPE;
-
         internal ThreadPoolBoundHandle? ThreadPoolBinding { get; set; }
 
         internal static unsafe SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -459,6 +459,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\FileStreamHelpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\FileStreamStrategy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\OSFileStreamStrategy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IObservable.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IObserver.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IProgress.cs" />
@@ -1813,7 +1814,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.CompletionSource.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\SyncWindowsFileStreamStrategy.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\WindowsFileStreamStrategy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\PasteArguments.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Loader\LibraryNameVariation.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\MemoryFailPoint.Windows.cs" />
@@ -2084,8 +2084,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Enumeration\FileSystemEnumerator.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\FileStreamHelpers.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.Unix.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.Lock.OSX.cs" Condition="'$(IsOSXLike)' == 'true'" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\Net5CompatFileStreamStrategy.Lock.Unix.cs" Condition="'$(IsOSXLike)' != 'true'" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\Strategies\UnixFileStreamStrategy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\PasteArguments.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Loader\LibraryNameVariation.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\MemoryFailPoint.Unix.cs" />

src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs

@@ -479,10 +479,17 @@ public override long Position
 
         public override ValueTask DisposeAsync() => _strategy.DisposeAsync();
 
-        public override void CopyTo(Stream destination, int bufferSize) => _strategy.CopyTo(destination, bufferSize);
+        public override void CopyTo(Stream destination, int bufferSize)
+        {
+            ValidateCopyToArguments(destination, bufferSize);
+            _strategy.CopyTo(destination, bufferSize);
+        }
 
         public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
-            => _strategy.CopyToAsync(destination, bufferSize, cancellationToken);
+        {
+            ValidateCopyToArguments(destination, bufferSize);
+            return _strategy.CopyToAsync(destination, bufferSize, cancellationToken);
+        }
 
         public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
         {

src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Unix.cs

@@ -28,7 +28,12 @@ internal static unsafe int ReadAtOffset(SafeFileHandle handle, Span<byte> buffer
         {
             fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer))
             {
-                int result = Interop.Sys.PRead(handle, bufPtr, buffer.Length, fileOffset);
+                // The Windows implementation uses ReadFile, which ignores the offset if the handle
+                // isn't seekable.  We do the same manually with PRead vs Read, in order to enable
+                // the function to be used by FileStream for all the same situations.
+                int result = handle.CanSeek ?
+                    Interop.Sys.PRead(handle, bufPtr, buffer.Length, fileOffset) :
+                    Interop.Sys.Read(handle, bufPtr, buffer.Length);
                 FileStreamHelpers.CheckFileCall(result, handle.Path);
                 return result;
             }
@@ -67,7 +72,7 @@ internal static unsafe long ReadScatterAtOffset(SafeFileHandle handle, IReadOnly
             return FileStreamHelpers.CheckFileCall(result, handle.Path);
         }
 
-        private static ValueTask<int> ReadAtOffsetAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
+        internal static ValueTask<int> ReadAtOffsetAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
             => ScheduleSyncReadAtOffsetAsync(handle, buffer, fileOffset, cancellationToken);
 
         private static ValueTask<long> ReadScatterAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers,
@@ -78,9 +83,14 @@ internal static unsafe int WriteAtOffset(SafeFileHandle handle, ReadOnlySpan<byt
         {
             fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer))
             {
-                int result = Interop.Sys.PWrite(handle, bufPtr, buffer.Length, fileOffset);
+                // The Windows implementation uses WriteFile, which ignores the offset if the handle
+                // isn't seekable.  We do the same manually with PWrite vs Write, in order to enable
+                // the function to be used by FileStream for all the same situations.
+                int result = handle.CanSeek ?
+                    Interop.Sys.PWrite(handle, bufPtr, buffer.Length, fileOffset) :
+                    Interop.Sys.Write(handle, bufPtr, buffer.Length);
                 FileStreamHelpers.CheckFileCall(result, handle.Path);
-                return  result;
+                return result;
             }
         }
 
@@ -117,7 +127,7 @@ internal static unsafe long WriteGatherAtOffset(SafeFileHandle handle, IReadOnly
             return FileStreamHelpers.CheckFileCall(result, handle.Path);
         }
 
-        private static ValueTask<int> WriteAtOffsetAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
+        internal static ValueTask<int> WriteAtOffsetAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken)
             => ScheduleSyncWriteAtOffsetAsync(handle, buffer, fileOffset, cancellationToken);
 
         private static ValueTask<long> WriteGatherAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers,

src/libraries/System.Private.CoreLib/src/System/IO/Strategies/AsyncWindowsFileStreamStrategy.cs

@@ -8,7 +8,7 @@
 
 namespace System.IO.Strategies
 {
-    internal sealed partial class AsyncWindowsFileStreamStrategy : WindowsFileStreamStrategy
+    internal sealed partial class AsyncWindowsFileStreamStrategy : OSFileStreamStrategy
     {
         internal AsyncWindowsFileStreamStrategy(SafeFileHandle handle, FileAccess access, FileShare share)
             : base(handle, access, share)
@@ -98,12 +98,8 @@ private Exception HandleIOError(long positionBefore, int errorCode)
             return SafeFileHandle.OverlappedValueTaskSource.GetIOError(errorCode, _fileHandle.Path);
         }
 
-        public override Task FlushAsync(CancellationToken cancellationToken) => Task.CompletedTask; // no buffering = nothing to flush
-
         public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
         {
-            ValidateCopyToArguments(destination, bufferSize);
-
             // Fail if the file was closed
             if (_fileHandle.IsClosed)
             {

src/libraries/System.Private.CoreLib/src/System/IO/Strategies/BufferedFileStreamStrategy.cs

@@ -247,7 +247,7 @@ private int ReadSpan(Span<byte> destination, ArraySegment<byte> arraySegment)
 
             // If we are reading from a device with no clear EOF like a
             // serial port or a pipe, this will cause us to block incorrectly.
-            if (!_strategy.IsPipe)
+            if (_strategy.CanSeek)
             {
                 // If we hit the end of the buffer and didn't have enough bytes, we must
                 // read some more from the underlying stream.  However, if we got
@@ -340,9 +340,9 @@ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken
             Debug.Assert((_readPos == 0 && _readLen == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLen),
                 "We're either reading or writing, but not both.");
 
-            if (_strategy.IsPipe) // pipes have a very limited support for buffering
+            if (!_strategy.CanSeek)
             {
-                return ReadFromPipeAsync(buffer, cancellationToken);
+                return ReadFromNonSeekableAsync(buffer, cancellationToken);
             }
 
             SemaphoreSlim semaphore = EnsureAsyncActiveSemaphoreInitialized();
@@ -383,9 +383,9 @@ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken
             return ReadAsyncSlowPath(semaphoreLockTask, buffer, cancellationToken);
         }
 
-        private async ValueTask<int> ReadFromPipeAsync(Memory<byte> destination, CancellationToken cancellationToken)
+        private async ValueTask<int> ReadFromNonSeekableAsync(Memory<byte> destination, CancellationToken cancellationToken)
         {
-            Debug.Assert(_strategy.IsPipe);
+            Debug.Assert(!_strategy.CanSeek);
 
             // Employ async waiting based on the same synchronization used in BeginRead of the abstract Stream.
             await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(false);
@@ -426,7 +426,7 @@ private async ValueTask<int> ReadFromPipeAsync(Memory<byte> destination, Cancell
         private async ValueTask<int> ReadAsyncSlowPath(Task semaphoreLockTask, Memory<byte> buffer, CancellationToken cancellationToken)
         {
             Debug.Assert(_asyncActiveSemaphore != null);
-            Debug.Assert(!_strategy.IsPipe);
+            Debug.Assert(_strategy.CanSeek);
 
             // Employ async waiting based on the same synchronization used in BeginRead of the abstract Stream.
             await semaphoreLockTask.ConfigureAwait(false);
@@ -633,13 +633,13 @@ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationTo
             Debug.Assert(!_strategy.IsClosed, "FileStream ensures that strategy is not closed");
             Debug.Assert((_readPos == 0 && _readLen == 0 && _writePos >= 0) || (_writePos == 0 && _readPos <= _readLen),
                 "We're either reading or writing, but not both.");
-            Debug.Assert(!_strategy.IsPipe || (_readPos == 0 && _readLen == 0),
+            Debug.Assert(_strategy.CanSeek || (_readPos == 0 && _readLen == 0),
                 "Win32FileStream must not have buffered data here!  Pipes should be unidirectional.");
 
-            if (_strategy.IsPipe)
+            if (!_strategy.CanSeek)
             {
                 // avoid async buffering with pipes, as doing so can lead to deadlocks (see comments in ReadFromPipeAsync)
-                return WriteToPipeAsync(buffer, cancellationToken);
+                return WriteToNonSeekableAsync(buffer, cancellationToken);
             }
 
             SemaphoreSlim semaphore = EnsureAsyncActiveSemaphoreInitialized();
@@ -690,9 +690,9 @@ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationTo
             return WriteAsyncSlowPath(semaphoreLockTask, buffer, cancellationToken);
         }
 
-        private async ValueTask WriteToPipeAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
+        private async ValueTask WriteToNonSeekableAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
         {
-            Debug.Assert(_strategy.IsPipe);
+            Debug.Assert(!_strategy.CanSeek);
 
             await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(false);
             try
@@ -708,7 +708,7 @@ private async ValueTask WriteToPipeAsync(ReadOnlyMemory<byte> source, Cancellati
         private async ValueTask WriteAsyncSlowPath(Task semaphoreLockTask, ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
         {
             Debug.Assert(_asyncActiveSemaphore != null);
-            Debug.Assert(!_strategy.IsPipe);
+            Debug.Assert(_strategy.CanSeek);
 
             await semaphoreLockTask.ConfigureAwait(false);
             try
@@ -878,7 +878,6 @@ private async Task FlushAsyncInternal(CancellationToken cancellationToken)
 
         public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
         {
-            ValidateCopyToArguments(destination, bufferSize);
             EnsureNotClosed();
             EnsureCanRead();
 
@@ -921,7 +920,6 @@ private async Task CopyToAsyncCore(Stream destination, int bufferSize, Cancellat
 
         public override void CopyTo(Stream destination, int bufferSize)
         {
-            ValidateCopyToArguments(destination, bufferSize);
             EnsureNotClosed();
             EnsureCanRead();