public void Dump(DumpType dumpType, object dumpArgs)
{
Thread t = null;
switch (dumpType)
{
case DumpType.UIGlobals:
t = new Thread(new ParameterizedThreadStart(Dumper_UIGlobals));
break;
case DumpType.UIChildren:
t = new Thread(new ParameterizedThreadStart(Dumper_UIChildren));
break;
default:
return;
}
if (t != null)
{
t.IsBackground = true;
t.Start(dumpArgs);
t = null;
}
}
/// <summary>
/// saving Wcf Configuration
/// </summary>
/// <param name="dumpType"></param>
/// <param name="value"></param>
/// <param name="wcfType"></param>
public void updateConfigurationFile(DumpType dumpType, String value, WcfType?wcfType = null)
{
SetDumpConfig(dumpType);
switch (dumpType)
{
case DumpType.File:
configFile.UpdateAppSetting(AppKeyName.FilePath, value);
break;
case DumpType.Msmq:
configFile.UpdateAppSetting(AppKeyName.MsmqPath, value);
break;
case DumpType.Wcf:
configFile.UpdateAppSetting(AppKeyName.WcfType, wcfType.Value.ToString());
configFile.UpdateUri(new Uri(value), wcfType.Value);
break;
default:
break;
}
configFile.Save();
}
public Task <ActionResult> GetDump(
ProcessFilter?processFilter,
[FromQuery] DumpType type = DumpType.WithHeap,
[FromQuery] string egressProvider = null)
{
return(InvokeForProcess(async processInfo =>
{
string dumpFileName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ?
FormattableString.Invariant($"dump_{GetFileNameTimeStampUtcNow()}.dmp") :
FormattableString.Invariant($"core_{GetFileNameTimeStampUtcNow()}");
if (string.IsNullOrEmpty(egressProvider))
{
Stream dumpStream = await _diagnosticServices.GetDump(processInfo, type, HttpContext.RequestAborted);
//Compression is done automatically by the response
//Chunking is done because the result has no content-length
return File(dumpStream, ContentTypes.ApplicationOctectStream, dumpFileName);
}
else
{
KeyValueLogScope scope = new KeyValueLogScope();
scope.AddArtifactType(ArtifactType_Dump);
scope.AddEndpointInfo(processInfo.EndpointInfo);
return new EgressStreamResult(
token => _diagnosticServices.GetDump(processInfo, type, token),
egressProvider,
dumpFileName,
processInfo.EndpointInfo,
ContentTypes.ApplicationOctectStream,
scope);
}
}, processFilter, ArtifactType_Dump));
}
public void SetDumpType(DumpIdentifier id, DumpType type)
{
DumpMetainfo dumpInfo = Get(id);
dumpInfo.DumpType = type;
storage.Store(dumpInfo);
}
public static void WriteDump(string fileName, DumpType typeOfdumpType)
{
MiniDumpExceptionInformation info;
info.ThreadId = NativeMethods.GetCurrentThreadId();
info.ClientPointers = false;
info.ExceptionPointers = Marshal.GetExceptionPointers();
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
uint processId = (uint)Process.GetCurrentProcess().Id;
IntPtr processHandle = NativeMethods.GetCurrentProcess();
IntPtr processHandle2 = Process.GetCurrentProcess().Handle;
// Feel free to specify different dump types
//uint dumpType = (uint) (DumpType.MiniDumpNormal | DumpType.MiniDumpWithDataSegs);
uint dumpType = (uint)typeOfdumpType;
NativeMethods.MiniDumpWriteDump(processHandle2,
processId,
fs.SafeFileHandle.DangerousGetHandle(),
dumpType,
ref info,
IntPtr.Zero,
IntPtr.Zero);
}
}
/// <summary>
/// Trigger a core dump generation.
/// </summary>
/// <param name="dumpType">Type of the dump to be generated</param>
/// <param name="dumpPath">Full path to the dump to be generated. By default it is /tmp/coredump.{pid}</param>
/// <param name="logDumpGeneration">When set to true, display the dump generation debug log to the console.</param>
/// <param name="token">The token to monitor for cancellation requests.</param>
internal async Task WriteDumpAsync(DumpType dumpType, string dumpPath, bool logDumpGeneration, CancellationToken token)
{
IpcMessage request = CreateWriteDumpMessage(dumpType, dumpPath, logDumpGeneration);
IpcMessage response = await IpcClient.SendMessageAsync(_endpoint, request, token).ConfigureAwait(false);
ValidateResponseMessage(response, nameof(WriteDumpAsync));
}
private void FillControls()
{
DumpType dtype = _editor.CurrentDumpLayer;
switch (dtype)
{
case DumpType.File:
FileSelected = true;
FolderPath = _editor.FolderPath;
MsmqPath = String.Empty;
SelectedBindingType = WcfBindingType[0];
WcfUri = String.Empty;
break;
case DumpType.Msmq:
MsmqSelected = true;
MsmqPath = _editor.MsmqPath;
FolderPath = String.Empty;
SelectedBindingType = WcfBindingType[0];
WcfUri = String.Empty;
break;
case DumpType.Wcf:
SelectedBindingType = _editor.WcfType;
WcfSelected = true;
WcfUri = _editor.GetWcfUri((WcfType)Enum.Parse(typeof(WcfType), SelectedBindingType)).ToString();
MsmqPath = String.Empty;
FolderPath = String.Empty;
break;
default:
break;
}
}
internal DebugTarget(DebugClient client, int index)
{
Index = index;
client.Control.GetDebuggeeType(out DebuggeeClass, out DebuggeeClassQualifier);
switch (DebuggeeClass)
{
case DEBUG_CLASS.KERNEL:
IsKernel = true;
break;
case DEBUG_CLASS.IMAGE_FILE:
IsDump = true;
break;
}
switch (DebuggeeClassQualifier)
{
case DEBUG_CLASS_QUALIFIER.KERNEL_LOCAL:
IsLocalKernel = true;
break;
case DEBUG_CLASS_QUALIFIER.KERNEL_DUMP:
DumpType = DumpType.Kernel;
break;
case DEBUG_CLASS_QUALIFIER.KERNEL_SMALL_DUMP:
DumpType = DumpType.Small;
break;
case DEBUG_CLASS_QUALIFIER.KERNEL_FULL_DUMP:
DumpType = DumpType.Full;
IsDump = true;
break;
}
}
/// <summary>
/// Trigger a core dump generation.
/// </summary>
/// <param name="dumpType">Type of the dump to be generated</param>
/// <param name="dumpPath">Full path to the dump to be generated. By default it is /tmp/coredump.{pid}</param>
/// <param name="logDumpGeneration">When set to true, display the dump generation debug log to the console.</param>
public void WriteDump(DumpType dumpType, string dumpPath, bool logDumpGeneration = false)
{
IpcMessage request = CreateWriteDumpMessage(dumpType, dumpPath, logDumpGeneration);
IpcMessage response = IpcClient.SendMessage(_endpoint, request);
ValidateResponseMessage(response, nameof(WriteDump));
}
private void ArchiveDump(DumpType dumpType, string fileName)
{
if (_settings.ArchiveDumps)
{
var archiveDir = Path.Combine(AppContext.BaseDirectory, "dump-archive", dumpType.ToString().ToLower());
if (!Directory.Exists(archiveDir))
{
Directory.CreateDirectory(archiveDir);
}
var info = new FileInfo(fileName);
var archiveFilename = $"{info.LastWriteTimeUtc.Year}-{info.LastWriteTimeUtc.Month:00}-{info.LastWriteTimeUtc.Day:00}-{dumpType.ToString().ToLower()}.xml.gz";
var targetFileName = Path.Combine(archiveDir, archiveFilename);
_logger.Information("Archiving {@fileName} to {@archiveFileName}", fileName, targetFileName);
if (File.Exists(fileName))
{
File.Copy(fileName, targetFileName);
}
else
{
_logger.Warning("File ({@fileName}) to archive not found.", fileName);
}
}
else
{
_logger.Debug("{@dumpType} dump archiving skipped.", dumpType);
}
}
/// <summary>
/// Initiate a core dump in the target process runtime.
/// </summary>
/// <param name="processId">.NET Core process id</param>
/// <param name="dumpName">Path and file name of core dump</param>
/// <param name="dumpType">Type of dump</param>
/// <param name="diagnostics">If true, log to console the dump generation diagnostics</param>
/// <returns>DiagnosticsServerErrorCode</returns>
public static int GenerateCoreDump(int processId, string dumpName, DumpType dumpType, bool diagnostics)
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
throw new PlatformNotSupportedException($"Unsupported operating system: {RuntimeInformation.OSDescription}");
}
if (string.IsNullOrEmpty(dumpName))
{
throw new ArgumentNullException($"{nameof(dumpName)} required");
}
var payload = SerializeCoreDump(dumpName, dumpType, diagnostics);
var message = new IpcMessage(DiagnosticsServerCommandSet.Dump, (byte)DumpCommandId.GenerateCoreDump, payload);
var response = IpcClient.SendMessage(processId, message);
var hr = 0;
switch ((DiagnosticsServerCommandId)response.Header.CommandId)
{
case DiagnosticsServerCommandId.Error:
case DiagnosticsServerCommandId.OK:
hr = BitConverter.ToInt32(response.Payload, 0);
break;
default:
return(-1);
}
return(hr);
}
public static void DumpLine(string line, int level, DumpType dumpType = DumpType.Strings)
{
if (!CanDump(dumpType) || !InitDump())
{
return;
}
if (!dumpAllLevels && !AllowedDumpLevels.Contains(level))
{
return;
}
if (dumpType == DumpType.Strings)
{
line = line.Replace("\n", "").Trim().Escape();
}
if (cachedDumps.Contains(line))
{
return;
}
cachedDumps.Add(line);
lock (dumpStream)
{
dumpStream.WriteLine($"[{dumpType}][LEVEL {level}] {line}");
dumpStream.Flush();
}
}
private void WriteToLog(DumpType type, ITraceable traceable)
{
try
{
XmlTextReader xmlTextReader = new XmlTextReader(traceStream.InnerStream);
StringWriter writer = new StringWriter(new StringBuilder((int)(traceStream.InnerStream.Length * 1.51)));
XmlTextWriter xmlTextWriter = new XmlTextWriter(writer);
xmlTextWriter.Formatting = Formatting.Indented;
xmlTextWriter.IndentChar = '\t';
xmlTextWriter.Indentation = 1;
xmlTextReader.MoveToContent();
xmlTextWriter.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
while (!xmlTextReader.EOF)
{
if (xmlTextReader.NodeType != XmlNodeType.XmlDeclaration)
{
xmlTextWriter.WriteNode(xmlTextReader, false);
}
}
Trace.WriteLine(writer.ToString(), String.Format("{0} {1}", traceable.ComponentName, type));
}
catch (Exception e)
{
Trace.TraceError("Error in TraceExtension: {0}", e);
}
}
/// <summary>
/// Trigger a core dump generation.
/// </summary>
/// <param name="dumpType">Type of the dump to be generated</param>
/// <param name="dumpPath">Full path to the dump to be generated. By default it is /tmp/coredump.{pid}</param>
/// <param name="logDumpGeneration">When set to true, display the dump generation debug log to the console.</param>
public void WriteDump(DumpType dumpType, string dumpPath, bool logDumpGeneration = false)
{
if (string.IsNullOrEmpty(dumpPath))
{
throw new ArgumentNullException($"{nameof(dumpPath)} required");
}
byte[] payload = SerializeCoreDump(dumpPath, dumpType, logDumpGeneration);
IpcMessage message = new IpcMessage(DiagnosticsServerCommandSet.Dump, (byte)DumpCommandId.GenerateCoreDump, payload);
IpcMessage response = IpcClient.SendMessage(_endpoint, message);
switch ((DiagnosticsServerResponseId)response.Header.CommandId)
{
case DiagnosticsServerResponseId.Error:
uint hr = BitConverter.ToUInt32(response.Payload, 0);
if (hr == (uint)DiagnosticsIpcError.UnknownCommand)
{
throw new PlatformNotSupportedException($"Unsupported operating system: {RuntimeInformation.OSDescription}");
}
throw new ServerErrorException($"Writing dump failed (HRESULT: 0x{hr:X8})");
case DiagnosticsServerResponseId.OK:
return;
default:
throw new ServerErrorException($"Writing dump failed - server responded with unknown command");
}
}
public async Task <int> Collect(CommandLineApplication cmd, int processId, string output, bool diag, DumpTypeOption type)
{
if (processId == 0)
{
return(cmd.ExitWithError("ProcessId is required."));
}
try
{
if (output == null)
{
// Build timestamp based file path
string timestamp = $"{DateTime.Now:yyyyMMdd_HHmmss}";
output = Path.Combine(Directory.GetCurrentDirectory(), RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? $"dump_{processId}_{timestamp}.dmp" : $"core_{processId}_{timestamp}");
}
// Make sure the dump path is NOT relative. This path could be sent to the runtime
// process on Linux which may have a different current directory.
output = Path.GetFullPath(output);
// Display the type of dump and dump path
string dumpTypeMessage = type == DumpTypeOption.Mini ? "minidump" : "minidump with heap";
cmd.Out.WriteLine($"Writing {dumpTypeMessage} to {output}");
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// Get the process
Process process = Process.GetProcessById(processId);
await Windows.CollectDumpAsync(process, output, type);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
var client = new DiagnosticsClient(processId);
DumpType dumpType = type == DumpTypeOption.Heap ? DumpType.WithHeap : DumpType.Normal;
// Send the command to the runtime to initiate the core dump
client.WriteDump(dumpType, output, diag);
}
else
{
throw new PlatformNotSupportedException($"Unsupported operating system: {RuntimeInformation.OSDescription}");
}
}
catch (Exception ex) when
(ex is FileNotFoundException ||
ex is DirectoryNotFoundException ||
ex is UnauthorizedAccessException ||
ex is PlatformNotSupportedException ||
ex is InvalidDataException ||
ex is InvalidOperationException ||
ex is NotSupportedException ||
ex is DiagnosticsClientException)
{
return(cmd.ExitWithError($"{ex.Message}"));
}
cmd.Out.WriteLine($"Complete");
return(0);
}
internal static extern int WerReportAddDump(
ReportHandle reportHandle,
IntPtr hProcess,
IntPtr hThread,
DumpType dumpType,
IntPtr pExceptionParam,
IntPtr dumpCustomOptions,
DumpFlags dumpFlags);
private static extern bool MiniDumpWriteDump(
[In] IntPtr hProcess,
uint ProcessId,
SafeFileHandle hFile,
DumpType DumpType,
[In] IntPtr ExceptionParam,
[In] IntPtr UserStreamParam,
[In] IntPtr CallbackParam);
private LogManager(string path = "./logs/latest.log", LogTypes _MinimumLogType = LogTypes.All, string _pattern_prefix = "[ %TYPE%: %DATE% ]: %MESSAGE%", DumpType dumpType = DumpType.NoDump, int dumpInterval = 10000)
{
_singleton = this;
Path = Directory.CreateDirectory(Directory.GetParent(System.IO.Path.GetFullPath(path)).FullName).FullName;
MinimumLogType = _MinimumLogType;
Pattern = _pattern_prefix;
DumpType = dumpType;
DumpInterval = dumpInterval;
if (!string.IsNullOrWhiteSpace(Path))
{
if (DumpType == DumpType.Interval)
{
MessageQueue = new List <string>();
Timer dumpLog = new Timer(dumpInterval)
{
AutoReset = true,
Enabled = true,
};
dumpLog.Elapsed += (s, e) => DumpQueue();
dumpLog.Start();
}
AppDomain.CurrentDomain.ProcessExit += (s, e) => Close();
}
switch (MinimumLogType)
{
case LogTypes.All:
IsFatalEnabled = true; IsWarnEnabled = true; IsInfoEnabled = true; IsDebugEnabled = true; IsErrorEnabled = true;
break;
case LogTypes.Debug:
IsFatalEnabled = true; IsWarnEnabled = true; IsInfoEnabled = true; IsDebugEnabled = true; IsErrorEnabled = true;
break;
case LogTypes.Info:
IsFatalEnabled = true; IsWarnEnabled = true; IsInfoEnabled = true; IsDebugEnabled = false; IsErrorEnabled = true;
break;
case LogTypes.Warn:
IsFatalEnabled = true; IsWarnEnabled = true; IsInfoEnabled = false; IsDebugEnabled = false; IsErrorEnabled = true;
break;
case LogTypes.Error:
IsFatalEnabled = true; IsWarnEnabled = false; IsInfoEnabled = false; IsDebugEnabled = false; IsErrorEnabled = true;
break;
case LogTypes.Fatal:
IsFatalEnabled = true; IsWarnEnabled = false; IsInfoEnabled = false; IsDebugEnabled = false; IsErrorEnabled = false;
break;
default:
IsFatalEnabled = true; IsWarnEnabled = true; IsInfoEnabled = true; IsDebugEnabled = true; IsErrorEnabled = true;
MinimumLogType = LogTypes.All;
break;
}
}
/// <summary>
/// Writes the memory dump to the file.
/// </summary>
/// <param name="fileName">The file name.</param>
/// <param name="dumpType">The dump type.</param>
public static void WriteDump(string fileName, DumpType dumpType)
{
using (FileStream fileStream = new FileStream(fileName, FileMode.Create))
{
Process currentProcess = Process.GetCurrentProcess();
NativeMethods.ExceptionInformation exceptionInformation = new NativeMethods.ExceptionInformation { ThreadId = NativeMethods.GetCurrentThreadId(), ExceptionPointers = Marshal.GetExceptionPointers() };
NativeMethods.MiniDumpWriteDump(currentProcess.Handle, currentProcess.Id, fileStream.SafeFileHandle, dumpType, ref exceptionInformation, IntPtr.Zero, IntPtr.Zero);
}
}
public Dump(string path, DateTime timestamp, DumpType type, ProcessorArchitecture architecture, IReadOnlyList <NativeModule> modules, IReadOnlyList <NativeThread> threads, IReadOnlyList <NativeMemoryInfo> memoryInfos)
{
Path = path;
Timestamp = timestamp;
Type = type;
Architecture = architecture;
Modules = modules;
Threads = threads;
MemoryInfos = memoryInfos;
}
private async Task RetrieveDumpAsync(DumpType dumpType, IJobExecutionContext context)
{
var fileName = Path.Combine(AppContext.BaseDirectory, _dumpRetrievalService.GetDumpFileNameByDumpType(dumpType));
string existingHash = "";
if (File.Exists(fileName))
{
_logger.Debug("Calculating hash from local file: {@fileName}", fileName);
using (var fileStream = new FileStream(fileName, FileMode.Open))
{
existingHash = await CalculateHashFromStreamAsync(fileStream).ConfigureAwait(false);
}
}
if (!_dumpRetrievalService.IsLocalDumpAvailableAndUpToDate(dumpType))
{
var stopWatch = Stopwatch.StartNew();
using (Stream responseStream = await _dumpRetrievalService.DownloadDumpAsync(dumpType, CancellationToken.None).ConfigureAwait(false))
{
stopWatch.Stop();
_logger.Debug("Download {@dumpType} dump as stream took {@elapsed} to complete.", dumpType, stopWatch.Elapsed);
if (existingHash != await CalculateHashFromStreamAsync(responseStream).ConfigureAwait(false))
{
ArchiveDump(dumpType, fileName);
using (var fileStream = new FileStream(fileName, FileMode.Create))
{
stopWatch.Restart();
responseStream.Seek(0, SeekOrigin.Begin);
await responseStream.CopyToAsync(fileStream).ConfigureAwait(false);
stopWatch.Stop();
_logger.Debug("Writing {@dumpType} dump to local cache took {@elapsed} to complete.", dumpType, stopWatch.Elapsed);
}
_isRetrying = false;
//Set only to true if there is no value, if it is true no need to change, if it is false keep it at false
if (!_successfullyUpdated.HasValue)
{
_successfullyUpdated = true;
}
}
else
{
_logger.Warning("Downloaded {@dumpType} dump stream does not differ from local {@dumpType} dump. {@dumpType} dump was not updated yet.", dumpType);
await RerunJobAsync(context).ConfigureAwait(false);
_successfullyUpdated = false;
}
}
}
else
{
_successfullyUpdated = true;
}
}
public Task DumpTest(DiagnosticPortConnectionMode mode, DumpType type)
{
#if !NET6_0_OR_GREATER
// Capturing non-full dumps via diagnostic command works inconsistently
// on Alpine for .NET 5 and lower (the dump command will return successfully, but)
// the dump file will not exist). Only test other dump types on .NET 6+
if (DistroInformation.IsAlpineLinux && type != DumpType.Full)
{
_outputHelper.WriteLine("Skipped on Alpine for .NET 5 and lower.");
return(Task.CompletedTask);
}
#endif
return(ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
mode,
TestAppScenarios.AsyncWait.Name,
appValidate: async(runner, client) =>
{
int processId = await runner.ProcessIdTask;
using ResponseStreamHolder holder = await client.CaptureDumpAsync(processId, type);
Assert.NotNull(holder);
// The dump operation may still be in progress but the process should still be discoverable.
// If this check fails, then the dump operation is causing dotnet-monitor to not be able
// to observe the process any more.
ProcessInfo processInfo = await client.GetProcessAsync(processId);
Assert.NotNull(processInfo);
await DumpTestUtilities.ValidateDump(runner.Environment.ContainsKey(DumpTestUtilities.EnableElfDumpOnMacOS), holder.Stream);
await runner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
},
configureApp: runner =>
{
// MachO not supported on .NET 5, only ELF: https://github.com/dotnet/runtime/blob/main/docs/design/coreclr/botr/xplat-minidump-generation.md#os-x
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && DotNetHost.RuntimeVersion.Major == 5)
{
runner.Environment.Add(DumpTestUtilities.EnableElfDumpOnMacOS, "1");
}
},
configureTool: runner =>
{
string dumpTempFolder = Path.Combine(runner.TempPath, "Dumps");
// The dump temp folder should not exist in order to test that capturing dumps into the folder
// will work since dotnet-monitor should ensure the folder is created before issuing the dump command.
Assert.False(Directory.Exists(dumpTempFolder), "The dump temp folder should not exist.");
runner.ConfigurationFromEnvironment.SetDumpTempFolder(dumpTempFolder);
}));
}
public async Task <Stream> DumpAsync(IEndpointInfo endpointInfo, Models.DumpType mode, CancellationToken token)
{
if (endpointInfo == null)
{
throw new ArgumentNullException(nameof(endpointInfo));
}
string dumpTempFolder = _storageOptions.CurrentValue.DumpTempFolder;
// Ensure folder exists before issue command.
if (!Directory.Exists(dumpTempFolder))
{
Directory.CreateDirectory(dumpTempFolder);
}
string dumpFilePath = Path.Combine(dumpTempFolder, FormattableString.Invariant($"{Guid.NewGuid()}_{endpointInfo.ProcessId}"));
DumpType dumpType = MapDumpType(mode);
IDisposable operationRegistration = null;
// Only track operation status for endpoints from a listening server because:
// 1) Each process only ever has a single instance of an IEndpointInfo
// 2) Only the listening server will query the dump service for the operation status of an endpoint.
if (IsListenMode)
{
// This is a quick fix to prevent the polling algorithm in the ServerEndpointInfoSource
// from removing IEndpointInfo instances when they don't respond in a timely manner to
// a dump operation causing the runtime to temporarily be unresponsive. Long term, this
// concept should be folded into RequestLimitTracker with registered endpoint information
// and allowing to query the status of an endpoint for a given artifact.
operationRegistration = _operationTrackerService.Register(endpointInfo);
}
try
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// Get the process
Process process = Process.GetProcessById(endpointInfo.ProcessId);
await Dumper.CollectDumpAsync(process, dumpFilePath, dumpType);
}
else
{
var client = new DiagnosticsClient(endpointInfo.Endpoint);
await client.WriteDumpAsync(dumpType, dumpFilePath, logDumpGeneration : false, token);
}
}
finally
{
operationRegistration?.Dispose();
}
return(new AutoDeleteFileStream(dumpFilePath));
}
/// <summary>
/// Writes the memory dump to the file.
/// </summary>
/// <param name="fileName">The file name.</param>
/// <param name="dumpType">The dump type.</param>
public static void WriteDump(string fileName, DumpType dumpType)
{
using (FileStream fileStream = new FileStream(fileName, FileMode.Create))
{
Process currentProcess = Process.GetCurrentProcess();
NativeMethods.ExceptionInformation exceptionInformation = new NativeMethods.ExceptionInformation {
ThreadId = NativeMethods.GetCurrentThreadId(), ExceptionPointers = Marshal.GetExceptionPointers()
};
NativeMethods.MiniDumpWriteDump(currentProcess.Handle, currentProcess.Id, fileStream.SafeFileHandle, dumpType, ref exceptionInformation, IntPtr.Zero, IntPtr.Zero);
}
}
public static void WriteDumpForProcess(Process process, string fileName, DumpType dumpType)
{
using (FileStream fs = File.Create(fileName))
{
if (!MiniDumpWriteDump(Process.GetCurrentProcess().Handle,
(uint)process.Id, fs.SafeFileHandle, dumpType,
IntPtr.Zero, IntPtr.Zero, IntPtr.Zero))
{
throw new Win32Exception(Marshal.GetLastWin32Error(), "Error calling MiniDumpWriteDump.");
}
}
}
public void Dump(int pid, DumpType dumpType, string fileName, string dumpComment = null)
{
_pid = pid;
_dumpType = dumpType;
dumpComment = dumpComment ?? ("DumpWriter: " + _dumpType.ToString());
IntPtr hProcess = DumpNativeMethods.OpenProcess(
ProcessAccessFlags.QueryInformation | ProcessAccessFlags.VirtualMemoryRead | ProcessAccessFlags.DuplicateHandle,
false,
(uint)_pid
);
if (hProcess == IntPtr.Zero)
{
throw new ArgumentException(String.Format("Unable to open process {0}, error {x:8}", _pid, Marshal.GetLastWin32Error()));
}
FileStream dumpFileStream = new FileStream(fileName, FileMode.Create);
var exceptionParam = new MINIDUMP_EXCEPTION_INFORMATION();
var userStreamParam = PrepareUserStream(dumpComment);
var callbackParam = new MINIDUMP_CALLBACK_INFORMATION();
if (_dumpType == DumpType.FullMemoryExcludingSafeRegions ||
_dumpType == DumpType.MinimalWithFullCLRHeap)
{
callbackParam.CallbackRoutine = CallbackRoutine;
}
MINIDUMP_TYPE nativeDumpType =
(_dumpType == DumpType.FullMemory || _dumpType == DumpType.FullMemoryExcludingSafeRegions) ?
MINIDUMP_TYPE.MiniDumpWithFullMemory | MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo :
MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo;
bool success = DumpNativeMethods.MiniDumpWriteDump(
hProcess,
(uint)_pid,
dumpFileStream.SafeFileHandle.DangerousGetHandle(),
nativeDumpType,
ref exceptionParam,
ref userStreamParam,
ref callbackParam
);
if (!success)
{
throw new ApplicationException(String.Format("Error writing dump, error {0:x8}", Marshal.GetLastWin32Error()));
}
userStreamParam.Delete();
DumpNativeMethods.CloseHandle(hProcess);
dumpFileStream.Close();
}
public MiniDumper(string dumpFolder, int pid, string processName,
TextWriter logger, DumpType dumpType, bool writeAsync, string filter)
{
this.dumpFolder = dumpFolder;
this.pid = pid;
this.processName = processName;
this.logger = logger;
this.dumpType = dumpType;
this.writeAsync = writeAsync;
this.rgxFilter = new Regex((filter ?? "*").Replace("*", ".*").Replace('?', '.'),
RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
this.target = DataTarget.AttachToProcess(pid, 1000, AttachFlag.Passive);
}
public MiniDumper(string dumpFolder, int pid, string processName,
TextWriter logger, DumpType dumpType, bool writeAsync, string filter)
{
this.dumpFolder = dumpFolder;
this.pid = pid;
this.processName = processName;
this.logger = logger;
this.dumpType = dumpType;
this.writeAsync = writeAsync;
this.rgxFilter = new Regex((filter ?? "*").Replace("*", ".*").Replace('?', '.'),
RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
this.target = DataTarget.AttachToProcess(pid, 1000, AttachFlag.Passive);
}
private static byte[] SerializeCoreDump(string dumpName, DumpType dumpType, bool diagnostics)
{
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
writer.WriteString(dumpName);
writer.Write((uint)dumpType);
writer.Write((uint)(diagnostics ? 1 : 0));
writer.Flush();
return(stream.ToArray());
}
}
public void Add_A_Type_Only_Once()
{
// arrange
var sut = new DumpModule(new DumpModuleKey(0, ""));
var type = new DumpType();
// act
sut.AddType(type);
sut.AddType(type);
// assert
sut.Types.Should().HaveCount(1);
}
public UnhandledExceptions( FeatureFlags featureFlags , DumpType dumpType )
{
_featureFlags = featureFlags;
_dumpType = dumpType;
if ( ( _featureFlags & FeatureFlags.Logging ) == FeatureFlags.Logging )
{
throw new ArgumentException("Logging feature is enabled with no log provided", "featureFlags");
}
if ( ( _featureFlags & FeatureFlags.Dump ) == FeatureFlags.Dump && _dumpType == DumpType.None )
{
throw new ArgumentException("Dump feature is enabled with DumpType.None provided", "dumpType");
}
}
public UnhandledExceptions( FeatureFlags featureFlags , DumpType dumpType , ILog log )
{
_featureFlags = featureFlags;
_dumpType = dumpType;
_log = log;
if ( ( _featureFlags & FeatureFlags.Logging ) == FeatureFlags.Logging && _log == null )
{
throw new ArgumentNullException("log", "Logging feature is enabled with null log provided");
}
if ( ( _featureFlags & FeatureFlags.Dump ) == FeatureFlags.Dump && _dumpType == DumpType.None )
{
throw new ArgumentException("Dump feature is enabled with DumpType.None provided", "dumpType");
}
}
/// <summary>
/// Trigger a core dump generation.
/// </summary>
/// <param name="dumpType">Type of the dump to be generated</param>
/// <param name="dumpPath">Full path to the dump to be generated. By default it is /tmp/coredump.{pid}</param>
/// <param name="flags">logging and crash report flags. On runtimes less than 6.0, only LoggingEnabled is supported.</param>
/// <param name="token">The token to monitor for cancellation requests.</param>
public async Task WriteDumpAsync(DumpType dumpType, string dumpPath, WriteDumpFlags flags, CancellationToken token)
{
IpcMessage request = CreateWriteDumpMessage2(dumpType, dumpPath, flags);
IpcMessage response = await IpcClient.SendMessageAsync(_endpoint, request, token).ConfigureAwait(false);
if (!ValidateResponseMessage(response, nameof(WriteDumpAsync), ValidateResponseOptions.UnknownCommandReturnsFalse))
{
if ((flags & ~WriteDumpFlags.LoggingEnabled) != 0)
{
throw new ArgumentException($"Only {nameof(WriteDumpFlags.LoggingEnabled)} flag is supported by this runtime version", nameof(flags));
}
await WriteDumpAsync(dumpType, dumpPath, logDumpGeneration : (flags & WriteDumpFlags.LoggingEnabled) != 0, token);
}
}
/// <summary>
/// Trigger a core dump generation.
/// </summary>
/// <param name="dumpType">Type of the dump to be generated</param>
/// <param name="dumpPath">Full path to the dump to be generated. By default it is /tmp/coredump.{pid}</param>
/// <param name="flags">logging and crash report flags. On runtimes less than 6.0, only LoggingEnabled is supported.</param>
public void WriteDump(DumpType dumpType, string dumpPath, WriteDumpFlags flags)
{
IpcMessage request = CreateWriteDumpMessage2(dumpType, dumpPath, flags);
IpcMessage response = IpcClient.SendMessage(_endpoint, request);
if (!ValidateResponseMessage(response, nameof(WriteDump), ValidateResponseOptions.UnknownCommandReturnsFalse))
{
if ((flags & ~WriteDumpFlags.LoggingEnabled) != 0)
{
throw new ArgumentException($"Only {nameof(WriteDumpFlags.LoggingEnabled)} flag is supported by this runtime version", nameof(flags));
}
WriteDump(dumpType, dumpPath, logDumpGeneration: (flags & WriteDumpFlags.LoggingEnabled) != 0);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MemoryDumpOnException"/> class.
/// </summary>
/// <param name="fileName">The file name.</param>
/// <param name="dumpType">The dump type.</param>
/// <param name="exceptionsToTrack">The exceptions to track.</param>
public MemoryDumpOnException(string fileName, DumpType dumpType, IEnumerable<Type> exceptionsToTrack)
{
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
if (exceptionsToTrack == null)
{
throw new ArgumentNullException("exceptionsToTrack");
}
this.fileName = fileName;
this.dumpType = dumpType;
this.exceptionsToTrack = exceptionsToTrack;
}
public void Dump(int pid, DumpType dumpType, string fileName, string dumpComment = null)
{
_pid = pid;
_dumpType = dumpType;
dumpComment = dumpComment ?? ("DumpWriter: " + _dumpType.ToString());
IntPtr hProcess = DumpNativeMethods.OpenProcess(
ProcessAccessFlags.QueryInformation | ProcessAccessFlags.VirtualMemoryRead | ProcessAccessFlags.DuplicateHandle,
false,
(uint)_pid
);
if (hProcess == IntPtr.Zero)
throw new ArgumentException(String.Format("Unable to open process {0}, error {x:8}", _pid, Marshal.GetLastWin32Error()));
FileStream dumpFileStream = new FileStream(fileName, FileMode.Create);
var exceptionParam = new MINIDUMP_EXCEPTION_INFORMATION();
var userStreamParam = PrepareUserStream(dumpComment);
var callbackParam = new MINIDUMP_CALLBACK_INFORMATION();
if (_dumpType == DumpType.FullMemoryExcludingSafeRegions ||
_dumpType == DumpType.MinimalWithFullCLRHeap)
{
callbackParam.CallbackRoutine = CallbackRoutine;
}
MINIDUMP_TYPE nativeDumpType =
(_dumpType == DumpType.FullMemory || _dumpType == DumpType.FullMemoryExcludingSafeRegions) ?
MINIDUMP_TYPE.MiniDumpWithFullMemory | MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo :
MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo;
bool success = DumpNativeMethods.MiniDumpWriteDump(
hProcess,
(uint)_pid,
dumpFileStream.SafeFileHandle.DangerousGetHandle(),
nativeDumpType,
ref exceptionParam,
ref userStreamParam,
ref callbackParam
);
if (!success)
throw new ApplicationException(String.Format("Error writing dump, error {0:x8}", Marshal.GetLastWin32Error()));
userStreamParam.Delete();
DumpNativeMethods.CloseHandle(hProcess);
dumpFileStream.Close();
}
public int Dump(Stream asnStream, TextWriter dumpWriter, DumpType dumpType, byte maxLevel)
{
long offset = asnStream.Position;
BerDecoderResult pr = BerDecoderResult.Finished;
TlvObject tlv;
D900CdrElement record;
int cnt = 0;
for (; ; )//(int n = 11; n > 0; n--)
{
pr = DecodeTlv(asnStream, out tlv, ref offset, 0, maxLevel);
if (pr != BerDecoderResult.Finished)
break;
switch (dumpType)
{
case DumpType.TLV_TXT:
tlv.DumpToTxt(dumpWriter, String.Format("{0,8} > {1}", tlv.Offset, ++cnt));
dumpWriter.WriteLine();
break;
case DumpType.TLV_XML:
tlv.DumpToXml(dumpWriter, 0);
break;
case DumpType.ELEMENT_TXT:
record = _tlvParser.ParseTlvObject(tlv);
record.DumpToTxt(dumpWriter, String.Format("{0,8} > {1}", record.Offset, ++cnt));
dumpWriter.WriteLine();
break;
case DumpType.ELEMENT_XML:
record = _tlvParser.ParseTlvObject(tlv);
record.DumpToXml(dumpWriter, 0);
break;
}
}
dumpWriter.Flush();
return (int)(pr);
}
public static void WriteDump(string fileName, DumpType typeOfdumpType)
{
MiniDumpExceptionInformation info;
info.ThreadId = NativeMethods.GetCurrentThreadId();
info.ClientPointers = false;
info.ExceptionPointers = Marshal.GetExceptionPointers();
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
var processId = (uint) Process.GetCurrentProcess().Id;
var processHandle = NativeMethods.GetCurrentProcess();
var processHandle2 = Process.GetCurrentProcess().Handle;
// Feel free to specify different dump types
//uint dumpType = (uint) (DumpType.MiniDumpNormal | DumpType.MiniDumpWithDataSegs);
var dumpType = (uint) typeOfdumpType;
NativeMethods.MiniDumpWriteDump(processHandle2,
processId,
fs.SafeFileHandle.DangerousGetHandle(),
dumpType,
ref info,
IntPtr.Zero,
IntPtr.Zero);
}
}
public void Dump(DumpType dumpType, object dumpArgs)
{
Thread t = null;
switch (dumpType)
{
case DumpType.UIGlobals:
t = new Thread(new ParameterizedThreadStart(Dumper_UIGlobals));
break;
case DumpType.UIChildren:
t = new Thread(new ParameterizedThreadStart(Dumper_UIChildren));
break;
default:
return;
}
if (t != null)
{
t.IsBackground = true;
t.Start(dumpArgs);
t = null;
}
}
internal static extern int WerReportAddDump(
ReportHandle reportHandle,
IntPtr hProcess,
IntPtr hThread,
DumpType dumpType,
IntPtr pExceptionParam,
IntPtr dumpCustomOptions,
DumpFlags dumpFlags);
internal static extern bool MiniDumpWriteDump(IntPtr processHandle, int processId, SafeHandle fileHandle, DumpType dumpType, ref ExceptionInformation exception, IntPtr userStream, IntPtr callback);
public void Dump(int pid, DumpType dumpType, IntPtr exceptionParam,
string fileName, bool writeAsync = false, string dumpComment = null)
{
_pid = pid;
_dumpType = dumpType;
_spillSegmentsAsynchronously = writeAsync;
dumpComment = dumpComment ?? ("DumpWriter: " + _dumpType.ToString());
IntPtr hProcess = DumpNativeMethods.OpenProcess(
ProcessAccessFlags.QueryInformation | ProcessAccessFlags.VirtualMemoryRead | ProcessAccessFlags.DuplicateHandle,
false,
(uint)_pid
);
if (hProcess == IntPtr.Zero)
throw new ArgumentException(String.Format("Unable to open process {0}, error {x:8}", _pid, Marshal.GetLastWin32Error()));
_dumpFileStream = new FileStream(fileName, FileMode.Create);
var userStreamParam = PrepareUserStream(dumpComment);
var callbackParam = new MINIDUMP_CALLBACK_INFORMATION();
_needMemoryCallbacks = (
_dumpType == DumpType.FullMemoryExcludingSafeRegions ||
_dumpType == DumpType.MinimalWithFullCLRHeap
);
if (_needMemoryCallbacks || _spillSegmentsAsynchronously)
{
callbackParam.CallbackRoutine = CallbackRoutine;
}
MINIDUMP_TYPE nativeDumpType =
(_dumpType == DumpType.FullMemory || _dumpType == DumpType.FullMemoryExcludingSafeRegions) ?
MINIDUMP_TYPE.MiniDumpWithFullMemory | MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo :
MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo;
Stopwatch sw = Stopwatch.StartNew();
bool success = DumpNativeMethods.MiniDumpWriteDump(
hProcess,
(uint)_pid,
_dumpFileStream.SafeFileHandle.DangerousGetHandle(),
nativeDumpType,
exceptionParam,
ref userStreamParam,
ref callbackParam);
if (!success)
throw new ApplicationException(string.Format("Error writing dump, error: {0}", Marshal.GetExceptionForHR(
Marshal.GetHRForLastWin32Error())));
_logger.WriteLine("Process was suspended for {0:N2}ms", sw.Elapsed.TotalMilliseconds);
if (_spillSegmentsAsynchronously)
{
// We are asynchronously spilling dump segments to disk, need to wait
// for this process to complete before returning to the caller.
_segmentSpillingTask.Wait();
_logger.WriteLine(
"Total dump writing time including async flush was {0:N2}ms",
sw.Elapsed.TotalMilliseconds);
}
userStreamParam.Delete();
DumpNativeMethods.CloseHandle(hProcess);
_dumpFileStream.Close();
}
public void Setup(DumpFormat format, DumpType type)
{
this.format = format;
this.type = type;
switch(format)
{
case DumpFormat.Text:
file = Path.Combine(directory, string.Format("TagIndexDump.{0:yyyy}{0:MM}{0:dd}_{0:HH}{0:mm}({0:ss}).{1}", DateTime.Now, "txt"));
provider = new TextProvider(file, type);
break;
case DumpFormat.Xml:
file = Path.Combine(directory, string.Format("TagIndexDump.{0:yyyy}{0:MM}{0:dd}_{0:HH}{0:mm}({0:ss}).{1}", DateTime.Now, "xml"));
provider = new XmlProvider(file);
break;
}
}
public int Dump(Stream asnStream, DumpType dumpType)
{
return this.Dump(asnStream, System.Console.Out, dumpType, byte.MaxValue);
}
public TextProvider(string file, DumpType type)
{
writer = new StreamWriter(file, false, Encoding.ASCII);
this.type = type;
}
