private void HandleUnhandledFailure(LoggingContext loggingContext, Exception exception)
{
if (Interlocked.CompareExchange(ref m_handlingUnhandledFailureInProgress, 1, comparand: 0) != 0)
{
Thread.Sleep(TimeSpan.FromSeconds(3));
ExceptionUtilities.FailFast("Second-chance exception handler has not completed in the allowed time.", new InvalidOperationException());
return;
}
try
{
GeneratorExitCode effectiveExitCode = GeneratorExitCode.InternalError;
ExceptionRootCause rootCause = exception is NullReferenceException
? ExceptionRootCause.FailFast
: ExceptionUtilities.AnalyzeExceptionRootCause(exception);
switch (rootCause)
{
case ExceptionRootCause.OutOfDiskSpace:
case ExceptionRootCause.DataErrorDriveFailure:
case ExceptionRootCause.DeviceAccessError:
effectiveExitCode = GeneratorExitCode.InfrastructureError;
break;
case ExceptionRootCause.MissingRuntimeDependency:
effectiveExitCode = GeneratorExitCode.MissingRuntimeDependency;
break;
}
string failureMessage = exception.ToStringDemystified();
if (effectiveExitCode == GeneratorExitCode.InfrastructureError)
{
Logger.Log.UnhandledInfrastructureError(loggingContext, failureMessage);
}
else
{
Logger.Log.UnhandledFailure(loggingContext, failureMessage);
}
if (rootCause == ExceptionRootCause.FailFast)
{
ExceptionUtilities.FailFast("Exception is configured to fail fast", exception);
}
Environment.Exit((int)effectiveExitCode);
}
catch (Exception e)
{
PrintErrorToConsole("Unhandled exception in exception handler");
PrintErrorToConsole(e.ToStringDemystified());
}
finally
{
Environment.Exit((int)GeneratorExitCode.InternalError);
}
}
public void HandleError(object sender, Exception exception)
{
// Work around bug that is fixed in https://devdiv.visualstudio.com/DevDiv/_git/VS-Platform/pullrequest/209513
if (exception is NullReferenceException && exception.StackTrace.Contains("SpanTrackingWpfToolTipPresenter"))
{
return;
}
ExceptionUtilities.FailFast(exception);
}
/// <summary>
/// Notifies the environment about a fatal exception and terminates the process.
/// </summary>
/// <param name="exception">An exception that represents the error that caused the termination.
/// This is typically the exception in a catch block.</param>
/// <param name="message">A message that explains why the process was terminated,
/// or null if no explanation is provided.</param>
public static void OnFatalException(Exception exception, string message = null)
{
Contract.RequiresNotNull(exception);
if (Debugger.IsAttached)
{
Debugger.Break();
}
// Note that we don't use Environment.FailFast. It isn't trustworthy; instead we go straight to the kernel.
ExceptionUtilities.FailFast(message, exception);
}
private unsafe void CompletionWorkerThreadProc()
{
{
int count;
do
{
count = Volatile.Read(ref m_completionPortRefCount);
if (count < 1)
{
// Manager disposed before this thread started.
return;
}
}while (Interlocked.CompareExchange(ref m_completionPortRefCount, count + 1, comparand: count) != count);
}
try
{
while (true)
{
FileSystemWin.IOCompletionPortDequeueResult result = FileSystemWin.GetQueuedCompletionStatus(m_completionPort);
Contract.Assume(
result.Status != FileSystemWin.IOCompletionPortDequeueStatus.CompletionPortClosed,
"We terminate all workers before closing the port (otherwise we risk a handle-recycle race).");
Contract.Assert(result.Status == FileSystemWin.IOCompletionPortDequeueStatus.Succeeded);
if (result.DequeuedOverlapped == null)
{
// Completion port is being closed; this is a poison message.
Contract.Assume(result.CompletionKey == s_queueCloseCompletionKey);
break;
}
// The OVERLAPPED* attached to each packet is unique to each I/O request. It should be one
// that we allocated earlier with AllocateOverlapped. We took care to place a request identifier
// immediately after the OVERLAPPED, so we can find the completion target.
Overlapped *deqeuedOverlapped = result.DequeuedOverlapped;
var taggedOverlapped = (TaggedOverlapped *)deqeuedOverlapped;
ReleaseOvelappedAndQueueCompletionNotification(taggedOverlapped, result.CompletedIO);
}
DecrementCompletionPortRefCount();
}
catch (Exception ex)
{
ExceptionUtilities.FailFast("Catastrophic failure in I/O completion worker", ex);
throw;
}
}
public void Dispose()
{
// Swap the available mask from all available to none available.
// If this fails, there was a double-dispose or an overlapped is in use (so un-pinning would be scary).
bool swapSucceeded = Interlocked.CompareExchange(ref m_availableEntryMask, 0L, comparand: ~0L) == ~0L;
if (!swapSucceeded)
{
ExceptionUtilities.FailFast(
"OverlappedPoolNode was double-disposed or is still in use (outstanding I/O)",
new InvalidOperationException());
}
if (m_entriesPinningHandle.IsAllocated)
{
m_entriesPinningHandle.Free();
}
}
public void HandleError(object sender, Exception exception)
{
ExceptionUtilities.FailFast(exception);
}
