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( 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([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 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); }