454 lines
20 KiB
Diff
454 lines
20 KiB
Diff
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();
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
}
|