use fstatfs to detect whether current file system supports shared loc…

…ks for files opened for writing

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

@@ -0,0 +1,14 @@
+// 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;
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetFileSystemType")]
+        internal static extern long GetFileSystemType(SafeFileHandle fd);
+    }
+}

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

@@ -5,6 +5,8 @@
 #cmakedefine01 HAVE_MMAP64
 #cmakedefine01 HAVE_FTRUNCATE64
 #cmakedefine01 HAVE_POSIX_FADVISE64
+#cmakedefine01 HAVE_STATFS64
+#cmakedefine01 HAVE_STATFS
 #cmakedefine01 HAVE_FLOCK64
 #cmakedefine01 HAVE_F_DUPFD_CLOEXEC
 #cmakedefine01 HAVE_F_FULLFSYNC

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

@@ -103,6 +103,7 @@ static const Entry s_sysNative[] =
     DllImportEntry(SystemNative_INotifyRemoveWatch)
     DllImportEntry(SystemNative_RealPath)
     DllImportEntry(SystemNative_GetPeerID)
+    DllImportEntry(SystemNative_GetFileSystemType)
     DllImportEntry(SystemNative_LockFileRegion)
     DllImportEntry(SystemNative_LChflags)
     DllImportEntry(SystemNative_LChflagsCanSetHiddenFlag)

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

@@ -35,6 +35,9 @@
 #if HAVE_INOTIFY
 #include <sys/inotify.h>
 #endif
+#if HAVE_STATFS64 || HAVE_STATFS
+#include <sys/vfs.h>
+#endif
 
 #ifdef _AIX
 #include <alloca.h>
@@ -1379,6 +1382,19 @@ static int16_t ConvertLockType(int16_t managedLockType)
     }
 }
 
+int64_t SystemNative_GetFileSystemType(intptr_t fd)
+{
+#if HAVE_STATFS64
+    struct statfs64 statfsArgs;
+    return fstatfs64(ToFileDescriptor(fd), &statfsArgs) == -1 ? -1 : statfsArgs.f_type;
+#elif HAVE_STATFS
+    struct statfs statfsArgs;
+    return fstatfs(ToFileDescriptor(fd), &statfsArgs) == -1 ? -1 : statfsArgs.f_type;
+#else
+    return 0;
+#endif
+}
+
 int32_t SystemNative_LockFileRegion(intptr_t fd, int64_t offset, int64_t length, int16_t lockType)
 {
     int16_t unixLockType = ConvertLockType(lockType);

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

@@ -710,6 +710,11 @@ PALEXPORT char* SystemNative_RealPath(const char* path);
 */
 PALEXPORT int32_t SystemNative_GetPeerID(intptr_t socket, uid_t* euid);
 
+/**
+* returns false for NFS and CIFS, otherwise true
+*/
+PALEXPORT int64_t SystemNative_GetFileSystemType(intptr_t fd);
+
 /**
 * Attempts to lock/unlock the region of the file "fd" specified by the offset and length. lockType
 * can be set to F_UNLCK (2) for unlock or F_WRLCK (3) for lock.

src/libraries/Native/Unix/configure.cmake

@@ -108,6 +108,28 @@ check_c_source_compiles(
 
 # /in_pktinfo
 
+check_c_source_compiles(
+    "
+    #include <sys/vfs.h>
+    int main(void)
+    {
+        struct statfs64 s;
+        return 0;
+    }
+    "
+    HAVE_STATFS64)
+
+check_c_source_compiles(
+    "
+    #include <sys/vfs.h>
+    int main(void)
+    {
+        struct statfs s;
+        return 0;
+    }
+    "
+    HAVE_STATFS)
+
 check_c_source_compiles(
     "
     #include <fcntl.h>

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

@@ -258,7 +258,7 @@ private void Init(string path, FileMode mode, FileAccess access, FileShare share
             // lock on the file and all other modes use a shared lock.  While this is not as granular as Windows, not mandatory,
             // and not atomic with file opening, it's better than nothing.
             Interop.Sys.LockOperations lockOperation = (share == FileShare.None) ? Interop.Sys.LockOperations.LOCK_EX : Interop.Sys.LockOperations.LOCK_SH;
-            if (Interop.Sys.FLock(this, lockOperation | Interop.Sys.LockOperations.LOCK_NB) < 0)
+            if (CanLockTheFile(lockOperation, access) && Interop.Sys.FLock(this, lockOperation | Interop.Sys.LockOperations.LOCK_NB) < 0)
             {
                 // The only error we care about is EWOULDBLOCK, which indicates that the file is currently locked by someone
                 // else and we would block trying to access it.  Other errors, such as ENOTSUP (locking isn't supported) or
@@ -319,6 +319,30 @@ private void Init(string path, FileMode mode, FileAccess access, FileShare share
             }
         }
 
+        private bool CanLockTheFile(Interop.Sys.LockOperations lockOperation, FileAccess access)
+        {
+            Debug.Assert(lockOperation == Interop.Sys.LockOperations.LOCK_EX || lockOperation == Interop.Sys.LockOperations.LOCK_SH);
+
+            if (lockOperation == Interop.Sys.LockOperations.LOCK_EX)
+            {
+                return true; // LOCK_EX is always OK
+            }
+            else if ((access & FileAccess.Write) == 0)
+            {
+                return true; // LOCK_SH is always OK when reading
+            }
+
+            switch (Interop.Sys.GetFileSystemType(this))
+            {
+                case 0x6969: // NFS_SUPER_MAGIC
+                case 0xFF534D42: // CIFS_MAGIC_NUMBER
+                case 0x517B: // SMB_SUPER_MAGIC
+                    return false; // LOCK_SH is not OK when writing to NFS, CIFS or SMB
+                default:
+                    return true; // in all other situations it should be OK
+            }
+        }
+
         private bool GetCanSeek()
         {
             Debug.Assert(!IsClosed);

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

@@ -1910,6 +1910,9 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ErrNo.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.ErrNo.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Fstatfs.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.Fstatfs.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.FLock.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.FLock.cs</Link>
     </Compile>