public static extern bool MiniDumpWriteDump(IntPtr hProcess,
int processId,
SafeFileHandle hFile,
MINIDUMP_TYPE dumpType,
IntPtr exceptionParam,
IntPtr userStreamParam,
IntPtr callbackParam);
public static extern bool MiniDumpWriteDump( IntPtr hProcess, uint processId, SafeHandle hFile, MINIDUMP_TYPE dumpType, IntPtr expParam, IntPtr userStreamParam, IntPtr callbackParam);
public static extern bool MiniDumpWriteDump(
IntPtr hProcess,
Int32 ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
IntPtr ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallackParam);
private static extern int MiniDumpWriteDump(
SafeHandle hProcess,
int ProcessId,
SafeHandle hFile,
MINIDUMP_TYPE DumpType,
IntPtr ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallbackParam);
static extern bool MiniDumpWriteDump(
IntPtr hProcess,
UInt32 ProcessId,
SafeHandle hFile,
MINIDUMP_TYPE DumpType,
IntPtr ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallbackParam);
static extern bool MiniDumpWriteDump(
IntPtr hProcess,
Int32 processId,
IntPtr hFile,
MINIDUMP_TYPE dumpType,
IntPtr exceptionParam,
IntPtr userStreamParam,
IntPtr callbackParam);
public static extern bool MiniDumpWriteDump(
IntPtr hProcess,
Int32 ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
IntPtr ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallackParam);
public static extern bool MiniDumpWriteDump(
PssSnapshotSafeHandle hpss,
uint processId,
SafeHandle hFile,
MINIDUMP_TYPE dumpType,
IntPtr expParam,
IntPtr userStreamParam,
[In] ref MINIDUMP_CALLBACK_INFORMATION callbackParam);
public static extern bool MiniDumpWriteDump(
IntPtr hProcess,
uint ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
IntPtr ExceptionParams,
[In] ref MINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
[In] ref MINIDUMP_CALLBACK_INFORMATION CallbackParam
);
public static extern bool MiniDumpWriteDump(
IntPtr hProcess,
short ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
ref MiniDumpExceptionInformation ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallbackParam
);
public static extern bool MiniDumpWriteDump(
IntPtr hProcess,
int ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
ref MINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallbackParam
);
internal static extern bool MiniDumpWriteDump
(
IntPtr hProcess,
short ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
IntPtr ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallbackParam
);
public static extern bool MiniDumpWriteDump
(
IntPtr hProcess,
short ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
ref MiniDumpExceptionInformation ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallbackParam
);
static extern bool MiniDumpWriteDump
(
SafeProcessHandle hProcess,
uint ProcessId,
SafeFileHandle hFile,
MINIDUMP_TYPE DumpType,
ref MINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
IntPtr UserStreamParam,
IntPtr CallbackParam
);
public static void MiniDump(this Process process, string dumpFile, MINIDUMP_TYPE dumpType)
{
using (var fs = new FileStream(dumpFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
if (!MiniDumpNativeMethods.MiniDumpWriteDump(process.Handle, (uint)process.Id, fs.SafeFileHandle, dumpType, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
}
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 static bool Write(string fileName, MINIDUMP_TYPE options, int? threadId = null)
{
var process = Process.GetCurrentProcess();
var processId = process.Id;
int realThreadId;
if (threadId == null)
realThreadId = Thread.CurrentThread.ManagedThreadId;
else
realThreadId = (int)threadId;
return CreateDump(processId, fileName, (Int32) options, realThreadId,
Marshal.GetExceptionPointers());
}
private bool CreateDump(Process process, IntPtr exceptionInfo, uint threadId, bool debugger)
{
bool ret;
_strLatestDumpName = "crashdump-" + DateTime.Now.ToFileTimeUtc().ToString() + ".dmp";
using (FileStream file = File.Create(Path.Combine(WorkingDirectory, _strLatestDumpName)))
{
MiniDumpExceptionInformation info = new MiniDumpExceptionInformation
{
ClientPointers = true,
ExceptionPointers = exceptionInfo,
ThreadId = threadId
};
const MINIDUMP_TYPE dtype = MINIDUMP_TYPE.MiniDumpWithPrivateReadWriteMemory |
MINIDUMP_TYPE.MiniDumpWithDataSegs |
MINIDUMP_TYPE.MiniDumpWithHandleData |
MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo |
MINIDUMP_TYPE.MiniDumpWithThreadInfo |
MINIDUMP_TYPE.MiniDumpWithUnloadedModules;
bool extraInfo = !(exceptionInfo == IntPtr.Zero || threadId == 0 || !debugger);
if (extraInfo)
{
ret = !NativeMethods.MiniDumpWriteDump(process.Handle, _procId,
file.SafeFileHandle?.DangerousGetHandle() ?? IntPtr.Zero,
dtype, ref info, IntPtr.Zero, IntPtr.Zero);
}
else if (NativeMethods.MiniDumpWriteDump(process.Handle, _procId,
file.SafeFileHandle?.DangerousGetHandle() ?? IntPtr.Zero,
dtype, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero))
{
ret = false;
//Might solve the problem if crashhandler stops working on remote (hah)
Attributes["debug-debug-exception-info"] = exceptionInfo.ToString();
Attributes["debug-debug-thread-id"] = threadId.ToString();
}
else
{
ret = true;
}
file.Flush();
}
return(ret);
}
private bool CreateDump(Process process, IntPtr exceptionInfo, uint threadId, bool debugger)
{
bool ret;
using (FileStream file = File.Create(Path.Combine(WorkingDirectory, "crashdump.dmp")))
{
MiniDumpExceptionInformation info = new MiniDumpExceptionInformation();
info.ClientPointers = true;
info.ExceptionPointers = exceptionInfo;
info.ThreadId = threadId;
MINIDUMP_TYPE dtype = MINIDUMP_TYPE.MiniDumpWithPrivateReadWriteMemory |
MINIDUMP_TYPE.MiniDumpWithDataSegs |
MINIDUMP_TYPE.MiniDumpWithHandleData |
MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo |
MINIDUMP_TYPE.MiniDumpWithThreadInfo |
MINIDUMP_TYPE.MiniDumpWithUnloadedModules;
bool extraInfo = !(exceptionInfo == IntPtr.Zero || threadId == 0 || !debugger);
if (extraInfo)
{
dtype |= 0;
ret = !(DbgHlp.MiniDumpWriteDump(process.Handle, procId, file.SafeFileHandle.DangerousGetHandle(),
dtype, ref info, IntPtr.Zero, IntPtr.Zero));
}
else if (DbgHlp.MiniDumpWriteDump(process.Handle, procId, file.SafeFileHandle.DangerousGetHandle(),
dtype, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero))
{
ret = false;
//Might solve the problem if crashhandler stops working on remote (hah)
Attributes["debug-debug-exception-info"] = exceptionInfo.ToString();
Attributes["debug-debug-thread-id"] = threadId.ToString();
}
else
{
int errorNo = Marshal.GetLastWin32Error();
ret = true;
}
file.Flush();
}
return(ret);
}
public static bool Write(MINIDUMP_TYPE options )
{
string fileName = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, DateTime.Now.ToString("yyyyMMdd-HHmmss") + ".dmp");
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Write))
{
MINIDUMP_EXCEPTION_INFORMATION Mdinfo = new MINIDUMP_EXCEPTION_INFORMATION();
Process currentProcess = Process.GetCurrentProcess();
IntPtr currentProcessHandle = currentProcess.Handle;
uint currentProcessId = (uint)currentProcess.Id;
Mdinfo.ThreadId = CrashDump.GetCurrentThreadId();
Mdinfo.ExceptionPointers = Marshal.GetExceptionPointers();
Mdinfo.ClientPointers = 1;
return MiniDumpWriteDump(currentProcessHandle, currentProcessId, fs.SafeFileHandle, (uint)options, ref Mdinfo, IntPtr.Zero, IntPtr.Zero);
}
}
public static bool Write(string fileName, MINIDUMP_TYPE options, int?threadId = null)
{
var process = Process.GetCurrentProcess();
var processId = process.Id;
int realThreadId;
if (threadId == null)
{
realThreadId = Thread.CurrentThread.ManagedThreadId;
}
else
{
realThreadId = (int)threadId;
}
return(CreateDump(processId, fileName, (Int32)options, realThreadId,
Marshal.GetExceptionPointers()));
}
public static bool Write(MINIDUMP_TYPE options)
{
string fileName = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, DateTime.Now.ToString("yyyyMMdd-HHmmss") + ".dmp");
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Write))
{
MINIDUMP_EXCEPTION_INFORMATION Mdinfo = new MINIDUMP_EXCEPTION_INFORMATION();
Process currentProcess = Process.GetCurrentProcess();
IntPtr currentProcessHandle = currentProcess.Handle;
uint currentProcessId = (uint)currentProcess.Id;
Mdinfo.ThreadId = CrashDump.GetCurrentThreadId();
Mdinfo.ExceptionPointers = Marshal.GetExceptionPointers();
Mdinfo.ClientPointers = 1;
return(MiniDumpWriteDump(currentProcessHandle, currentProcessId, fs.SafeFileHandle, (uint)options, ref Mdinfo, IntPtr.Zero, IntPtr.Zero));
}
}
public static void Main(string path, string process_name)
{
if (path == null) //if no directory is passed, output goes to current working directory
{
path = Directory.GetCurrentDirectory();
}
Process[] process_list = Process.GetProcessesByName(process_name); //get all processes into an array
foreach (Process process in process_list) //create dump for each process
{
UInt32 ProcessId = (uint)process.Id;
IntPtr hProcess = process.Handle;
MINIDUMP_TYPE DumpType = MINIDUMP_TYPE.MiniDumpWithFullMemory;
string out_dump_path = Path.Combine(path, process_name + "_" + ProcessId.ToString() + ".dmp");
FileStream procdumpFileStream = File.Create(out_dump_path);
bool success = MiniDumpWriteDump(hProcess, ProcessId, procdumpFileStream.SafeFileHandle, DumpType, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
}
}
public static void SnapshotAndDump(this Process process, string dumpFile, MINIDUMP_TYPE dumpType)
{
using (var fs = new FileStream(dumpFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
using (var pssSnapshot = PssSnapshotSafeHandle.CaptureSnapshot(process.Handle))
{
bool PssSnapshotMinidumpCallback(IntPtr unused, ref MINIDUMP_CALLBACK_INPUT input, ref MINIDUMP_CALLBACK_OUTPUT output)
{
const int S_OK = 0;
const int S_FALSE = 1;
switch (input.CallbackType)
{
case MINIDUMP_CALLBACK_TYPE.IsProcessSnapshotCallback:
// The target is always a snapshot.
output.Status = S_FALSE;
break;
case MINIDUMP_CALLBACK_TYPE.ReadMemoryFailureCallback:
// Ignore any read failures during dump generation.
output.Status = S_OK;
break;
}
return(true);
}
var callbackParam = new MINIDUMP_CALLBACK_INFORMATION
{
CallbackParam = IntPtr.Zero,
CallbackRoutine = PssSnapshotMinidumpCallback
};
if (!MiniDumpWriteDump(pssSnapshot, (uint)process.Id, fs.SafeFileHandle, dumpType | MINIDUMP_TYPE.IgnoreInaccessibleMemory, IntPtr.Zero, IntPtr.Zero, ref callbackParam))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
}
}
public static bool WriteMiniDump(string dumpFilePath)
{
using (var process = Process.GetCurrentProcess())
{
using (var file = new FileStream(dumpFilePath, FileMode.Create))
{
if (file.SafeFileHandle == null)
{
return(false);
}
// Task manager uses: MiniDumpWithFullMemory | MiniDumpWithHandleData | MiniDumpWithUnloadedModules | MiniDumpWithFullMemoryInfo | MiniDumpWithThreadInfo | MiniDumpIgnoreInaccessibleMemory | MiniDumpWithIptTrace
const MINIDUMP_TYPE flags = MINIDUMP_TYPE.MiniDumpWithDataSegs |
MINIDUMP_TYPE.MiniDumpWithFullMemory |
MINIDUMP_TYPE.MiniDumpWithHandleData |
MINIDUMP_TYPE.MiniDumpScanMemory |
MINIDUMP_TYPE.MiniDumpWithUnloadedModules |
MINIDUMP_TYPE.MiniDumpWithIndirectlyReferencedMemory |
MINIDUMP_TYPE.MiniDumpWithProcessThreadData |
MINIDUMP_TYPE.MiniDumpWithPrivateReadWriteMemory |
MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo |
MINIDUMP_TYPE.MiniDumpWithThreadInfo |
MINIDUMP_TYPE.MiniDumpWithCodeSegs |
MINIDUMP_TYPE.MiniDumpWithFullAuxiliaryState |
MINIDUMP_TYPE.MiniDumpWithPrivateWriteCopyMemory |
MINIDUMP_TYPE.MiniDumpIgnoreInaccessibleMemory |
MINIDUMP_TYPE.MiniDumpWithTokenInformation |
MINIDUMP_TYPE.MiniDumpWithModuleHeaders |
MINIDUMP_TYPE.MiniDumpWithAvxXStateContext |
MINIDUMP_TYPE.MiniDumpWithIptTrace;
return(MiniDumpWriteDump(process.Handle, (uint)process.Id, file.SafeFileHandle.DangerousGetHandle(), flags,
IntPtr.Zero, IntPtr.Zero, IntPtr.Zero));
}
}
}
public static void Create(Process process, string destinationPath)
{
if (process is null)
{
throw new ArgumentNullException(nameof(process));
}
if (destinationPath is null)
{
throw new ArgumentNullException(nameof(destinationPath));
}
using (FileStream fs = File.Create(destinationPath))
{
const MINIDUMP_TYPE MiniDumpType =
MINIDUMP_TYPE.MiniDumpWithFullMemory |
MINIDUMP_TYPE.MiniDumpIgnoreInaccessibleMemory;
if (MiniDumpWriteDump(process.SafeHandle, process.Id, fs.SafeFileHandle, MiniDumpType, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero) == 0)
{
throw new Win32Exception();
}
}
}
public static bool Write(string fileName, MINIDUMP_TYPE DumpType)
{
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
var ExceptionParam = new MINIDUMP_EXCEPTION_INFORMATION
{
ThreadId = GetCurrentThreadId(),
ExceptionPointers = Marshal.GetExceptionPointers(),
ClientPointers = false
};
return(MiniDumpWriteDump
(
GetCurrentProcess(),
GetCurrentProcessId(),
fs.SafeFileHandle,
DumpType,
ref ExceptionParam,
IntPtr.Zero,
IntPtr.Zero
));
}
}
public static extern bool MiniDumpWriteDump(
IntPtr hProcess,
uint ProcessId,
IntPtr hFile,
MINIDUMP_TYPE DumpType,
IntPtr ExceptionParams,
[In] ref MINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
[In] ref MINIDUMP_CALLBACK_INFORMATION CallbackParam
);
public static extern bool MiniDumpWriteDump([System.Runtime.InteropServices.InAttribute()] System.IntPtr hProcess, uint ProcessId, [System.Runtime.InteropServices.InAttribute()] System.IntPtr hFile, MINIDUMP_TYPE DumpType, [System.Runtime.InteropServices.InAttribute()] ref MINIDUMP_EXCEPTION_INFORMATION ExceptionParam);
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 {1:x8}", _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 static extern bool CreateDump(uint ProcessId, string FileName, MINIDUMP_TYPE DumpType, uint ExcThreadId, IntPtr ExtPtrs);
public static void MiniDump(this Process process, string dumpFile, MINIDUMP_TYPE dumpType)
{
using (var fs = new FileStream(dumpFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
if (!MiniDumpNativeMethods.MiniDumpWriteDump(process.Handle, (uint)process.Id, fs.SafeFileHandle, dumpType, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
}
public static extern bool RegisterFilter(string FileName, MINIDUMP_TYPE DumpType);
public static bool Register(string fileName, MINIDUMP_TYPE options)
{
return(RegisterFilter(fileName, (Int32)options));
}
internal static extern DWORD MiniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile, MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
private static extern int MiniDumpWriteDump(IntPtr processHandle, int processId, IntPtr fileHandle, MINIDUMP_TYPE dumpType, IntPtr excepParam, IntPtr userParam, IntPtr callParam);
public static bool Register(string fileName, MINIDUMP_TYPE options)
{
return RegisterFilter(fileName, (Int32)options);
}
