Fix named mutex workaround for .NET Mono runtime

* Enable named mutex workaround when running on .NET using Mono runtime

* Re-implement file locking logic to ensure intra- and inter-process
  mutual exclusion, and no longer leak lock files

* Use mutex abstraction throughout test suite

* Fix async race in ServerFailsWithLongTempPathUnix test case

* Fixes #57002

Author: uweigand

src/Compilers/Core/Portable/InternalUtilities/PlatformInformation.cs

@@ -31,5 +31,22 @@ public static bool IsRunningOnMono
                 }
             }
         }
+        // Are we running on .NET 5 or later using the Mono runtime?
+        // Will also return true when running on Mono itself; if necessary
+        // we can use the above IsRunningOnMono to distinguish.
+        public static bool IsUsingMonoRuntime
+        {
+            get
+            {
+                try
+                {
+                    return !(Type.GetType("Mono.RuntimeStructs") is null);
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
     }
 }

src/Compilers/Server/VBCSCompilerTests/BuildClientTests.cs

@@ -79,7 +79,7 @@ public void ConnectToServerFails()
                 // to connect. When it fails it should fall back to in-proc
                 // compilation.
                 bool holdsMutex;
-                using (var serverMutex = new Mutex(initiallyOwned: true,
+                using (var serverMutex = BuildServerConnection.OpenOrCreateMutex(
                                                    name: BuildServerConnection.GetServerMutexName(_pipeName),
                                                    createdNew: out holdsMutex))
                 {

src/Compilers/Server/VBCSCompilerTests/CompilerServerApiTest.cs

@@ -103,7 +103,7 @@ public void MutexStopsServerStarting()
             var mutexName = BuildServerConnection.GetServerMutexName(pipeName);
 
             bool holdsMutex;
-            using (var mutex = new Mutex(initiallyOwned: true,
+            using (var mutex = BuildServerConnection.OpenOrCreateMutex(
                                          name: mutexName,
                                          createdNew: out holdsMutex))
             {
@@ -119,7 +119,7 @@ public void MutexStopsServerStarting()
                 }
                 finally
                 {
-                    mutex.ReleaseMutex();
+                    mutex.Dispose();
                 }
             }
         }

src/Compilers/Server/VBCSCompilerTests/CompilerServerTests.cs

@@ -304,7 +304,7 @@ public async Task ServerFailsWithLongTempPathUnix()
             var newTempDir = _tempDirectory.CreateDirectory(new string('a', 100 - _tempDirectory.Path.Length));
             await ApplyEnvironmentVariables(
                 new[] { new KeyValuePair<string, string>("TMPDIR", newTempDir.Path) },
-                async () =>
+                async () => await Task.Run(async () =>
             {
                 using var serverData = await ServerUtil.CreateServer(_logger);
                 var result = RunCommandLineCompiler(
@@ -317,7 +317,7 @@ await ApplyEnvironmentVariables(
 
                 var listener = await serverData.Complete();
                 Assert.Equal(CompletionData.RequestCompleted, listener.CompletionDataList.Single());
-            });
+            }));
         }
 
         [Fact]

src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs

@@ -101,7 +101,7 @@ public async Task NoServerConnection()
 
                     var thread = new Thread(() =>
                     {
-                        using (var mutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out created))
+                        using (var mutex = BuildServerConnection.OpenOrCreateMutex(name: mutexName, createdNew: out created))
                         using (var stream = NamedPipeUtil.CreateServer(pipeName))
                         {
                             readyMre.Set();
@@ -112,7 +112,7 @@ public async Task NoServerConnection()
                             stream.Close();
 
                             doneMre.WaitOne();
-                            mutex.ReleaseMutex();
+                            mutex.Dispose();
                         }
                     });
 
@@ -153,15 +153,14 @@ public async Task ServerShutdownsDuringProcessing()
                     {
                         using (var stream = NamedPipeUtil.CreateServer(pipeName))
                         {
-                            var mutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out created);
+                            var mutex = BuildServerConnection.OpenOrCreateMutex(name: mutexName, createdNew: out created);
                             readyMre.Set();
 
                             stream.WaitForConnection();
                             connected = true;
 
                             // Client is waiting for a response.  Close the mutex now.  Then close the connection 
                             // so the client gets an error.
-                            mutex.ReleaseMutex();
                             mutex.Dispose();
                             stream.Close();
 

src/Compilers/Shared/BuildServerConnection.cs

@@ -543,19 +543,9 @@ internal static bool WasServerMutexOpen(string mutexName)
         {
             try
             {
-                if (PlatformInformation.IsRunningOnMono)
+                if (PlatformInformation.IsUsingMonoRuntime)
                 {
-                    IServerMutex? mutex = null;
-                    bool createdNew = false;
-                    try
-                    {
-                        mutex = new ServerFileMutexPair(mutexName, false, out createdNew);
-                        return !createdNew;
-                    }
-                    finally
-                    {
-                        mutex?.Dispose();
-                    }
+                    return ServerFileMutexPair.WasOpen(mutexName);
                 }
                 else
                 {
@@ -572,9 +562,9 @@ internal static bool WasServerMutexOpen(string mutexName)
 
         internal static IServerMutex OpenOrCreateMutex(string name, out bool createdNew)
         {
-            if (PlatformInformation.IsRunningOnMono)
+            if (PlatformInformation.IsUsingMonoRuntime)
             {
-                return new ServerFileMutexPair(name, initiallyOwned: true, out createdNew);
+                return new ServerFileMutexPair(name, out createdNew);
             }
             else
             {
@@ -648,16 +638,16 @@ internal interface IServerMutex : IDisposable
     }
 
     /// <summary>
-    /// An interprocess mutex abstraction based on OS advisory locking (FileStream.Lock/Unlock).
+    /// An interprocess mutex abstraction based on file sharing permission (FileShare.None).
     /// If multiple processes running as the same user create FileMutex instances with the same name,
     ///  those instances will all point to the same file somewhere in a selected temporary directory.
-    /// The TryLock method can be used to attempt to acquire the mutex, with Unlock or Dispose used to release.
+    /// The TryLock method can be used to attempt to acquire the mutex, with Dispose used to release.
     /// Unlike Win32 named mutexes, there is no mechanism for detecting an abandoned mutex. The file
     ///  will simply revert to being unlocked but remain where it is.
     /// </summary>
     internal sealed class FileMutex : IDisposable
     {
-        public readonly FileStream Stream;
+        public FileStream? Stream;
         public readonly string FilePath;
 
         public bool IsLocked { get; private set; }
@@ -673,7 +663,11 @@ internal static string GetMutexDirectory()
         public FileMutex(string name)
         {
             FilePath = Path.Combine(GetMutexDirectory(), name);
-            Stream = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
+        }
+
+        public bool WasOpen()
+        {
+            return File.Exists(FilePath);
         }
 
         public bool TryLock(int timeoutMs)
@@ -686,7 +680,7 @@ public bool TryLock(int timeoutMs)
             {
                 try
                 {
-                    Stream.Lock(0, 0);
+                    Stream = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
                     IsLocked = true;
                     return true;
                 }
@@ -709,22 +703,14 @@ public bool TryLock(int timeoutMs)
             return false;
         }
 
-        public void Unlock()
-        {
-            if (!IsLocked)
-                return;
-            Stream.Unlock(0, 0);
-            IsLocked = false;
-        }
-
         public void Dispose()
         {
-            var wasLocked = IsLocked;
-            if (wasLocked)
-                Unlock();
-            Stream.Dispose();
-            // We do not delete the lock file here because there is no reliable way to perform a
-            //  'delete if no one has the file open' operation atomically on *nix. This is a leak.
+            if (IsLocked)
+            {
+                File.Delete(FilePath);
+                Stream!.Dispose();
+            }
+            IsLocked = false;
         }
     }
 
@@ -806,18 +792,24 @@ internal sealed class ServerFileMutexPair : IServerMutex
 
         public bool IsDisposed { get; private set; }
 
-        public ServerFileMutexPair(string mutexName, bool initiallyOwned, out bool createdNew)
+        public ServerFileMutexPair(string mutexName, out bool createdNew)
         {
             AliveMutex = new FileMutex(mutexName + "-alive");
             HeldMutex = new FileMutex(mutexName + "-held");
             createdNew = AliveMutex.TryLock(0);
-            if (initiallyOwned && createdNew)
+            if (createdNew)
             {
                 if (!TryLock(0))
                     throw new Exception("Failed to lock mutex after creating it");
             }
         }
 
+        public static bool WasOpen(string mutexName)
+        {
+            var TestAliveMutex = new FileMutex(mutexName + "-alive");
+            return TestAliveMutex.WasOpen();
+	}
+
         public bool TryLock(int timeoutMs)
         {
             if (IsDisposed)
@@ -831,16 +823,8 @@ public void Dispose()
                 return;
             IsDisposed = true;
 
-            try
-            {
-                HeldMutex.Unlock();
-                AliveMutex.Unlock();
-            }
-            finally
-            {
-                AliveMutex.Dispose();
-                HeldMutex.Dispose();
-            }
+            HeldMutex.Dispose();
+            AliveMutex.Dispose();
         }
     }