diff options
Diffstat (limited to 'roslyn-57003-mono-named-mutex.patch')
| -rw-r--r-- | roslyn-57003-mono-named-mutex.patch | 453 |
1 files changed, 453 insertions, 0 deletions
diff --git a/roslyn-57003-mono-named-mutex.patch b/roslyn-57003-mono-named-mutex.patch new file mode 100644 index 0000000..c264bff --- /dev/null +++ b/roslyn-57003-mono-named-mutex.patch @@ -0,0 +1,453 @@ +Index: tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Core/Portable/InternalUtilities/PlatformInformation.cs +=================================================================== +--- tarball.6.0.1-rc2-6.0.100-rc2.orig/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Core/Portable/InternalUtilities/PlatformInformation.cs ++++ tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Core/Portable/InternalUtilities/PlatformInformation.cs +@@ -31,5 +31,24 @@ namespace Roslyn.Utilities + } + } + } ++ /// <summary> ++ /// 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 IsRunningOnMono to distinguish. ++ /// </summary> ++ public static bool IsUsingMonoRuntime ++ { ++ get ++ { ++ try ++ { ++ return !(Type.GetType("Mono.RuntimeStructs", throwOnError: false) is null); ++ } ++ catch ++ { ++ return false; ++ } ++ } ++ } + } + } +Index: tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/BuildClientTests.cs +=================================================================== +--- tarball.6.0.1-rc2-6.0.100-rc2.orig/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/BuildClientTests.cs ++++ tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/BuildClientTests.cs +@@ -79,7 +79,7 @@ namespace Microsoft.CodeAnalysis.Compile + // 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)) + { +Index: tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/CompilerServerApiTest.cs +=================================================================== +--- tarball.6.0.1-rc2-6.0.100-rc2.orig/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/CompilerServerApiTest.cs ++++ tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/CompilerServerApiTest.cs +@@ -103,7 +103,7 @@ class Hello + 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 @@ class Hello + } + finally + { +- mutex.ReleaseMutex(); ++ mutex.Dispose(); + } + } + } +Index: tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/CompilerServerTests.cs +=================================================================== +--- tarball.6.0.1-rc2-6.0.100-rc2.orig/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/CompilerServerTests.cs ++++ tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/CompilerServerTests.cs +@@ -304,7 +304,7 @@ End Module") + 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 @@ End Module") + + var listener = await serverData.Complete(); + Assert.Equal(CompletionData.RequestCompleted, listener.CompletionDataList.Single()); +- }); ++ })); + } + + [Fact] +Index: tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs +=================================================================== +--- tarball.6.0.1-rc2-6.0.100-rc2.orig/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs ++++ tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Server/VBCSCompilerTests/VBCSCompilerServerTests.cs +@@ -101,7 +101,7 @@ namespace Microsoft.CodeAnalysis.Compile + + 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 @@ namespace Microsoft.CodeAnalysis.Compile + stream.Close(); + + doneMre.WaitOne(); +- mutex.ReleaseMutex(); ++ mutex.Dispose(); + } + }); + +@@ -153,7 +153,7 @@ namespace Microsoft.CodeAnalysis.Compile + { + 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(); +@@ -161,7 +161,6 @@ namespace Microsoft.CodeAnalysis.Compile + + // 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(); + +Index: tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Shared/BuildServerConnection.cs +=================================================================== +--- tarball.6.0.1-rc2-6.0.100-rc2.orig/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Shared/BuildServerConnection.cs ++++ tarball.6.0.1-rc2-6.0.100-rc2/src/roslyn.8e1779e16298415843e85029d8b52a1ae9bb4c30/src/Compilers/Shared/BuildServerConnection.cs +@@ -543,19 +543,10 @@ namespace Microsoft.CodeAnalysis.Command + { + 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(); +- } ++ using var mutex = new ServerFileMutex(mutexName); ++ return !mutex.CouldLock(); + } + else + { +@@ -572,9 +563,11 @@ namespace Microsoft.CodeAnalysis.Command + + internal static IServerMutex OpenOrCreateMutex(string name, out bool createdNew) + { +- if (PlatformInformation.IsRunningOnMono) ++ if (PlatformInformation.IsUsingMonoRuntime) + { +- return new ServerFileMutexPair(name, initiallyOwned: true, out createdNew); ++ var mutex = new ServerFileMutex(name); ++ createdNew = mutex.TryLock(0); ++ return mutex; + } + else + { +@@ -648,19 +641,22 @@ namespace Microsoft.CodeAnalysis.Command + } + + /// <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. ++ /// The CouldLock method can be used to check whether an attempt to acquire the mutex would have ++ /// succeeded at the current time, without actually acquiring it. + /// 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 ++ internal sealed class ServerFileMutex : IServerMutex + { +- public readonly FileStream Stream; ++ public FileStream? Stream; + public readonly string FilePath; ++ public readonly string GuardPath; + +- public bool IsLocked { get; private set; } ++ public bool IsDisposed { get; private set; } + + internal static string GetMutexDirectory() + { +@@ -670,61 +666,176 @@ namespace Microsoft.CodeAnalysis.Command + return result; + } + +- public FileMutex(string name) ++ public ServerFileMutex(string name) + { +- FilePath = Path.Combine(GetMutexDirectory(), name); +- Stream = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); ++ var mutexDirectory = GetMutexDirectory(); ++ FilePath = Path.Combine(mutexDirectory, name); ++ GuardPath = Path.Combine(mutexDirectory, ".guard"); + } + +- public bool TryLock(int timeoutMs) ++ /// <summary> ++ /// Acquire the guard by opening the guard file with FileShare.None. The guard must only ever ++ /// be held for very brief amounts of time, so we can simply spin until it is acquired. The ++ /// guard must be released by disposing the FileStream returned from this routine. Note the ++ /// guard file is never deleted; this is a leak, but only of a single file. ++ /// </summary> ++ internal FileStream LockGuard() + { +- if (IsLocked) +- throw new InvalidOperationException("Lock already held"); +- +- var sw = Stopwatch.StartNew(); +- do ++ // We should be able to acquire the guard quickly. Limit the number of retries anyway ++ // by some arbitrary bound to avoid getting hung up in a possibly infinite loop. ++ for (var i = 0; i < 100; i++) + { + try + { +- Stream.Lock(0, 0); +- IsLocked = true; +- return true; ++ return new FileStream(GuardPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); + } + catch (IOException) + { +- // Lock currently held by someone else. ++ // Guard currently held by someone else. + // We want to sleep for a short period of time to ensure that other processes + // have an opportunity to finish their work and relinquish the lock. + // Spinning here (via Yield) would work but risks creating a priority + // inversion if the lock is held by a lower-priority process. + Thread.Sleep(1); + } ++ } ++ // Handle unexpected failure to acquire guard as error. ++ throw new InvalidOperationException("Unable to acquire guard"); ++ } ++ ++ /// <summary> ++ /// Attempt to acquire the lock by opening the lock file with FileShare.None. Sets "Stream" ++ /// and returns true if successful, returns false if the lock is already held by another ++ /// thread or process. Guard must be held when calling this routine. ++ /// </summary> ++ internal bool TryLockFile() ++ { ++ Debug.Assert(Stream is null); ++ FileStream? stream = null; ++ try ++ { ++ stream = new FileStream(FilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); ++ // On some targets, the file locking used to implement FileShare.None may not be ++ // atomic with opening/creating the file. This creates a race window when another ++ // thread holds the lock and is just about to unlock: we may be able to open the ++ // file here, then the other thread unlocks and deletes the file, and then we ++ // acquire the lock on our file handle - but the actual file is already deleted. ++ // To close this race, we verify that the file does in fact still exist now that ++ // we have successfull acquired the locked FileStream. (Note that this check is ++ // safe because we cannot race with an other attempt to create the file since we ++ // hold the guard, and after the FileStream constructor returned we can no race ++ // with file deletion because we hold the lock.) ++ if (!File.Exists(FilePath)) ++ { ++ // To simplify the logic, we treat this case as "unable to acquire the lock" ++ // because it we caught another process while it owned the lock and was just ++ // giving it up. If the caller retries, we'll likely acquire the lock then. ++ stream.Dispose(); ++ return false; ++ } ++ } ++ catch (Exception) ++ { ++ stream?.Dispose(); ++ return false; ++ } ++ Stream = stream; ++ return true; ++ } ++ ++ /// <summary> ++ /// Release the lock by deleting the lock file and disposing "Stream". ++ /// </summary> ++ internal void UnlockFile() ++ { ++ Debug.Assert(Stream is not null); ++ try ++ { ++ // Delete the lock file while the stream is not yet disposed ++ // and we therefore still hold the FileShare.None exclusion. ++ // There may still be a race with another thread attempting a ++ // TryLockFile in parallel, but that is safely handled there. ++ File.Delete(FilePath); ++ } ++ finally ++ { ++ Stream.Dispose(); ++ Stream = null; ++ } ++ } ++ ++ public bool TryLock(int timeoutMs) ++ { ++ if (IsDisposed) ++ throw new ObjectDisposedException("Mutex"); ++ if (Stream is not null) ++ throw new InvalidOperationException("Lock already held"); ++ ++ var sw = Stopwatch.StartNew(); ++ do ++ { ++ try ++ { ++ // Attempt to acquire lock while holding guard. ++ using var guard = LockGuard(); ++ if (TryLockFile()) ++ return true; ++ } + catch (Exception) + { +- // Something else went wrong. + return false; + } ++ ++ // See comment in LockGuard. ++ Thread.Sleep(1); + } while (sw.ElapsedMilliseconds < timeoutMs); + + return false; + } + +- public void Unlock() ++ public bool CouldLock() + { +- if (!IsLocked) +- return; +- Stream.Unlock(0, 0); +- IsLocked = false; ++ if (IsDisposed) ++ return false; ++ if (Stream is not null) ++ return false; ++ ++ try ++ { ++ // Attempt to acquire lock while holding guard, and if successful ++ // immediately unlock again while still holding guard. This ensures ++ // no other thread will spuriously observe the lock as held due to ++ // the lock attempt here. ++ using var guard = LockGuard(); ++ if (TryLockFile()) ++ { ++ UnlockFile(); ++ return true; ++ } ++ } ++ catch (Exception) ++ { ++ return false; ++ } ++ ++ return 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 (IsDisposed) ++ return; ++ IsDisposed = true; ++ if (Stream is not null) ++ { ++ try ++ { ++ UnlockFile(); ++ } ++ catch (Exception) ++ { ++ } ++ } + } + } + +@@ -792,56 +903,4 @@ namespace Microsoft.CodeAnalysis.Command + } + } + } +- +- /// <summary> +- /// Approximates a named mutex with 'locked', 'unlocked' and 'abandoned' states. +- /// There is no reliable way to detect whether a mutex has been abandoned on some target platforms, +- /// so we use the AliveMutex to manually track whether the creator of a mutex is still running, +- /// while the HeldMutex represents the actual lock state of the mutex. +- /// </summary> +- internal sealed class ServerFileMutexPair : IServerMutex +- { +- public readonly FileMutex AliveMutex; +- public readonly FileMutex HeldMutex; +- +- public bool IsDisposed { get; private set; } +- +- public ServerFileMutexPair(string mutexName, bool initiallyOwned, out bool createdNew) +- { +- AliveMutex = new FileMutex(mutexName + "-alive"); +- HeldMutex = new FileMutex(mutexName + "-held"); +- createdNew = AliveMutex.TryLock(0); +- if (initiallyOwned && createdNew) +- { +- if (!TryLock(0)) +- throw new Exception("Failed to lock mutex after creating it"); +- } +- } +- +- public bool TryLock(int timeoutMs) +- { +- if (IsDisposed) +- throw new ObjectDisposedException("Mutex"); +- return HeldMutex.TryLock(timeoutMs); +- } +- +- public void Dispose() +- { +- if (IsDisposed) +- return; +- IsDisposed = true; +- +- try +- { +- HeldMutex.Unlock(); +- AliveMutex.Unlock(); +- } +- finally +- { +- AliveMutex.Dispose(); +- HeldMutex.Dispose(); +- } +- } +- } +- + } |