Clone files on OSX-like platforms when possible, instead of copying the whole file

src/libraries/Common/src/Interop/OSX/Interop.libc.cs

@@ -44,5 +44,10 @@ internal static unsafe int fsetattrlist(SafeHandle handle, AttrList* attrList, v
                     handle.DangerousRelease();
             }
         }
+
+        [LibraryImport(Libraries.libc, EntryPoint = "clonefile", StringMarshalling = StringMarshalling.Utf8, SetLastError = true)]
+        internal static unsafe partial int clonefile(string src, string dst, int flags);
+
+        internal const int CLONE_ACL = 0x0004;
     }
 }

src/libraries/System.IO.FileSystem/tests/File/Copy.cs

@@ -352,6 +352,19 @@ public void WindowsAlternateDataStreamOverwrite(string defaultStream, string alt
             Assert.Throws<IOException>(() => Copy(testFileAlternateStream, testFile2 + alternateStream, overwrite: true));
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsFileLockingEnabled))]
+        public void CopyOntoLockedFile()
+        {
+            string testFileSource = GetTestFilePath();
+            string testFileDest = GetTestFilePath();
+            File.Create(testFileSource).Dispose();
+            File.Create(testFileDest).Dispose();
+            using (var stream = new FileStream(testFileDest, FileMode.Open, FileAccess.Read, FileShare.None))
+            {
+                Assert.Throws<IOException>(() => Copy(testFileSource, testFileDest, overwrite: true));
+            }
+        }
+
         [Fact]
         public void DestinationFileIsTruncatedWhenItsLargerThanSourceFile()
         {

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

@@ -2373,6 +2373,7 @@
   </ItemGroup>
   <ItemGroup Condition="('$(TargetsUnix)' == 'true' or '$(TargetsBrowser)' == 'true' or '$(TargetsWasi)' == 'true') and '$(IsOSXLike)' != 'true'">
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileStatus.SetTimes.OtherUnix.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileSystem.TryCloneFile.OtherUnix.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetEUid.cs" Link="Common\Interop\Unix\Interop.GetEUid.cs" />
@@ -2427,6 +2428,7 @@
       <Link>Common\Interop\OSX\Interop.libc.cs</Link>
     </Compile>
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileStatus.SetTimes.OSX.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\IO\FileSystem.TryCloneFile.OSX.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsiOSLike)' == 'true' or '$(IsOSXLike)' == 'true'">
     <Compile Include="$(CommonPath)Interop\OSX\System.Native\Interop.SearchPath.cs">

src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.TryCloneFile.OSX.cs

@@ -0,0 +1,87 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Win32.SafeHandles;
+using System.Diagnostics;
+
+namespace System.IO
+{
+    internal static partial class FileSystem
+    {
+        private static bool TryCloneFile(string sourceFullPath, string destFullPath, bool overwrite)
+        {
+            // Try to clone the file immediately, this will only succeed if the
+            // destination doesn't exist, so we don't worry about locking for this one.
+            int flags = Interop.@libc.CLONE_ACL;
+            retry1:
+            if (Interop.@libc.clonefile(sourceFullPath, destFullPath, flags) == 0)
+            {
+                // Success.
+                return true;
+            }
+            Interop.Error error = Interop.Sys.GetLastError();
+
+            // Some filesystems don't support ACLs, so may fail due to trying to copy ACLs.
+            // This will disable them and allow trying again (a maximum of 1 time).
+            if (flags != 0 && error == Interop.Error.EINVAL)
+            {
+                flags = 0;
+                goto retry1;
+            }
+
+            // Try to delete the destination file if we're overwriting.
+            if (error == Interop.Error.EEXIST && overwrite)
+            {
+                // Delete the destination. This should fail on directories. Get a lock to the dest file to ensure we don't copy onto it when
+                // it's locked by something else, and then delete it. It should also fail if destination == source since it's already locked.
+                try
+                {
+                    using SafeFileHandle? dstHandle = SafeFileHandle.Open(destFullPath, FileMode.Open, FileAccess.ReadWrite,
+                        FileShare.None, FileOptions.None, preallocationSize: 0);
+                    if (Interop.Sys.Unlink(destFullPath) < 0)
+                    {
+                        Interop.Error errorInfo = Interop.Sys.GetLastError();
+                        if (error != Interop.Error.ENOENT)
+                        {
+                            // Fall back to standard copy as an unexpected error has occured.
+                            return false;
+                        }
+                    }
+                }
+                catch (FileNotFoundException)
+                {
+                    // We don't want to throw if it's just the file not existing, since we're trying to delete it.
+                }
+
+                // Try clonefile now we've deleted the destination file.
+                retry2:
+                if (Interop.@libc.clonefile(sourceFullPath, destFullPath, flags) == 0)
+                {
+                    // Success.
+                    return true;
+                }
+                error = Interop.Sys.GetLastError();
+
+                // Some filesystems don't support ACLs, so may fail due to trying to copy ACLs.
+                // This will disable them and allow trying again (a maximum of 1 time).
+                if (flags != 0 && error == Interop.Error.EINVAL)
+                {
+                    flags = 0;
+                    goto retry2;
+                }
+            }
+
+            // Check if it's not supported, if they're on different filesystems, the destination file still exists, or if we have unsupported flags still.
+            // EINVAL is checked again here since clonefile is implemented by filesystem-specific drivers, therefore it could potentially fail with flags=0.
+            if (error == Interop.Error.ENOTSUP || error == Interop.Error.EXDEV || error == Interop.Error.EEXIST || error == Interop.Error.EINVAL)
+            {
+                // Fall back to normal copy.
+                return false;
+            }
+
+            // Throw the appropriate exception.
+            Debug.Assert(error != Interop.Error.SUCCESS); // We shouldn't fail with success.
+            throw Interop.GetExceptionForIoErrno(error.Info());
+        }
+    }
+}

src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.TryCloneFile.OtherUnix.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.
+
+namespace System.IO
+{
+    internal static partial class FileSystem
+    {
+#pragma warning disable IDE0060 // Remove unused parameter
+         private static bool TryCloneFile(string sourceFullPath, string destFullPath, bool overwrite)
+#pragma warning restore IDE0060 // Remove unused parameter
+         {
+            // No such functionality is available on unix OSes (other than OSX-like ones).
+            return false;
+         }
+    }
+}

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

@@ -33,6 +33,13 @@ public static void CopyFile(string sourceFullPath, string destFullPath, bool ove
             long fileLength;
             UnixFileMode filePermissions;
             using SafeFileHandle src = SafeFileHandle.OpenReadOnly(sourceFullPath, FileOptions.None, out fileLength, out filePermissions);
+
+            // Try to clone the file first.
+            if (TryCloneFile(sourceFullPath, destFullPath, overwrite))
+            {
+                return;
+            }
+
             using SafeFileHandle dst = SafeFileHandle.Open(destFullPath, overwrite ? FileMode.Create : FileMode.CreateNew,
                                             FileAccess.ReadWrite, FileShare.None, FileOptions.None, preallocationSize: 0, filePermissions,
                                             CreateOpenException);