2020-08-07 14:37:42 -04:00
using System ;
using System.Runtime.InteropServices ;
2021-02-03 10:41:28 -05:00
using Vanara.InteropServices ;
2020-08-07 14:37:42 -04:00
namespace Vanara.PInvoke
{
public static partial class DbgHelp
{
/// <summary>
/// <para>An application-defined callback function used with MiniDumpWriteDump. It receives extended minidump information.</para>
2021-02-03 10:41:28 -05:00
/// <para>
/// The <c>MINIDUMP_CALLBACK_ROUTINE</c> type defines a pointer to this callback function. <c>MiniDumpCallback</c> is a placeholder
/// for the application-defined function name.
/// </para>
2020-08-07 14:37:42 -04:00
/// </summary>
/// <param name="CallbackParam">An application-defined parameter value.</param>
/// <param name="CallbackInput">A pointer to a MINIDUMP_CALLBACK_INPUT structure that specifies extended minidump information.</param>
2021-02-03 10:41:28 -05:00
/// <param name="CallbackOutput">
/// A pointer to a MINIDUMP_CALLBACK_OUTPUT structure that receives application-defined information from the callback function.
/// </param>
2020-08-07 14:37:42 -04:00
/// <returns>If the function succeeds, return <c>TRUE</c>; otherwise, return <c>FALSE</c>.</returns>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/nc-minidumpapiset-minidump_callback_routine
2021-02-03 10:41:28 -05:00
// MINIDUMP_CALLBACK_ROUTINE MinidumpCallbackRoutine; BOOL MinidumpCallbackRoutine( PVOID CallbackParam, PMINIDUMP_CALLBACK_INPUT
// CallbackInput, PMINIDUMP_CALLBACK_OUTPUT CallbackOutput ) {...}
2020-08-07 14:37:42 -04:00
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("minidumpapiset.h", MSDNShortId = "NC:minidumpapiset.MINIDUMP_CALLBACK_ROUTINE")]
[return: MarshalAs(UnmanagedType.Bool)]
public delegate bool MINIDUMP_CALLBACK_ROUTINE ( [ In , Out ] IntPtr CallbackParam , in MINIDUMP_CALLBACK_INPUT CallbackInput , ref MINIDUMP_CALLBACK_OUTPUT CallbackOutput ) ;
2021-02-03 15:57:49 -05:00
/// <summary>
/// Identifies the type of information returned by the MiniDumpCallback function. Not all memory failures will cause a callback; for
/// example if the failure is within a stack then the failure is considered to be unrecoverable and the minidump will fail.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ne-minidumpapiset-minidump_callback_type typedef enum
// _MINIDUMP_CALLBACK_TYPE { ModuleCallback, ThreadCallback, ThreadExCallback, IncludeThreadCallback, IncludeModuleCallback,
// MemoryCallback, CancelCallback, WriteKernelMinidumpCallback, KernelMinidumpStatusCallback, RemoveMemoryCallback,
// IncludeVmRegionCallback, IoStartCallback, IoWriteAllCallback, IoFinishCallback, ReadMemoryFailureCallback,
// SecondaryFlagsCallback, IsProcessSnapshotCallback, VmStartCallback, VmQueryCallback, VmPreReadCallback, VmPostReadCallback } MINIDUMP_CALLBACK_TYPE;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NE:minidumpapiset._MINIDUMP_CALLBACK_TYPE")]
public enum MINIDUMP_CALLBACK_TYPE
{
/// <summary>The callback function returns module information.</summary>
ModuleCallback ,
/// <summary>The callback function returns thread information.</summary>
ThreadCallback ,
/// <summary>The callback function returns extended thread information.</summary>
ThreadExCallback ,
/// <summary>
/// The callback function indicates which threads are to be included. It is called as the minidump library is enumerating the
/// threads in a process, rather than after the information gathered, as it is with ThreadCallback or ThreadExCallback. It is
/// called for each thread. If the callback function returns FALSE, the current thread is excluded. This allows the caller to
/// obtain information for a subset of the threads in a process, without suspending threads that are not of interest.
/// Alternately, you can modify the ThreadWriteFlags member of the MINIDUMP_CALLBACK_OUTPUT structure and return TRUE to avoid
/// gathering unnecessary information for the thread.
/// </summary>
IncludeThreadCallback ,
/// <summary>
/// The callback function indicates which modules are to be included. The callback function is called as the minidump library is
/// enumerating the modules in a process, rather than after the information is gathered, as it is with ModuleCallback. It is
/// called for each module. If the callback function returns FALSE, the current module is excluded. Alternatively, you can
/// modify the ModuleWriteFlags member of the MINIDUMP_CALLBACK_OUTPUT structure and return TRUE to avoid gathering unnecessary
/// information for the module.
/// </summary>
IncludeModuleCallback ,
/// <summary>
/// The callback function returns a region of memory to be included in the dump. The callback is called only for dumps generated
/// without the MiniDumpWithFullMemory flag. If the callback function returns FALSE or a region of size 0, the callback will not
/// be called again. DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
MemoryCallback ,
/// <summary>The callback function returns cancellation information. DbgHelp 6.1 and earlier: This value is not supported.</summary>
CancelCallback ,
/// <summary>
/// The user-mode minidump has been successfully completed. To initiate a kernel-mode minidump, the callback should return TRUE
/// and set the Handle member of the MINIDUMP_CALLBACK_OUTPUT structure. DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
WriteKernelMinidumpCallback ,
/// <summary>
/// The callback function returns status information for the kernel minidump. DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
KernelMinidumpStatusCallback ,
/// <summary>
/// The callback function returns a region of memory to be excluded from the dump. The callback is called only for dumps
/// generated without the MiniDumpWithFullMemory flag. If the callback function returns FALSE or a region of size 0, the
/// callback will not be called again. DbgHelp 6.3 and earlier: This value is not supported.
/// </summary>
RemoveMemoryCallback ,
/// <summary>
/// The callback function returns information about the virtual memory region. It is called twice for each region during the
/// full-memory writing pass. The VmRegion member of the MINIDUMP_CALLBACK_OUTPUT structure contains the current memory region.
/// You can modify the base address and size of the region, as long as the new region remains a subset of the original region;
/// changes to other members are ignored. If the callback returns TRUE and sets the Continue member of MINIDUMP_CALLBACK_OUTPUT
/// to TRUE, the minidump library will use the region specified by VmRegion as the region to be written. If the callback returns
/// FALSE or if Continue is FALSE, the callback will not be called for additional memory regions. DbgHelp 6.4 and earlier: This
/// value is not supported.
/// </summary>
IncludeVmRegionCallback ,
/// <summary>
/// The callback function indicates that the caller will be providing an alternate I/O routine. If the callback returns TRUE and
/// sets the Status member of MINIDUMP_CALLBACK_OUTPUT to S_FALSE, the minidump library will send all I/O through callbacks. The
/// caller will receive an IoWriteAllCallback callback for each piece of data. DbgHelp 6.4 and earlier: This value is not supported.
/// </summary>
IoStartCallback ,
/// <summary>
/// The callback must write all requested bytes or fail. The Io member of the MINIDUMP_CALLBACK_INPUT structure contains the
/// request. If the write operation fails, the callback should return FALSE. If the write operation succeeds, the callback
/// should return TRUE and set the Status member of MINIDUMP_CALLBACK_OUTPUT to S_OK. The caller will receive an
/// IoFinishCallback callback when the I/O has completed. DbgHelp 6.4 and earlier: This value is not supported.
/// </summary>
IoWriteAllCallback ,
/// <summary>
/// The callback returns I/O completion information. If the callback returns FALSE or does not set the Status member of
/// MINIDUMP_CALLBACK_OUTPUT to S_OK, the minidump library assumes the minidump write operation has failed. DbgHelp 6.4 and
/// earlier: This value is not supported.
/// </summary>
IoFinishCallback ,
/// <summary>
/// There has been a failure to read memory. If the callback returns TRUE and sets the Status member of MINIDUMP_CALLBACK_OUTPUT
/// to S_OK, the memory failure is ignored and the block is omitted from the minidump. Otherwise, this failure results in a
/// failure to write to the minidump. DbgHelp 6.4 and earlier: This value is not supported.
/// </summary>
ReadMemoryFailureCallback ,
/// <summary>The callback returns secondary information. DbgHelp 6.5 and earlier: This value is not supported.</summary>
SecondaryFlagsCallback ,
/// <summary>
/// The callback function indicates whether the target is a process or a snapshot.DbgHelp 6.2 and earlier: This value is not supported.
/// </summary>
IsProcessSnapshotCallback ,
/// <summary>
/// The callback function indicates whether the callee supports and accepts virtual memory callbacks, such as VmQueryCallback,
/// VmPreReadCallback, and VmPostReadCallback. A return value of S_FALSE means that virtual memory callbacks are supported. A
/// value of S_OK means that virtual memory callbacks are not supported.DbgHelp 6.2 and earlier: This value is not supported.
/// </summary>
VmStartCallback ,
/// <summary>
/// The callback function is invoked for snapshot targets to collect virtual address memory information from the target.The
/// callback is only called if VmStartCallback returned a value of S_FALSE.DbgHelp 6.2 and earlier: This value is not supported.
/// </summary>
VmQueryCallback ,
/// <summary>
/// The callback function is sent for every ReadVirtual operation. These reads are not limited to the memory blocks that are
/// added to the dump. The engine also accesses the Process Environment Block (PEB), the Thread Environment Block (TEB), the
/// loader data, the unloaded module traces, and other blocks. Even if those blocks do not end up in the dump, they are read
/// from the target, and virtual memory callbacks are initiated for each. The callback is only called if VmStartCallback
/// returned S_FALSE.DbgHelp 6.2 and earlier: This value is not supported.
/// </summary>
VmPreReadCallback ,
/// <summary>
/// The callback function allows the callee to alter the buffer contents with data from other sources, such as a cache, or
/// perform obfuscation. The buffer at this point is fully or partially filled by VmPreReadCallback and by ReadProcessMemory.
/// The callback is only called if VmStartCallback returned S_FALSE.DbgHelp 6.2 and earlier: This value is not supported.
/// </summary>
VmPostReadCallback ,
}
/// <summary>Identifies the type of object-specific information.</summary>
/// <remarks>
/// The information represented by each of these values can vary by operating system and procesor architecture. Per-handle
/// object-specific information is automatically gathered when minidump type is MiniDumpWithHandleData. For more information, see MINIDUMP_TYPE.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ne-minidumpapiset-minidump_handle_object_information_type
// typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE { MiniHandleObjectInformationNone, MiniThreadInformation1,
// MiniMutantInformation1, MiniMutantInformation2, MiniProcessInformation1, MiniProcessInformation2, MiniEventInformation1,
// MiniSectionInformation1, MiniSemaphoreInformation1, MiniHandleObjectInformationTypeMax } MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NE:minidumpapiset._MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE")]
public enum MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE
{
/// <summary>There is no object-specific information for this handle type.</summary>
MiniHandleObjectInformationNone ,
/// <summary>The information is specific to thread objects.</summary>
MiniThreadInformation1 ,
/// <summary>The information is specific to mutant objects.</summary>
MiniMutantInformation1 ,
/// <summary>The information is specific to mutant objects.</summary>
MiniMutantInformation2 ,
/// <summary>The information is specific to process objects.</summary>
MiniProcessInformation1 ,
/// <summary>The information is specific to process objects.</summary>
MiniProcessInformation2 ,
/// <summary/>
MiniEventInformation1 ,
/// <summary/>
MiniSectionInformation1 ,
/// <summary/>
MiniSemaphoreInformation1 ,
/// <summary/>
MiniHandleObjectInformationTypeMax ,
}
/// <summary>Specifies the secondary flags for the minidump.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ne-minidumpapiset-minidump_secondary_flags typedef enum
// _MINIDUMP_SECONDARY_FLAGS { MiniSecondaryWithoutPowerInfo, MiniSecondaryValidFlags } MINIDUMP_SECONDARY_FLAGS;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NE:minidumpapiset._MINIDUMP_SECONDARY_FLAGS")]
[Flags]
public enum MINIDUMP_SECONDARY_FLAGS
{
/// <summary>
/// The minidump information does not retrieve the processor power information contained in the MINIDUMP_MISC_INFO_2 structure.
/// </summary>
MiniSecondaryWithoutPowerInfo = 1 ,
/// <summary/>
MiniSecondaryValidFlags = 1 ,
}
/// <summary>Represents the type of a minidump data stream.</summary>
/// <remarks>
/// <para>In this context, a data stream is a set of data in a minidump file.</para>
/// <para>
/// The <c>StreamType</c> member of the MINIDUMP_DIRECTORY structure can be one of these types. Additional types may be added in the
/// future, so if a program reading the minidump header encounters a stream type it does not recognize, it should ignore the stream altogether.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ne-minidumpapiset-minidump_stream_type typedef enum
// _MINIDUMP_STREAM_TYPE { UnusedStream, ReservedStream0, ReservedStream1, ThreadListStream, ModuleListStream, MemoryListStream,
// ExceptionStream, SystemInfoStream, ThreadExListStream, Memory64ListStream, CommentStreamA, CommentStreamW, HandleDataStream,
// FunctionTableStream, UnloadedModuleListStream, MiscInfoStream, MemoryInfoListStream, ThreadInfoListStream,
// HandleOperationListStream, TokenStream, JavaScriptDataStream, SystemMemoryInfoStream, ProcessVmCountersStream, IptTraceStream,
// ThreadNamesStream, ceStreamNull, ceStreamSystemInfo, ceStreamException, ceStreamModuleList, ceStreamProcessList,
// ceStreamThreadList, ceStreamThreadContextList, ceStreamThreadCallStackList, ceStreamMemoryVirtualList,
// ceStreamMemoryPhysicalList, ceStreamBucketParameters, ceStreamProcessModuleMap, ceStreamDiagnosisList, LastReservedStream } MINIDUMP_STREAM_TYPE;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NE:minidumpapiset._MINIDUMP_STREAM_TYPE")]
public enum MINIDUMP_STREAM_TYPE
{
/// <summary>Reserved. Do not use this enumeration value.</summary>
UnusedStream ,
/// <summary>Reserved. Do not use this enumeration value.</summary>
ReservedStream0 ,
/// <summary>Reserved. Do not use this enumeration value.</summary>
ReservedStream1 ,
/// <summary>The stream contains thread information. For more information, see MINIDUMP_THREAD_LIST.</summary>
ThreadListStream ,
/// <summary>The stream contains module information. For more information, see MINIDUMP_MODULE_LIST.</summary>
ModuleListStream ,
/// <summary>The stream contains memory allocation information. For more information, see MINIDUMP_MEMORY_LIST.</summary>
MemoryListStream ,
/// <summary>The stream contains exception information. For more information, see MINIDUMP_EXCEPTION_STREAM.</summary>
ExceptionStream ,
/// <summary>The stream contains general system information. For more information, see MINIDUMP_SYSTEM_INFO.</summary>
SystemInfoStream ,
/// <summary>The stream contains extended thread information. For more information, see MINIDUMP_THREAD_EX_LIST.</summary>
ThreadExListStream ,
/// <summary>The stream contains memory allocation information. For more information, see MINIDUMP_MEMORY64_LIST.</summary>
Memory64ListStream ,
/// <summary>The stream contains an ANSI string used for documentation purposes.</summary>
CommentStreamA ,
/// <summary>The stream contains a Unicode string used for documentation purposes.</summary>
CommentStreamW ,
/// <summary>
/// The stream contains high-level information about the active operating system handles. For more information, see MINIDUMP_HANDLE_DATA_STREAM.
/// </summary>
HandleDataStream ,
/// <summary>The stream contains function table information. For more information, see MINIDUMP_FUNCTION_TABLE_STREAM.</summary>
FunctionTableStream ,
/// <summary>
/// The stream contains module information for the unloaded modules. For more information, see
/// MINIDUMP_UNLOADED_MODULE_LIST.DbgHelp 5.1: This value is not supported.
/// </summary>
UnloadedModuleListStream ,
/// <summary>
/// The stream contains miscellaneous information. For more information, see MINIDUMP_MISC_INFO or MINIDUMP_MISC_INFO_2.DbgHelp
/// 5.1: This value is not supported.
/// </summary>
MiscInfoStream ,
/// <summary>
/// The stream contains memory region description information. It corresponds to the information that would be returned for the
/// process from the VirtualQuery function. For more information, see MINIDUMP_MEMORY_INFO_LIST.DbgHelp 6.1 and earlier: This
/// value is not supported.
/// </summary>
MemoryInfoListStream ,
/// <summary>
/// The stream contains thread state information. For more information, see MINIDUMP_THREAD_INFO_LIST.DbgHelp 6.1 and earlier:
/// This value is not supported.
/// </summary>
ThreadInfoListStream ,
/// <summary>
/// This stream contains operation list information. For more information, see MINIDUMP_HANDLE_OPERATION_LIST.DbgHelp 6.4 and
/// earlier: This value is not supported.
/// </summary>
HandleOperationListStream ,
/// <summary/>
TokenStream ,
/// <summary/>
JavaScriptDataStream ,
/// <summary/>
SystemMemoryInfoStream ,
/// <summary/>
ProcessVmCountersStream ,
/// <summary/>
IptTraceStream ,
/// <summary/>
ThreadNamesStream ,
/// <summary/>
ceStreamNull = 0x8000 ,
/// <summary/>
ceStreamSystemInfo ,
/// <summary/>
ceStreamException ,
/// <summary/>
ceStreamModuleList ,
/// <summary/>
ceStreamProcessList ,
/// <summary/>
ceStreamThreadList ,
/// <summary/>
ceStreamThreadContextList ,
/// <summary/>
ceStreamThreadCallStackList ,
/// <summary/>
ceStreamMemoryVirtualList ,
/// <summary/>
ceStreamMemoryPhysicalList ,
/// <summary/>
ceStreamBucketParameters ,
/// <summary/>
ceStreamProcessModuleMap ,
/// <summary/>
ceStreamDiagnosisList ,
/// <summary>
/// Any value greater than this value will not be used by the system and can be used to represent application-defined data
/// streams. For more information, see MINIDUMP_USER_STREAM.
/// </summary>
LastReservedStream = 0xffff ,
}
2021-02-03 10:41:28 -05:00
/// <summary>The flags that indicate the thread state.</summary>
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_INFO")]
[Flags]
public enum MINIDUMP_THREAD_INFO_FLAG : uint
{
/// <summary>A placeholder thread due to an error accessing the thread. No thread information exists beyond the thread identifier.</summary>
MINIDUMP_THREAD_INFO_ERROR_THREAD = 0x00000001 ,
/// <summary>The thread has exited (not running any code) at the time of the dump.</summary>
MINIDUMP_THREAD_INFO_EXITED_THREAD = 0x00000004 ,
/// <summary>Thread context could not be retrieved.</summary>
MINIDUMP_THREAD_INFO_INVALID_CONTEXT = 0x00000010 ,
/// <summary>Thread information could not be retrieved.</summary>
MINIDUMP_THREAD_INFO_INVALID_INFO = 0x00000008 ,
/// <summary>TEB information could not be retrieved.</summary>
MINIDUMP_THREAD_INFO_INVALID_TEB = 0x00000020 ,
/// <summary>This is the thread that called MiniDumpWriteDump.</summary>
MINIDUMP_THREAD_INFO_WRITING_THREAD = 0x00000002 ,
}
2021-02-03 15:57:49 -05:00
/// <summary>
/// <para>Identifies the type of information that will be written to the minidump file by the MiniDumpWriteDump function.</para>
/// <para><c>Important</c></para>
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ne-minidumpapiset-minidump_type typedef enum _MINIDUMP_TYPE {
// MiniDumpNormal, MiniDumpWithDataSegs, MiniDumpWithFullMemory, MiniDumpWithHandleData, MiniDumpFilterMemory, MiniDumpScanMemory,
// MiniDumpWithUnloadedModules, MiniDumpWithIndirectlyReferencedMemory, MiniDumpFilterModulePaths, MiniDumpWithProcessThreadData,
// MiniDumpWithPrivateReadWriteMemory, MiniDumpWithoutOptionalData, MiniDumpWithFullMemoryInfo, MiniDumpWithThreadInfo,
// MiniDumpWithCodeSegs, MiniDumpWithoutAuxiliaryState, MiniDumpWithFullAuxiliaryState, MiniDumpWithPrivateWriteCopyMemory,
// MiniDumpIgnoreInaccessibleMemory, MiniDumpWithTokenInformation, MiniDumpWithModuleHeaders, MiniDumpFilterTriage,
// MiniDumpWithAvxXStateContext, MiniDumpWithIptTrace, MiniDumpScanInaccessiblePartialPages, MiniDumpValidTypeFlags } MINIDUMP_TYPE;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NE:minidumpapiset._MINIDUMP_TYPE")]
[Flags]
public enum MINIDUMP_TYPE
{
/// <summary>Include just the information necessary to capture stack traces for all existing threads in a process.</summary>
MiniDumpNormal = 0x00000000 ,
/// <summary>
/// Include the data sections from all loaded modules. This results in the inclusion of global variables, which can make the
/// minidump file significantly larger. For per-module control, use the ModuleWriteDataSeg enumeration value from MODULE_WRITE_FLAGS.
/// </summary>
MiniDumpWithDataSegs = 0x00000001 ,
/// <summary>
/// Include all accessible memory in the process. The raw memory data is included at the end, so that the initial structures can
/// be mapped directly without the raw memory information. This option can result in a very large file.
/// </summary>
MiniDumpWithFullMemory = 0x00000002 ,
/// <summary>Include high-level information about the operating system handles that are active when the minidump is made.</summary>
MiniDumpWithHandleData = 0x00000004 ,
/// <summary>
/// Stack and backing store memory written to the minidump file should be filtered to remove all but the pointer values
/// necessary to reconstruct a stack trace.
/// </summary>
MiniDumpFilterMemory = 0x00000008 ,
/// <summary>
/// Stack and backing store memory should be scanned for pointer references to modules in the module list. If a module is
/// referenced by stack or backing store memory, the ModuleWriteFlags member of the MINIDUMP_CALLBACK_OUTPUT structure is set to ModuleReferencedByMemory.
/// </summary>
MiniDumpScanMemory = 0x00000010 ,
/// <summary>
/// Include information from the list of modules that were recently unloaded, if this information is maintained by the operating
/// system. Windows Server 2003 and Windows XP: The operating system does not maintain information for unloaded modules until
/// Windows Server 2003 with SP1 and Windows XP with SP2.DbgHelp 5.1: This value is not supported.
/// </summary>
MiniDumpWithUnloadedModules = 0x00000020 ,
/// <summary>
/// Include pages with data referenced by locals or other stack memory. This option can increase the size of the minidump file
/// significantly. DbgHelp 5.1: This value is not supported.
/// </summary>
MiniDumpWithIndirectlyReferencedMemory = 0x00000040 ,
/// <summary>
/// Filter module paths for information such as user names or important directories. This option may prevent the system from
/// locating the image file and should be used only in special situations. DbgHelp 5.1: This value is not supported.
/// </summary>
MiniDumpFilterModulePaths = 0x00000080 ,
/// <summary>
/// Include complete per-process and per-thread information from the operating system. DbgHelp 5.1: This value is not supported.
/// </summary>
MiniDumpWithProcessThreadData = 0x00000100 ,
/// <summary>Scan the virtual address space for PAGE_READWRITE memory to be included. DbgHelp 5.1: This value is not supported.</summary>
MiniDumpWithPrivateReadWriteMemory = 0x00000200 ,
/// <summary>
/// Reduce the data that is dumped by eliminating memory regions that are not essential to meet criteria specified for the dump.
/// This can avoid dumping memory that may contain data that is private to the user. However, it is not a guarantee that no
/// private information will be present. DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
MiniDumpWithoutOptionalData = 0x00000400 ,
/// <summary>
/// Include memory region information. For more information, see MINIDUMP_MEMORY_INFO_LIST. DbgHelp 6.1 and earlier: This value
/// is not supported.
/// </summary>
MiniDumpWithFullMemoryInfo = 0x00000800 ,
/// <summary>
/// Include thread state information. For more information, see MINIDUMP_THREAD_INFO_LIST. DbgHelp 6.1 and earlier: This value
/// is not supported.
/// </summary>
MiniDumpWithThreadInfo = 0x00001000 ,
/// <summary>
/// Include all code and code-related sections from loaded modules to capture executable content. For per-module control, use
/// the ModuleWriteCodeSegs enumeration value from MODULE_WRITE_FLAGS. DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
MiniDumpWithCodeSegs = 0x00002000 ,
/// <summary>Turns off secondary auxiliary-supported memory gathering.</summary>
MiniDumpWithoutAuxiliaryState = 0x00004000 ,
/// <summary>
/// Requests that auxiliary data providers include their state in the dump image; the state data that is included is provider
/// dependent. This option can result in a large dump image.
/// </summary>
MiniDumpWithFullAuxiliaryState = 0x00008000 ,
/// <summary>
/// Scans the virtual address space for PAGE_WRITECOPY memory to be included. Prior to DbgHelp 6.1: This value is not supported.
/// </summary>
MiniDumpWithPrivateWriteCopyMemory = 0x00010000 ,
/// <summary>
/// If you specify MiniDumpWithFullMemory, the MiniDumpWriteDump function will fail if the function cannot read the memory
/// regions; however, if you include MiniDumpIgnoreInaccessibleMemory, the MiniDumpWriteDump function will ignore the memory
/// read failures and continue to generate the dump. Note that the inaccessible memory regions are not included in the
/// dump.Prior to DbgHelp 6.1: This value is not supported.
/// </summary>
MiniDumpIgnoreInaccessibleMemory = 0x00020000 ,
/// <summary>
/// Adds security token related data. This will make the "!token" extension work when processing a user-mode dump. Prior to
/// DbgHelp 6.1: This value is not supported.
/// </summary>
MiniDumpWithTokenInformation = 0x00040000 ,
/// <summary>Adds module header related data. Prior to DbgHelp 6.1: This value is not supported.</summary>
MiniDumpWithModuleHeaders = 0x00080000 ,
/// <summary>Adds filter triage related data. Prior to DbgHelp 6.1: This value is not supported.</summary>
MiniDumpFilterTriage = 0x00100000 ,
/// <summary/>
MiniDumpWithAvxXStateContext = 0x00200000 ,
/// <summary/>
MiniDumpWithIptTrace = 0x00400000 ,
/// <summary>Indicates which flags are valid.</summary>
MiniDumpValidTypeFlags = 0x00800000 ,
}
/// <summary>Identifies the type of module information that will be written to the minidump file by the MiniDumpWriteDump function.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ne-minidumpapiset-module_write_flags typedef enum
// _MODULE_WRITE_FLAGS { ModuleWriteModule, ModuleWriteDataSeg, ModuleWriteMiscRecord, ModuleWriteCvRecord,
// ModuleReferencedByMemory, ModuleWriteTlsData, ModuleWriteCodeSegs } MODULE_WRITE_FLAGS;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NE:minidumpapiset._MODULE_WRITE_FLAGS")]
[Flags]
public enum MODULE_WRITE_FLAGS
{
/// <summary>Only module information will be written to the minidump file.</summary>
ModuleWriteModule = 0x0001 ,
/// <summary>
/// Module and data segment information will be written to the minidump file. This value will only be set if the
/// MiniDumpWithDataSegs enumeration value from MINIDUMP_TYPE is set.
/// </summary>
ModuleWriteDataSeg = 0x0002 ,
/// <summary>Module, data segment, and miscellaneous record information will be written to the minidump file.</summary>
ModuleWriteMiscRecord = 0x0004 ,
/// <summary>
/// CodeView information will be written to the minidump file. Some debuggers need the CodeView information to properly locate symbols.
/// </summary>
ModuleWriteCvRecord = 0x0008 ,
/// <summary>
/// Indicates that a module was referenced by a pointer on the stack or backing store of a thread in the minidump. This value is
/// valid only if the DumpType parameter of the MiniDumpWriteDump function includes MiniDumpScanMemory.
/// </summary>
ModuleReferencedByMemory = 0x0010 ,
/// <summary>
/// Per-module automatic TLS data is written to the minidump file. (Note that automatic TLS data is created using
/// __declspec(thread) while TlsAlloc creates dynamic TLS data). This value is valid only if the DumpType parameter of the
/// MiniDumpWriteDump function includes MiniDumpWithProcessThreadData.DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
ModuleWriteTlsData = 0x0020 ,
/// <summary>
/// Code segment information will be written to the minidump file. This value will only be set if the MiniDumpWithCodeSegs
/// enumeration value from MINIDUMP_TYPE is set.DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
ModuleWriteCodeSegs = 0x0040 ,
}
/// <summary>Identifies the type of thread information that will be written to the minidump file by the MiniDumpWriteDump function.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ne-minidumpapiset-thread_write_flags typedef enum
// _THREAD_WRITE_FLAGS { ThreadWriteThread, ThreadWriteStack, ThreadWriteContext, ThreadWriteBackingStore,
// ThreadWriteInstructionWindow, ThreadWriteThreadData, ThreadWriteThreadInfo } THREAD_WRITE_FLAGS;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NE:minidumpapiset._THREAD_WRITE_FLAGS")]
public enum THREAD_WRITE_FLAGS
{
/// <summary>Only basic thread information will be written to the minidump file.</summary>
ThreadWriteThread ,
/// <summary>Basic thread and thread stack information will be written to the minidump file.</summary>
ThreadWriteStack ,
/// <summary>The entire thread context will be written to the minidump file.</summary>
ThreadWriteContext ,
/// <summary>Intel Itanium: The backing store memory of every thread will be written to the minidump file.</summary>
ThreadWriteBackingStore ,
/// <summary>
/// A small amount of memory surrounding each thread's instruction pointer will be written to the minidump file. This allows
/// instructions near a thread's instruction pointer to be disassembled even if an executable image matching the module cannot
/// be found.
/// </summary>
ThreadWriteInstructionWindow ,
/// <summary>
/// When the minidump type includes MiniDumpWithProcessThreadData, this flag is set. The callback function can clear this flag
/// to control which threads provide complete thread data in the minidump file.DbgHelp 5.1: This value is not supported.
/// </summary>
ThreadWriteThreadData ,
/// <summary>
/// When the minidump type includes MiniDumpWithThreadInfo, this flag is set. The callback function can clear this flag to
/// control which threads provide thread state information in the minidump file. For more information, see
/// MINIDUMP_THREAD_INFO.DbgHelp 6.1 and earlier: This value is not supported.
/// </summary>
ThreadWriteThreadInfo ,
}
2020-08-07 14:37:42 -04:00
/// <summary>Reads a stream from a user-mode minidump file.</summary>
2021-02-03 10:41:28 -05:00
/// <param name="BaseOfDump">
/// A pointer to the base of the mapped minidump file. The file should have been mapped into memory using the MapViewOfFile function.
/// </param>
/// <param name="StreamNumber">
/// The type of data to be read from the minidump file. This member can be one of the values in the MINIDUMP_STREAM_TYPE enumeration.
/// </param>
2020-08-07 14:37:42 -04:00
/// <param name="Dir">A pointer to a MINIDUMP_DIRECTORY structure.</param>
2021-02-03 10:41:28 -05:00
/// <param name="StreamPointer">
/// A pointer to the beginning of the minidump stream. The format of this stream depends on the value of StreamNumber. For more
/// information, see MINIDUMP_STREAM_TYPE.
/// </param>
2020-08-07 14:37:42 -04:00
/// <param name="StreamSize">The size of the stream pointed to by StreamPointer, in bytes.</param>
/// <returns>If the function succeeds, the return value is <c>TRUE</c>; otherwise, the return value is <c>FALSE</c>.</returns>
/// <remarks>In this context, a data stream is a block of data written to a minidump file.</remarks>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/nf-minidumpapiset-minidumpreaddumpstream BOOL
// MiniDumpReadDumpStream( PVOID BaseOfDump, ULONG StreamNumber, PMINIDUMP_DIRECTORY *Dir, PVOID *StreamPointer, ULONG *StreamSize );
2021-02-03 15:57:49 -05:00
[DllImport(Lib_DbgHelp, SetLastError = false, ExactSpelling = true)]
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NF:minidumpapiset.MiniDumpReadDumpStream")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool MiniDumpReadDumpStream ( [ In ] IntPtr BaseOfDump , uint StreamNumber , out IntPtr Dir , out IntPtr StreamPointer , out uint StreamSize ) ;
/// <summary>Writes user-mode minidump information to the specified file.</summary>
/// <param name="hProcess">
/// <para>A handle to the process for which the information is to be generated.</para>
2021-02-03 10:41:28 -05:00
/// <para>
/// This handle must have <c>PROCESS_QUERY_INFORMATION</c> and <c>PROCESS_VM_READ</c> access to the process. If handle information
/// is to be collected then <c>PROCESS_DUP_HANDLE</c> access is also required. For more information, see Process Security and Access
/// Rights. The caller must also be able to get <c>THREAD_ALL_ACCESS</c> access to the threads in the process. For more information,
/// see Thread Security and Access Rights.
/// </para>
/// </param>
/// <param name="ProcessId">The identifier of the process for which the information is to be generated.</param>
/// <param name="hFile">A handle to the file in which the information is to be written.</param>
/// <param name="DumpType">
/// The type of information to be generated. This parameter can be one or more of the values from the MINIDUMP_TYPE enumeration.
/// </param>
/// <param name="ExceptionParam">
/// A pointer to a MINIDUMP_EXCEPTION_INFORMATION structure describing the client exception that caused the minidump to be
/// generated. If the value of this parameter is <c>NULL</c>, no exception information is included in the minidump file.
/// </param>
/// <param name="UserStreamParam">
/// A pointer to a MINIDUMP_USER_STREAM_INFORMATION structure. If the value of this parameter is <c>NULL</c>, no user-defined
/// information is included in the minidump file.
/// </param>
/// <param name="CallbackParam">
/// A pointer to a MINIDUMP_CALLBACK_INFORMATION structure that specifies a callback routine which is to receive extended minidump
/// information. If the value of this parameter is <c>NULL</c>, no callbacks are performed.
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is <c>TRUE</c>; otherwise, the return value is <c>FALSE</c>. To retrieve extended
/// error information, call GetLastError. Note that the last error will be an <c>HRESULT</c> value.
/// </para>
/// <para>If the operation is canceled, the last error code is
/// <code>HRESULT_FROM_WIN32(ERROR_CANCELLED)</code>
/// .
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// The MiniDumpCallback function receives extended minidump information from <c>MiniDumpWriteDump</c>. It also provides a way for
/// the caller to determine the granularity of information written to the minidump file, as the callback function can filter the
/// default information.
/// </para>
/// <para>
/// <c>MiniDumpWriteDump</c> should be called from a separate process if at all possible, rather than from within the target process
/// being dumped. This is especially true when the target process is already not stable. For example, if it just crashed. A loader
/// deadlock is one of many potential side effects of calling <c>MiniDumpWriteDump</c> from within the target process.
/// </para>
/// <para>
/// <c>MiniDumpWriteDump</c> may not produce a valid stack trace for the calling thread. To work around this problem, you must
/// capture the state of the calling thread before calling <c>MiniDumpWriteDump</c> and use it as the ExceptionParam parameter. One
/// way to do this is to force an exception inside a <c>__try</c>/ <c>__except</c> block and use the EXCEPTION_POINTERS information
/// provided by GetExceptionInformation. Alternatively, you can call the function from a new worker thread and filter this worker
/// thread from the dump.
/// </para>
/// <para>
/// All DbgHelp functions, such as this one, are single threaded. Therefore, calls from more than one thread to this function will
/// likely result in unexpected behavior or memory corruption. To avoid this, you must synchronize all concurrent calls from more
/// than one thread to this function.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/nf-minidumpapiset-minidumpwritedump BOOL MiniDumpWriteDump(
// HANDLE hProcess, DWORD ProcessId, HANDLE hFile, MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
// PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam );
2021-02-03 15:57:49 -05:00
[DllImport(Lib_DbgHelp, SetLastError = true, ExactSpelling = true)]
2021-02-03 10:41:28 -05:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NF:minidumpapiset.MiniDumpWriteDump")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern unsafe bool MiniDumpWriteDump ( HPROCESS hProcess , uint ProcessId , HFILE hFile , MINIDUMP_TYPE DumpType ,
[In, Optional] in MINIDUMP_EXCEPTION_INFORMATION ExceptionParam , [ In , Optional ] in MINIDUMP_USER_STREAM_INFORMATION UserStreamParam ,
[In, Optional] in MINIDUMP_CALLBACK_INFORMATION CallbackParam ) ;
/// <summary>Writes user-mode minidump information to the specified file.</summary>
/// <param name="hProcess">
/// <para>A handle to the process for which the information is to be generated.</para>
/// <para>
/// This handle must have <c>PROCESS_QUERY_INFORMATION</c> and <c>PROCESS_VM_READ</c> access to the process. If handle information
/// is to be collected then <c>PROCESS_DUP_HANDLE</c> access is also required. For more information, see Process Security and Access
/// Rights. The caller must also be able to get <c>THREAD_ALL_ACCESS</c> access to the threads in the process. For more information,
/// see Thread Security and Access Rights.
/// </para>
2020-08-07 14:37:42 -04:00
/// </param>
/// <param name="ProcessId">The identifier of the process for which the information is to be generated.</param>
2021-02-03 16:49:31 -05:00
/// <param name="hFile">A handle to the file in which the information is to be written.</param>
/// <param name="DumpType">
/// The type of information to be generated. This parameter can be one or more of the values from the MINIDUMP_TYPE enumeration.
/// </param>
/// <param name="ExceptionParam">
/// A pointer to a MINIDUMP_EXCEPTION_INFORMATION structure describing the client exception that caused the minidump to be
/// generated. If the value of this parameter is <c>NULL</c>, no exception information is included in the minidump file.
/// </param>
/// <param name="UserStreamParam">
/// A pointer to a MINIDUMP_USER_STREAM_INFORMATION structure. If the value of this parameter is <c>NULL</c>, no user-defined
/// information is included in the minidump file.
/// </param>
/// <param name="CallbackParam">
/// A pointer to a MINIDUMP_CALLBACK_INFORMATION structure that specifies a callback routine which is to receive extended minidump
/// information. If the value of this parameter is <c>NULL</c>, no callbacks are performed.
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is <c>TRUE</c>; otherwise, the return value is <c>FALSE</c>. To retrieve extended
/// error information, call GetLastError. Note that the last error will be an <c>HRESULT</c> value.
/// </para>
/// <para>If the operation is canceled, the last error code is
/// <code>HRESULT_FROM_WIN32(ERROR_CANCELLED)</code>
/// .
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// The MiniDumpCallback function receives extended minidump information from <c>MiniDumpWriteDump</c>. It also provides a way for
/// the caller to determine the granularity of information written to the minidump file, as the callback function can filter the
/// default information.
/// </para>
/// <para>
/// <c>MiniDumpWriteDump</c> should be called from a separate process if at all possible, rather than from within the target process
/// being dumped. This is especially true when the target process is already not stable. For example, if it just crashed. A loader
/// deadlock is one of many potential side effects of calling <c>MiniDumpWriteDump</c> from within the target process.
/// </para>
/// <para>
/// <c>MiniDumpWriteDump</c> may not produce a valid stack trace for the calling thread. To work around this problem, you must
/// capture the state of the calling thread before calling <c>MiniDumpWriteDump</c> and use it as the ExceptionParam parameter. One
/// way to do this is to force an exception inside a <c>__try</c>/ <c>__except</c> block and use the EXCEPTION_POINTERS information
/// provided by GetExceptionInformation. Alternatively, you can call the function from a new worker thread and filter this worker
/// thread from the dump.
/// </para>
/// <para>
/// All DbgHelp functions, such as this one, are single threaded. Therefore, calls from more than one thread to this function will
/// likely result in unexpected behavior or memory corruption. To avoid this, you must synchronize all concurrent calls from more
/// than one thread to this function.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/nf-minidumpapiset-minidumpwritedump BOOL MiniDumpWriteDump(
// HANDLE hProcess, DWORD ProcessId, HANDLE hFile, MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
// PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam );
[DllImport(Lib_DbgHelp, SetLastError = true, ExactSpelling = true)]
[PInvokeData("minidumpapiset.h", MSDNShortId = "NF:minidumpapiset.MiniDumpWriteDump")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern unsafe bool MiniDumpWriteDump ( HPROCESS hProcess , uint ProcessId , HFILE hFile , MINIDUMP_TYPE DumpType ,
[In, Optional] in MINIDUMP_EXCEPTION_INFORMATION ExceptionParam , [ In , Optional ] IntPtr UserStreamParam ,
[In, Optional] IntPtr CallbackParam ) ;
/// <summary>Writes user-mode minidump information to the specified file.</summary>
/// <param name="hProcess">
/// <para>A handle to the process for which the information is to be generated.</para>
/// <para>
/// This handle must have <c>PROCESS_QUERY_INFORMATION</c> and <c>PROCESS_VM_READ</c> access to the process. If handle information
/// is to be collected then <c>PROCESS_DUP_HANDLE</c> access is also required. For more information, see Process Security and Access
/// Rights. The caller must also be able to get <c>THREAD_ALL_ACCESS</c> access to the threads in the process. For more information,
/// see Thread Security and Access Rights.
/// </para>
/// </param>
/// <param name="ProcessId">The identifier of the process for which the information is to be generated.</param>
2020-08-07 14:37:42 -04:00
/// <param name="hFile">A handle to the file in which the information is to be written.</param>
2021-02-03 10:41:28 -05:00
/// <param name="DumpType">
/// The type of information to be generated. This parameter can be one or more of the values from the MINIDUMP_TYPE enumeration.
/// </param>
/// <param name="ExceptionParam">
/// A pointer to a MINIDUMP_EXCEPTION_INFORMATION structure describing the client exception that caused the minidump to be
/// generated. If the value of this parameter is <c>NULL</c>, no exception information is included in the minidump file.
/// </param>
/// <param name="UserStreamParam">
/// A pointer to a MINIDUMP_USER_STREAM_INFORMATION structure. If the value of this parameter is <c>NULL</c>, no user-defined
/// information is included in the minidump file.
/// </param>
/// <param name="CallbackParam">
/// A pointer to a MINIDUMP_CALLBACK_INFORMATION structure that specifies a callback routine which is to receive extended minidump
/// information. If the value of this parameter is <c>NULL</c>, no callbacks are performed.
/// </param>
2020-08-07 14:37:42 -04:00
/// <returns>
2021-02-03 10:41:28 -05:00
/// <para>
/// If the function succeeds, the return value is <c>TRUE</c>; otherwise, the return value is <c>FALSE</c>. To retrieve extended
/// error information, call GetLastError. Note that the last error will be an <c>HRESULT</c> value.
/// </para>
/// <para>If the operation is canceled, the last error code is
/// <code>HRESULT_FROM_WIN32(ERROR_CANCELLED)</code>
/// .
/// </para>
2020-08-07 14:37:42 -04:00
/// </returns>
/// <remarks>
2021-02-03 10:41:28 -05:00
/// <para>
/// The MiniDumpCallback function receives extended minidump information from <c>MiniDumpWriteDump</c>. It also provides a way for
/// the caller to determine the granularity of information written to the minidump file, as the callback function can filter the
/// default information.
/// </para>
/// <para>
/// <c>MiniDumpWriteDump</c> should be called from a separate process if at all possible, rather than from within the target process
/// being dumped. This is especially true when the target process is already not stable. For example, if it just crashed. A loader
/// deadlock is one of many potential side effects of calling <c>MiniDumpWriteDump</c> from within the target process.
/// </para>
/// <para>
/// <c>MiniDumpWriteDump</c> may not produce a valid stack trace for the calling thread. To work around this problem, you must
/// capture the state of the calling thread before calling <c>MiniDumpWriteDump</c> and use it as the ExceptionParam parameter. One
/// way to do this is to force an exception inside a <c>__try</c>/ <c>__except</c> block and use the EXCEPTION_POINTERS information
/// provided by GetExceptionInformation. Alternatively, you can call the function from a new worker thread and filter this worker
/// thread from the dump.
/// </para>
/// <para>
/// All DbgHelp functions, such as this one, are single threaded. Therefore, calls from more than one thread to this function will
/// likely result in unexpected behavior or memory corruption. To avoid this, you must synchronize all concurrent calls from more
/// than one thread to this function.
/// </para>
2020-08-07 14:37:42 -04:00
/// </remarks>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/nf-minidumpapiset-minidumpwritedump BOOL MiniDumpWriteDump(
// HANDLE hProcess, DWORD ProcessId, HANDLE hFile, MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
// PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam );
2021-02-03 15:57:49 -05:00
[DllImport(Lib_DbgHelp, SetLastError = true, ExactSpelling = true)]
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NF:minidumpapiset.MiniDumpWriteDump")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern unsafe bool MiniDumpWriteDump ( HPROCESS hProcess , uint ProcessId , HFILE hFile , MINIDUMP_TYPE DumpType ,
2021-02-03 10:41:28 -05:00
[In, Optional] IntPtr ExceptionParam , [ In , Optional ] IntPtr UserStreamParam ,
[In, Optional] IntPtr CallbackParam ) ;
/// <summary/>
2022-12-21 22:33:41 -05:00
[StructLayout(LayoutKind.Sequential, Pack = 4)]
2021-02-03 10:41:28 -05:00
public struct CONTEXT
{
2022-12-21 22:33:41 -05:00
// Structure size is 716 under x86 and 1232 under x64, not using arrays or unsafe to make blittable
private readonly int i01 , i02 , i03 , i04 , i05 , i06 , i07 , i08 , i09 , i10 , i11 , i12 , i13 , i14 , i15 , i16 , i17 , i18 , i19 , i20 , i21 , i22 , i23 , i24 , i25 , i26 , i27 , i28 , i29 , i30 , i31 , i32 , i33 , i34 , i35 , i36 , i37 , i38 , i39 , i40 , i41 , i42 , i43 , i44 , i45 , i46 , i47 , i48 , i49 , i50 ;
private readonly IntPtr p001 , p002 , p003 , p004 , p005 , p006 , p007 , p008 , p009 , p010 , p011 , p012 , p013 , p014 , p015 , p016 , p017 , p018 , p019 , p020 , p021 , p022 , p023 , p024 , p025 , p026 , p027 , p028 , p029 , p030 , p031 , p032 , p033 , p034 , p035 , p036 , p037 , p038 , p039 , p040 , p041 , p042 , p043 , p044 , p045 , p046 , p047 , p048 , p049 , p050 , p051 , p052 , p053 , p054 , p055 , p056 , p057 , p058 , p059 , p060 , p061 , p062 , p063 , p064 , p065 , p066 , p067 , p068 , p069 , p070 , p071 , p072 , p073 , p074 , p075 , p076 , p077 , p078 , p079 , p080 , p081 , p082 , p083 , p084 , p085 , p086 , p087 , p088 , p089 , p090 , p091 , p092 , p093 , p094 , p095 , p096 , p097 , p098 , p099 , p100 , p101 , p102 , p103 , p104 , p105 , p106 , p107 , p108 , p109 , p110 , p111 , p112 , p113 , p114 , p115 , p116 , p117 , p118 , p119 , p120 , p121 , p122 , p123 , p124 , p125 , p126 , p127 , p128 , p129 ;
2021-02-03 10:41:28 -05:00
}
/// <summary></summary>
[PInvokeData("minidumpapiset.h")]
[StructLayout(LayoutKind.Sequential)]
public struct CPU_INFORMATION
{
/// <summary>X86 platforms use CPUID function to obtain processor information.</summary>
[StructLayout(LayoutKind.Sequential)]
public struct X86CPUINFO
{
/// <summary>CPUID Subfunction 0, register EAX (VendorId [0]), EBX (VendorId [1]) and ECX (VendorId [2]).</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
public uint [ ] VendorId ;
/// <summary>CPUID Subfunction 1, register EAX</summary>
public uint VersionInformation ;
/// <summary>CPUID Subfunction 1, register EDX</summary>
public uint FeatureInformation ;
/// <summary>CPUID, Subfunction 80000001, register EBX. This will only be obtained if the vendor id is "AuthenticAMD".</summary>
public uint AMDExtendedCpuFeatures ;
}
/// <summary>X86 platforms use CPUID function to obtain processor information.</summary>
public X86CPUINFO X86CpuInfo ;
/// <summary>Non-x86 platforms use processor feature flags.</summary>
[StructLayout(LayoutKind.Sequential)]
public struct OTHERCPUINFO
{
/// <summary>Non-x86 platforms use processor feature flags.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public ulong [ ] ProcessorFeatures ;
}
/// <summary>Non-x86 platforms use processor feature flags.</summary>
public OTHERCPUINFO OtherCpuInfo ;
}
2020-08-07 14:37:42 -04:00
/// <summary>Contains a pointer to an optional callback function that can be used by the MiniDumpWriteDump function.</summary>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_callback_information typedef struct
// _MINIDUMP_CALLBACK_INFORMATION { MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; PVOID CallbackParam; } MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_CALLBACK_INFORMATION")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_CALLBACK_INFORMATION
{
/// <summary>A pointer to the MiniDumpCallback callback function.</summary>
[MarshalAs(UnmanagedType.FunctionPtr)]
public MINIDUMP_CALLBACK_ROUTINE CallbackRoutine ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The application-defined data for <c>CallbackRoutine</c>.</summary>
public IntPtr CallbackParam ;
}
/// <summary>Contains information used by the MiniDumpCallback function.</summary>
2021-02-03 10:41:28 -05:00
/// <remarks>
/// If <c>CallbackType</c> is <c>CancelCallback</c> or <c>MemoryCallback</c>, the <c>ProcessId</c>, <c>ProcessHandle</c>, and
/// <c>CallbackType</c> members are valid but no other input is specified.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_callback_input typedef struct
// _MINIDUMP_CALLBACK_INPUT { ULONG ProcessId; HANDLE ProcessHandle; ULONG CallbackType; union { HRESULT Status;
// MINIDUMP_THREAD_CALLBACK Thread; MINIDUMP_THREAD_EX_CALLBACK ThreadEx; MINIDUMP_MODULE_CALLBACK Module;
// MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; MINIDUMP_IO_CALLBACK Io;
// MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure; ULONG SecondaryFlags; MINIDUMP_VM_QUERY_CALLBACK VmQuery;
// MINIDUMP_VM_PRE_READ_CALLBACK VmPreRead; MINIDUMP_VM_POST_READ_CALLBACK VmPostRead; }; } MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_CALLBACK_INPUT")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_CALLBACK_INPUT
{
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>The identifier of the process that contains callback function.</para>
/// <para>This member is not used if <c>CallbackType</c> is <c>IoStartCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
public uint ProcessId ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>A handle to the process that contains the callback function.</para>
/// <para>This member is not used if <c>CallbackType</c> is <c>IoStartCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
public HPROCESS ProcessHandle ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The type of callback function. This member can be one of the values in the MINIDUMP_CALLBACK_TYPE enumeration.</summary>
public MINIDUMP_CALLBACK_TYPE CallbackType ;
2021-02-03 10:41:28 -05:00
/// <summary>Internal union.</summary>
private UNION Union ;
/// <summary>
/// If <c>CallbackType</c> is <c>KernelMinidumpStatusCallback</c>, the union is an <c>HRESULT</c> value that indicates the
/// status of the kernel minidump write attempt.
/// </summary>
public HRESULT Status { get = > Union . Status ; set = > Union . Status = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>If <c>CallbackType</c> is <c>ThreadCallback</c>, the union is a MINIDUMP_THREAD_CALLBACK structure.</summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_THREAD_CALLBACK Thread { get = > Union . Thread ; set = > Union . Thread = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>If <c>CallbackType</c> is <c>ThreadExCallback</c>, the union is a MINIDUMP_THREAD_EX_CALLBACK structure.</summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_THREAD_EX_CALLBACK ThreadEx { get = > Union . ThreadEx ; set = > Union . ThreadEx = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>If <c>CallbackType</c> is <c>ModuleCallback</c>, the union is a MINIDUMP_MODULE_CALLBACK structure.</summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_MODULE_CALLBACK Module { get = > Union . Module ; set = > Union . Module = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>If <c>CallbackType</c> is <c>IncludeThreadCallback</c>, the union is a MINIDUMP_INCLUDE_THREAD_CALLBACK structure.</para>
/// <para><c>DbgHelp 6.2 and earlier:</c> This member is not available.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread { get = > Union . IncludeThread ; set = > Union . IncludeThread = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>If <c>CallbackType</c> is <c>IncludeModuleCallback</c>, the union is a MINIDUMP_INCLUDE_MODULE_CALLBACK structure.</para>
/// <para><c>DbgHelp 6.2 and earlier:</c> This member is not available.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule { get = > Union . IncludeModule ; set = > Union . IncludeModule = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// If <c>CallbackType</c> is <c>IoStartCallback</c>, <c>IoWriteAllCallback</c>, or <c>IoFinishCallback</c>, the union is a
/// MINIDUMP_IO_CALLBACK structure.
/// </para>
/// <para><c>DbgHelp 6.4 and earlier:</c> This member is not available.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_IO_CALLBACK Io { get = > Union . Io ; set = > Union . Io = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// If <c>CallbackType</c> is <c>ReadMemoryFailureCallback</c>, the union is a MINIDUMP_READ_MEMORY_FAILURE_CALLBACK structure.
/// </para>
/// <para><c>DbgHelp 6.4 and earlier:</c> This member is not available.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure { get = > Union . ReadMemoryFailure ; set = > Union . ReadMemoryFailure = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>Contains a value from the MINIDUMP_SECONDARY_FLAGS enumeration type.</para>
/// <para><c>DbgHelp 6.5 and earlier:</c> This member is not available.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
public MINIDUMP_SECONDARY_FLAGS SecondaryFlags { get = > Union . SecondaryFlags ; set = > Union . SecondaryFlags = value ; }
/// <summary/>
public MINIDUMP_VM_QUERY_CALLBACK VmQuery { get = > Union . VmQuery ; set = > Union . VmQuery = value ; }
/// <summary/>
public MINIDUMP_VM_PRE_READ_CALLBACK VmPreRead { get = > Union . VmPreRead ; set = > Union . VmPreRead = value ; }
/// <summary/>
public MINIDUMP_VM_POST_READ_CALLBACK VmPostRead { get = > Union . VmPostRead ; set = > Union . VmPostRead = value ; }
2021-02-03 10:59:07 -05:00
2021-02-03 10:41:28 -05:00
/// <summary>Internal union.</summary>
[StructLayout(LayoutKind.Explicit)]
private struct UNION
{
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal HRESULT Status ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_THREAD_CALLBACK Thread ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_THREAD_EX_CALLBACK ThreadEx ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_MODULE_CALLBACK Module ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_IO_CALLBACK Io ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_SECONDARY_FLAGS SecondaryFlags ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_VM_QUERY_CALLBACK VmQuery ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_VM_PRE_READ_CALLBACK VmPreRead ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2021-02-03 10:59:07 -05:00
internal MINIDUMP_VM_POST_READ_CALLBACK VmPostRead ;
2021-02-03 10:41:28 -05:00
}
2020-08-07 14:37:42 -04:00
}
/// <summary>Contains information returned by the MiniDumpCallback function.</summary>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_callback_output typedef struct
// _MINIDUMP_CALLBACK_OUTPUT { union { ULONG ModuleWriteFlags; ULONG ThreadWriteFlags; ULONG SecondaryFlags; struct { ULONG64
// MemoryBase; ULONG MemorySize; }; struct { BOOL CheckCancel; BOOL Cancel; }; HANDLE Handle; struct { MINIDUMP_MEMORY_INFO
// VmRegion; BOOL Continue; }; struct { HRESULT VmQueryStatus; MINIDUMP_MEMORY_INFO VmQueryResult; }; struct { HRESULT VmReadStatus;
// ULONG VmReadBytesCompleted; }; HRESULT Status; }; } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_CALLBACK_OUTPUT")]
2021-02-03 10:41:28 -05:00
[StructLayout(LayoutKind.Explicit)]
2020-08-07 14:37:42 -04:00
public struct MINIDUMP_CALLBACK_OUTPUT
{
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// The module write operation flags. This member can be one or more of the values in the MODULE_WRITE_FLAGS enumeration. The
/// flags are set to their default values on entry to the callback.
/// </para>
/// <para>This member is ignored unless the callback type is <c>IncludeModuleCallback</c> or <c>ModuleCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public MODULE_WRITE_FLAGS ModuleWriteFlags ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// The thread write operation flags. This member can be one or more of the values in the THREAD_WRITE_FLAGS enumeration. The
/// flags are set to their default values on entry to the callback.
/// </para>
/// <para>This member is ignored unless the callback type is <c>IncludeThreadCallback</c>, <c>ThreadCallback</c>, or <c>ThreadExCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public THREAD_WRITE_FLAGS ThreadWriteFlags ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>Contains a value from the MINIDUMP_SECONDARY_FLAGS enumeration type.</para>
/// <para><c>DbgHelp 6.5 and earlier:</c> This member is not available.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public MINIDUMP_SECONDARY_FLAGS SecondaryFlags ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>The base address of the memory region to be included in the dump.</para>
/// <para>This member is ignored unless the callback type is <c>MemoryCallback</c> or <c>RemoveMemoryCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public ulong MemoryBase ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>The size of the memory region to be included in the dump, in bytes.</para>
/// <para>This member is ignored unless the callback type is <c>MemoryCallback</c> or <c>RemoveMemoryCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(8)]
2020-08-07 14:37:42 -04:00
public uint MemorySize ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// Controls whether the callback function should receive cancel callbacks. If this member is <c>TRUE</c>, the cancel callbacks
/// will continue. Otherwise, they will not.
/// </para>
/// <para>This member is ignored unless the callback type is <c>CancelCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
[MarshalAs(UnmanagedType.Bool)] public bool CheckCancel ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// Controls whether the dump should be canceled. If the callback function returns <c>TRUE</c> and <c>Cancel</c> is <c>TRUE</c>,
/// the dump will be canceled. In this case, the MiniDumpWriteDump function fails and the dump is not valid.
/// </para>
/// <para>This member is ignored unless the callback type is <c>CancelCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(4)]
2020-08-07 14:37:42 -04:00
[MarshalAs(UnmanagedType.Bool)] public bool Cancel ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>A handle to the file to which a kernel minidump will be written.</para>
/// <para>This member is ignored unless the callback type is <c>WriteKernelMinidumpCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public HFILE Handle ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// A MINIDUMP_MEMORY_INFO structure that describes the virtual memory region. The region base and size must be aligned on a
/// page boundary. The region size can be set to 0 to filter out the region.
/// </para>
/// <para>This member is ignored unless the callback type is <c>IncludeVmRegionCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public MINIDUMP_MEMORY_INFO VmRegion ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// Controls whether the dump should be continued. If the callback function returns <c>TRUE</c> and <c>Continue</c> is
/// <c>TRUE</c>, the dump will be continued. Otherwise, the MiniDumpWriteDump function fails and the dump is not valid.
/// </para>
/// <para>This member is ignored unless the callback type is <c>IncludeVmRegionCallback</c>.</para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(48)]
[MarshalAs(UnmanagedType.Bool)]
public bool Continue ;
/// <summary/>
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public HRESULT VmQueryStatus ;
2021-02-03 10:41:28 -05:00
/// <summary/>
public MINIDUMP_MEMORY_INFO VmQueryResult { get = > ptrmi . f1 ; set = > ptrmi . f1 = value ; }
/// <summary/>
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public HRESULT VmReadStatus ;
2021-02-03 10:41:28 -05:00
/// <summary/>
public uint VmReadBytesCompleted { get = > ptrUint . f1 ; set = > ptrUint . f1 = value ; }
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>The status of the operation.</para>
/// <para>
/// This member is ignored unless the callback type is <c>ReadMemoryFailureCallback</c>, <c>IoStartCallback</c>,
/// <c>IoWriteAllCallback</c>, or <c>IoFinishCallback</c>.
/// </para>
2020-08-07 14:37:42 -04:00
/// </summary>
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
2020-08-07 14:37:42 -04:00
public HRESULT Status ;
2021-02-03 10:41:28 -05:00
[FieldOffset(0)]
private PtrUint ptrUint ;
[FieldOffset(0)]
private PtrMI ptrmi ;
[StructLayout(LayoutKind.Sequential)]
private struct PtrUint
{
private IntPtr f0 ;
internal uint f1 ;
}
[StructLayout(LayoutKind.Sequential)]
private struct PtrMI
{
private IntPtr f0 ;
internal MINIDUMP_MEMORY_INFO f1 ;
}
2020-08-07 14:37:42 -04:00
}
/// <summary>Contains the information needed to access a specific data stream in a minidump file.</summary>
/// <remarks>In this context, a data stream is a block of data within a minidump file.</remarks>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_directory typedef struct
// _MINIDUMP_DIRECTORY { ULONG32 StreamType; MINIDUMP_LOCATION_DESCRIPTOR Location; } MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_DIRECTORY")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_DIRECTORY
{
/// <summary>The type of data stream. This member can be one of the values in the MINIDUMP_STREAM_TYPE enumeration.</summary>
public MINIDUMP_STREAM_TYPE StreamType ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>A MINIDUMP_LOCATION_DESCRIPTOR structure that specifies the location of the data stream.</summary>
public MINIDUMP_LOCATION_DESCRIPTOR Location ;
}
/// <summary>Contains exception information.</summary>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_exception typedef struct
// _MINIDUMP_EXCEPTION { ULONG32 ExceptionCode; ULONG32 ExceptionFlags; ULONG64 ExceptionRecord; ULONG64 ExceptionAddress; ULONG32
// NumberParameters; ULONG32 __unusedAlignment; ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; } MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_EXCEPTION")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_EXCEPTION
{
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// The reason the exception occurred. This is the code generated by a hardware exception, or the code specified in the
/// RaiseException function for a software-generated exception. Following are the exception codes likely to occur due to common
/// programming errors.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>EXCEPTION_ACCESS_VIOLATION</term>
/// <term>The thread tried to read from or write to a virtual address for which it does not have the appropriate access.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_ARRAY_BOUNDS_EXCEEDED</term>
/// <term>The thread tried to access an array element that is out of bounds and the underlying hardware supports bounds checking.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_BREAKPOINT</term>
/// <term>A breakpoint was encountered.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_DATATYPE_MISALIGNMENT</term>
/// <term>
/// The thread tried to read or write data that is misaligned on hardware that does not provide alignment. For example, 16-bit
/// values must be aligned on 2-byte boundaries; 32-bit values on 4-byte boundaries, and so on.
/// </term>
/// </item>
/// <item>
/// <term>EXCEPTION_FLT_DENORMAL_OPERAND</term>
/// <term>
/// One of the operands in a floating-point operation is denormal. A denormal value is one that is too small to represent as a
/// standard floating-point value.
/// </term>
/// </item>
/// <item>
/// <term>EXCEPTION_FLT_DIVIDE_BY_ZERO</term>
/// <term>The thread tried to divide a floating-point value by a floating-point divisor of zero.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_FLT_INEXACT_RESULT</term>
/// <term>The result of a floating-point operation cannot be represented exactly as a decimal fraction.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_FLT_INVALID_OPERATION</term>
/// <term>This exception represents any floating-point exception not included in this list.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_FLT_OVERFLOW</term>
/// <term>The exponent of a floating-point operation is greater than the magnitude allowed by the corresponding type.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_FLT_STACK_CHECK</term>
/// <term>The stack overflowed or underflowed as the result of a floating-point operation.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_FLT_UNDERFLOW</term>
/// <term>The exponent of a floating-point operation is less than the magnitude allowed by the corresponding type.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_ILLEGAL_INSTRUCTION</term>
/// <term>The thread tried to execute an invalid instruction.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_IN_PAGE_ERROR</term>
/// <term>
/// The thread tried to access a page that was not present, and the system was unable to load the page. For example, this
/// exception might occur if a network connection is lost while running a program over the network.
/// </term>
/// </item>
/// <item>
/// <term>EXCEPTION_INT_DIVIDE_BY_ZERO</term>
/// <term>The thread tried to divide an integer value by an integer divisor of zero.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_INT_OVERFLOW</term>
/// <term>The result of an integer operation caused a carry out of the most significant bit of the result.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_INVALID_DISPOSITION</term>
/// <term>
/// An exception handler returned an invalid disposition to the exception dispatcher. Programmers using a high-level language
/// such as C should never encounter this exception.
/// </term>
/// </item>
/// <item>
/// <term>EXCEPTION_NONCONTINUABLE_EXCEPTION</term>
/// <term>The thread tried to continue execution after a noncontinuable exception occurred.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_PRIV_INSTRUCTION</term>
/// <term>The thread tried to execute an instruction whose operation is not allowed in the current machine mode.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_SINGLE_STEP</term>
/// <term>A trace trap or other single-instruction mechanism signaled that one instruction has been executed.</term>
/// </item>
/// <item>
/// <term>EXCEPTION_STACK_OVERFLOW</term>
/// <term>The thread used up its stack.</term>
/// </item>
/// </list>
/// <para>
/// Another exception code is likely to occur when debugging console processes. It does not arise because of a programming
/// error. The DBG_CONTROL_C exception code occurs when CTRL+C is input to a console process that handles CTRL+C signals and is
/// being debugged. This exception code is not meant to be handled by applications. It is raised only for the benefit of the
/// debugger, and is raised only when a debugger is attached to the console process.
/// </para>
/// </summary>
public NTStatus ExceptionCode ;
/// <summary>
/// This member can be either zero, indicating a continuable exception, or EXCEPTION_NONCONTINUABLE, indicating a noncontinuable
/// exception. Any attempt to continue execution after a noncontinuable exception causes the EXCEPTION_NONCONTINUABLE_EXCEPTION exception.
/// </summary>
public Kernel32 . EXCEPTION_FLAG ExceptionFlags ;
/// <summary>
/// A pointer to an associated <c>MINIDUMP_EXCEPTION</c> structure. Exception records can be chained together to provide
/// additional information when nested exceptions occur.
/// </summary>
2020-08-07 14:37:42 -04:00
public ulong ExceptionRecord ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The address where the exception occurred.</summary>
public ulong ExceptionAddress ;
2021-02-03 10:41:28 -05:00
/// <summary>
/// The number of parameters associated with the exception. This is the number of defined elements in the
/// <c>ExceptionInformation</c> array.
/// </summary>
2020-08-07 14:37:42 -04:00
public uint NumberParameters ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>Reserved for cross-platform structure member alignment. Do not set.</summary>
private uint unusedAlignment ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>
2021-02-03 10:41:28 -05:00
/// <para>
/// An array of additional arguments that describe the exception. The RaiseException function can specify this array of
/// arguments. For most exception codes, the array elements are undefined. For the following exception code, the array elements
/// are defined as follows.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Exception code</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>EXCEPTION_ACCESS_VIOLATION</term>
/// <term>
/// The first element of the array contains a read/write flag that indicates the type of operation that caused the access
/// violation. If this value is zero, the thread attempted to read the inaccessible data. If this value is 1, the thread
/// attempted to write to an inaccessible address. The second array element specifies the virtual address of the inaccessible data.
/// </term>
/// </item>
/// </list>
2020-08-07 14:37:42 -04:00
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 15)]
public ulong [ ] ExceptionInformation ;
}
/// <summary>Contains the exception information written to the minidump file by the MiniDumpWriteDump function.</summary>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_exception_information typedef struct
// _MINIDUMP_EXCEPTION_INFORMATION { DWORD ThreadId; PEXCEPTION_POINTERS ExceptionPointers; BOOL ClientPointers; }
// MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_EXCEPTION_INFORMATION")]
2021-02-03 10:41:28 -05:00
[StructLayout(LayoutKind.Sequential, Pack = 4)]
2020-08-07 14:37:42 -04:00
public struct MINIDUMP_EXCEPTION_INFORMATION
{
/// <summary>The identifier of the thread throwing the exception.</summary>
public uint ThreadId ;
2021-02-03 10:41:28 -05:00
/// <summary>
/// A pointer to an EXCEPTION_POINTERS structure specifying a computer-independent description of the exception and the
/// processor context at the time of the exception.
/// </summary>
2020-08-07 14:37:42 -04:00
public IntPtr ExceptionPointers ;
2021-02-03 10:41:28 -05:00
/// <summary>
/// Determines where to get the memory regions pointed to by the <c>ExceptionPointers</c> member. Set to <c>TRUE</c> if the
/// memory resides in the process being debugged (the target process of the debugger). Otherwise, set to <c>FALSE</c> if the
/// memory resides in the address space of the calling program (the debugger process). If you are accessing local memory (in the
/// calling process) you should not set this member to <c>TRUE</c>.
/// </summary>
[MarshalAs(UnmanagedType.Bool)]
public bool ClientPointers ;
2020-08-07 14:37:42 -04:00
}
/// <summary>Represents an exception information stream.</summary>
/// <remarks>In this context, a data stream is a set of data in a minidump file.</remarks>
2021-02-03 10:41:28 -05:00
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_exception_stream typedef struct
// MINIDUMP_EXCEPTION_STREAM { ULONG32 ThreadId; ULONG32 __alignment; MINIDUMP_EXCEPTION ExceptionRecord;
// MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; } MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset.MINIDUMP_EXCEPTION_STREAM")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_EXCEPTION_STREAM
{
/// <summary>The identifier of the thread that caused the exception.</summary>
public uint ThreadId ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>A variable for alignment.</summary>
private uint __alignment ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>A MINIDUMP_EXCEPTION structure.</summary>
public MINIDUMP_EXCEPTION ExceptionRecord ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>A MINIDUMP_LOCATION_DESCRIPTOR structure.</summary>
public MINIDUMP_LOCATION_DESCRIPTOR ThreadContext ;
}
/// <summary>Represents a function table stream.</summary>
2021-02-03 10:41:28 -05:00
/// <remarks>
/// The first descriptor in the function table stream follows the header, MINIDUMP_FUNCTION_TABLE_STREAM. The generic descriptor is
/// followed by a native system descriptor, then by <c>EntryCount</c> native system function entry structures.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_function_table_descriptor typedef
// struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR { ULONG64 MinimumAddress; ULONG64 MaximumAddress; ULONG64 BaseAddress; ULONG32
// EntryCount; ULONG32 SizeOfAlignPad; } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR, *PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_FUNCTION_TABLE_DESCRIPTOR")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_FUNCTION_TABLE_DESCRIPTOR
{
/// <summary>The minimum address of functions described by the table.</summary>
public ulong MinimumAddress ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The maximum address of functions described by the table.</summary>
public ulong MaximumAddress ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The base address to use when computing full virtual addresses from relative virtual addresses in function entries.</summary>
public ulong BaseAddress ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The number of entries in the function table.</summary>
public uint EntryCount ;
2021-02-03 10:41:28 -05:00
/// <summary>
/// The size of alignment padding that follows the function entry data, in bytes. The function entry data in the stream is
/// guaranteed to be aligned appropriately for access to the data members. If a minidump is directly mapped in memory, it is
/// always possible to directly reference structure members in the stream.
/// </summary>
2020-08-07 14:37:42 -04:00
public uint SizeOfAlignPad ;
}
/// <summary>Represents the header for the function table stream.</summary>
2021-02-03 10:41:28 -05:00
/// <remarks>
/// In this context, a data stream is a set of data in a minidump file. This header structure is followed by
/// <c>NumberOfDescriptors</c> function tables. For each function table there is a MINIDUMP_FUNCTION_TABLE_DESCRIPTOR structure,
/// then the raw system descriptor for the table, then the raw system function entry data. If necessary, alignment padding is placed
/// between tables to properly align the initial structures.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_function_table_stream typedef struct
// _MINIDUMP_FUNCTION_TABLE_STREAM { ULONG32 SizeOfHeader; ULONG32 SizeOfDescriptor; ULONG32 SizeOfNativeDescriptor; ULONG32
// SizeOfFunctionEntry; ULONG32 NumberOfDescriptors; ULONG32 SizeOfAlignPad; } MINIDUMP_FUNCTION_TABLE_STREAM, *PMINIDUMP_FUNCTION_TABLE_STREAM;
2020-08-07 14:37:42 -04:00
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_FUNCTION_TABLE_STREAM")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_FUNCTION_TABLE_STREAM
{
2021-02-03 10:41:28 -05:00
/// <summary>
/// The size of header information for the stream, in bytes. This value is
/// <code>sizeof(MINIDUMP_FUNCTION_TABLE_STREAM)</code>
/// .
/// </summary>
2020-08-07 14:37:42 -04:00
public uint SizeOfHeader ;
2021-02-03 10:41:28 -05:00
/// <summary>
/// The size of a descriptor in the stream, in bytes. This value is
/// <code>sizeof(MINIDUMP_FUNCTION_TABLE_DESCRIPTOR)</code>
/// .
/// </summary>
2020-08-07 14:37:42 -04:00
public uint SizeOfDescriptor ;
2021-02-03 10:41:28 -05:00
/// <summary>
/// The size of a raw system descriptor in the stream, in bytes. This value depends on the particular platform and system
/// version on which the minidump was generated.
/// </summary>
2020-08-07 14:37:42 -04:00
public uint SizeOfNativeDescriptor ;
2021-02-03 10:41:28 -05:00
/// <summary>
/// The size of a raw system function table entry, in bytes. This value depends on the particular platform and system version on
/// which the minidump was generated.
/// </summary>
2020-08-07 14:37:42 -04:00
public uint SizeOfFunctionEntry ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The number of descriptors in the stream.</summary>
public uint NumberOfDescriptors ;
2021-02-03 10:41:28 -05:00
2020-08-07 14:37:42 -04:00
/// <summary>The size of alignment padding that follows the header, in bytes.</summary>
public uint SizeOfAlignPad ;
}
2021-02-03 10:41:28 -05:00
/// <summary>Represents the header for a handle data stream.</summary>
/// <remarks>
/// In this context, a data stream is a set of data in a minidump file. This header structure is followed by
/// <c>NumberOfDescriptors</c> MINIDUMP_HANDLE_DESCRIPTOR or MINIDUMP_HANDLE_DESCRIPTOR_2 structures.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_handle_data_stream typedef struct
// _MINIDUMP_HANDLE_DATA_STREAM { ULONG32 SizeOfHeader; ULONG32 SizeOfDescriptor; ULONG32 NumberOfDescriptors; ULONG32 Reserved; }
// MINIDUMP_HANDLE_DATA_STREAM, *PMINIDUMP_HANDLE_DATA_STREAM;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_HANDLE_DATA_STREAM")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_HANDLE_DATA_STREAM
{
/// <summary>
/// The size of the header information for the stream, in bytes. This value is
/// <code>sizeof(MINIDUMP_HANDLE_DATA_STREAM)</code>
/// .
/// </summary>
public uint SizeOfHeader ;
/// <summary>
/// The size of a descriptor in the stream, in bytes. This value is
/// <code>sizeof(MINIDUMP_HANDLE_DESCRIPTOR)</code>
/// or
/// <code>sizeof(MINIDUMP_HANDLE_DESCRIPTOR_2)</code>
/// .
/// </summary>
public uint SizeOfDescriptor ;
/// <summary>The number of descriptors in the stream.</summary>
public uint NumberOfDescriptors ;
/// <summary>Reserved for future use; must be zero.</summary>
public uint Reserved ;
}
/// <summary>Contains the state of an individual system handle at the time the minidump was written.</summary>
/// <remarks>The first descriptor in the handle data stream follows the header, MINIDUMP_HANDLE_DATA_STREAM.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_handle_descriptor typedef struct
// _MINIDUMP_HANDLE_DESCRIPTOR { ULONG64 Handle; RVA TypeNameRva; RVA ObjectNameRva; ULONG32 Attributes; ULONG32 GrantedAccess;
// ULONG32 HandleCount; ULONG32 PointerCount; } MINIDUMP_HANDLE_DESCRIPTOR, *PMINIDUMP_HANDLE_DESCRIPTOR;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_HANDLE_DESCRIPTOR")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_HANDLE_DESCRIPTOR
{
/// <summary>The operating system handle value.</summary>
public ulong Handle ;
/// <summary>An RVA to a MINIDUMP_STRING structure that specifies the object type of the handle. This member can be zero.</summary>
public uint TypeNameRva ;
/// <summary>An RVA to a MINIDUMP_STRING structure that specifies the object name of the handle. This member can be zero.</summary>
public uint ObjectNameRva ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint Attributes ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint GrantedAccess ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint HandleCount ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint PointerCount ;
}
/// <summary>Describes the state of an individual system handle at the time the minidump was written.</summary>
/// <remarks>The first descriptor in the handle data stream follows the header, MINIDUMP_HANDLE_DATA_STREAM.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_handle_descriptor_2 typedef struct
// _MINIDUMP_HANDLE_DESCRIPTOR_2 { ULONG64 Handle; RVA TypeNameRva; RVA ObjectNameRva; ULONG32 Attributes; ULONG32 GrantedAccess;
// ULONG32 HandleCount; ULONG32 PointerCount; RVA ObjectInfoRva; ULONG32 Reserved0; } MINIDUMP_HANDLE_DESCRIPTOR_2, *PMINIDUMP_HANDLE_DESCRIPTOR_2;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_HANDLE_DESCRIPTOR_2")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_HANDLE_DESCRIPTOR_2
{
/// <summary>The operating system handle value.</summary>
public ulong Handle ;
/// <summary>An RVA to a MINIDUMP_STRING structure that specifies the object type of the handle. This member can be zero.</summary>
public uint TypeNameRva ;
/// <summary>An RVA to a MINIDUMP_STRING structure that specifies the object name of the handle. This member can be 0.</summary>
public uint ObjectNameRva ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint Attributes ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint GrantedAccess ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint HandleCount ;
/// <summary>The meaning of this member depends on the handle type and the operating system.</summary>
public uint PointerCount ;
/// <summary>
/// An RVA to a MINIDUMP_HANDLE_OBJECT_INFORMATION structure that specifies object-specific information. This member can be 0 if
/// there is no extra information.
/// </summary>
public uint ObjectInfoRva ;
/// <summary>Reserved for future use; must be zero.</summary>
public uint Reserved0 ;
}
/// <summary>Contains object-specific information for a handle.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_handle_object_information typedef
// struct _MINIDUMP_HANDLE_OBJECT_INFORMATION { RVA NextInfoRva; ULONG32 InfoType; ULONG32 SizeOfInfo; } MINIDUMP_HANDLE_OBJECT_INFORMATION;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_HANDLE_OBJECT_INFORMATION")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_HANDLE_OBJECT_INFORMATION
{
/// <summary>
/// An RVA to a <c>MINIDUMP_HANDLE_OBJECT_INFORMATION</c> structure that specifies additional object-specific information. This
/// member is 0 if there are no more elements in the list.
/// </summary>
public uint NextInfoRva ;
/// <summary>
/// The object information type. This member is one of the values from the MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE enumeration.
/// </summary>
public MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE InfoType ;
/// <summary>The size of the information that follows this member, in bytes.</summary>
public uint SizeOfInfo ;
}
/// <summary>Contains a list of handle operations.</summary>
/// <remarks>For a definition of the <c>AVRF_HANDLE_OPERATION</c> structure, see the Avrfsdk.h header file.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_handle_operation_list typedef struct
// _MINIDUMP_HANDLE_OPERATION_LIST { ULONG32 SizeOfHeader; ULONG32 SizeOfEntry; ULONG32 NumberOfEntries; ULONG32 Reserved; }
// MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_HANDLE_OPERATION_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_HANDLE_OPERATION_LIST
{
/// <summary>
/// The size of the header data for the stream, in bytes. This is generally
/// <code>sizeof(MINIDUMP_HANDLE_OPERATION_LIST)</code>
/// .
/// </summary>
public uint SizeOfHeader ;
/// <summary>
/// The size of each entry following the header, in bytes. This is generally
/// <code>sizeof(AVRF_HANDLE_OPERATION)</code>
/// .
/// </summary>
public uint SizeOfEntry ;
/// <summary>
/// The number of entries in the stream. These are generally <c>AVRF_HANDLE_OPERATION</c> structures. The entries follow the header.
/// </summary>
public uint NumberOfEntries ;
/// <summary>This member is reserved for future use.</summary>
public uint Reserved ;
}
/// <summary>Contains header information for the minidump file.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_header typedef struct
// _MINIDUMP_HEADER { ULONG32 Signature; ULONG32 Version; ULONG32 NumberOfStreams; RVA StreamDirectoryRva; ULONG32 CheckSum; union {
// ULONG32 Reserved; ULONG32 TimeDateStamp; }; ULONG64 Flags; } MINIDUMP_HEADER, *PMINIDUMP_HEADER;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_HEADER")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_HEADER
{
/// <summary>The signature. Set this member to MINIDUMP_SIGNATURE.</summary>
public uint Signature ;
/// <summary>
/// The version of the minidump format. The low-order word is MINIDUMP_VERSION. The high-order word is an internal value that is
/// implementation specific.
/// </summary>
public uint Version ;
/// <summary>The number of streams in the minidump directory.</summary>
public uint NumberOfStreams ;
/// <summary>The base RVA of the minidump directory. The directory is an array of MINIDUMP_DIRECTORY structures.</summary>
public uint StreamDirectoryRva ;
/// <summary>The checksum for the minidump file. This member can be zero.</summary>
public uint CheckSum ;
/// <summary>Time and date, in <c>time_t</c> format.</summary>
public time_t TimeDateStamp ;
/// <summary>One or more values from the MINIDUMP_TYPE enumeration type.</summary>
public ulong Flags ;
}
/// <summary>Contains information for the MiniDumpCallback function when the callback type is <c>IncludeModuleCallback</c>.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_include_module_callback typedef
// struct _MINIDUMP_INCLUDE_MODULE_CALLBACK { ULONG64 BaseOfImage; } MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_INCLUDE_MODULE_CALLBACK")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_INCLUDE_MODULE_CALLBACK
{
/// <summary>The base address of the executable image in memory.</summary>
public ulong BaseOfImage ;
}
/// <summary>Contains information for the MiniDumpCallback function when the callback type is <c>IncludeThreadCallback</c>.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_include_thread_callback typedef
// struct _MINIDUMP_INCLUDE_THREAD_CALLBACK { ULONG ThreadId; } MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_INCLUDE_THREAD_CALLBACK")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_INCLUDE_THREAD_CALLBACK
{
/// <summary>The identifier of the thread.</summary>
public uint ThreadId ;
}
/// <summary>
/// Contains I/O callback information. This structure is used by the MiniDumpCallbackfunction when the callback type is
/// <c>IoStartCallback</c>, <c>IoWriteAllCallback</c>, or <c>IoFinishCallback</c>.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_io_callback typedef struct
// _MINIDUMP_IO_CALLBACK { HANDLE Handle; ULONG64 Offset; PVOID Buffer; ULONG BufferBytes; } MINIDUMP_IO_CALLBACK, *PMINIDUMP_IO_CALLBACK;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_IO_CALLBACK")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_IO_CALLBACK
{
/// <summary>The file handle passed to the MiniDumpWriteDump function.</summary>
public HFILE Handle ;
/// <summary>The offset for the write operation from the start of the minidump data. This member is used only with <c>IoWriteAllCallback</c>.</summary>
public ulong Offset ;
/// <summary>A pointer to a buffer that contains the data to be written. This member is used only with <c>IoWriteAllCallback</c>.</summary>
public IntPtr Buffer ;
/// <summary>The size of the data buffer, in bytes. This member is used only with <c>IoWriteAllCallback</c>.</summary>
public uint BufferBytes ;
}
/// <summary>Contains information describing the location of a data stream within a minidump file.</summary>
/// <remarks>
/// <para>In this context, a data stream refers to a block of data within a minidump file.</para>
/// <para>
/// This structure uses 32-bit locations for RVAs in the first 4GB and 64-bit locations are used for larger RVAs. The
/// <c>MINIDUMP_LOCATION_DESCRIPTOR64</c> structure is defined as follows.
/// </para>
/// <para>
/// <code> typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 { ULONG64 DataSize; RVA64 Rva; } MINIDUMP_LOCATION_DESCRIPTOR64;</code>
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_location_descriptor typedef struct
// _MINIDUMP_LOCATION_DESCRIPTOR { ULONG32 DataSize; RVA Rva; } MINIDUMP_LOCATION_DESCRIPTOR;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_LOCATION_DESCRIPTOR")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_LOCATION_DESCRIPTOR
{
/// <summary>The size of the data stream, in bytes.</summary>
public uint DataSize ;
/// <summary>
/// The relative virtual address (RVA) of the data. This is the byte offset of the data stream from the beginning of the
/// minidump file.
/// </summary>
public uint Rva ;
}
/// <summary>Describes a range of memory.</summary>
/// <remarks>
/// <para>
/// <c>MINIDUMP_MEMORY_DESCRIPTOR64</c> is used for full-memory minidumps where all of the raw memory is sequential at the end of
/// the minidump. There is no need for individual relative virtual addresses (RVAs), because the RVA is the base RVA plus the sum of
/// the preceding data blocks. The <c>MINIDUMP_MEMORY_DESCRIPTOR64</c> structure is defined as follows.
/// </para>
/// <para>
/// <code> typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 { ULONG64 StartOfMemoryRange; ULONG64 DataSize; } MINIDUMP_MEMORY_DESCRIPTOR64, *PMINIDUMP_MEMORY_DESCRIPTOR64;</code>
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_memory_descriptor typedef struct
// _MINIDUMP_MEMORY_DESCRIPTOR { ULONG64 StartOfMemoryRange; MINIDUMP_LOCATION_DESCRIPTOR Memory; } MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MEMORY_DESCRIPTOR")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MEMORY_DESCRIPTOR
{
/// <summary>The starting address of the memory range.</summary>
public ulong StartOfMemoryRange ;
/// <summary>A MINIDUMP_LOCATION_DESCRIPTOR structure.</summary>
public MINIDUMP_LOCATION_DESCRIPTOR Memory ;
}
/// <summary>Describes a region of memory.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_memory_info typedef struct
// _MINIDUMP_MEMORY_INFO { ULONG64 BaseAddress; ULONG64 AllocationBase; ULONG32 AllocationProtect; ULONG32 __alignment1; ULONG64
// RegionSize; ULONG32 State; ULONG32 Protect; ULONG32 Type; ULONG32 __alignment2; } MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MEMORY_INFO")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MEMORY_INFO
{
/// <summary>The base address of the region of pages.</summary>
public ulong BaseAddress ;
/// <summary>The base address of a range of pages in this region. The page is contained within this memory region.</summary>
public ulong AllocationBase ;
/// <summary>
/// The memory protection when the region was initially allocated. This member can be one of the memory protection options,
/// along with PAGE_GUARD or PAGE_NOCACHE, as needed.
/// </summary>
public uint AllocationProtect ;
/// <summary>A variable for alignment.</summary>
private uint __alignment1 ;
/// <summary>The size of the region beginning at the base address in which all pages have identical attributes, in bytes.</summary>
public ulong RegionSize ;
/// <summary>
/// <para>The state of the pages in the region. This member can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>State</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>MEM_COMMIT 0x1000</term>
/// <term>
/// Indicates committed pages for which physical storage has been allocated, either in memory or in the paging file on disk.
/// </term>
/// </item>
/// <item>
/// <term>MEM_FREE 0x10000</term>
/// <term>
/// Indicates free pages not accessible to the calling process and available to be allocated. For free pages, the information in
/// the AllocationBase, AllocationProtect, Protect, and Type members is undefined.
/// </term>
/// </item>
/// <item>
/// <term>MEM_RESERVE 0x2000</term>
/// <term>
/// Indicates reserved pages where a range of the process's virtual address space is reserved without any physical storage being
/// allocated. For reserved pages, the information in the Protect member is undefined.
/// </term>
/// </item>
/// </list>
/// </summary>
public uint State ;
/// <summary>
/// The access protection of the pages in the region. This member is one of the values listed for the <c>AllocationProtect</c> member.
/// </summary>
public uint Protect ;
/// <summary>
/// <para>The type of pages in the region. The following types are defined.</para>
/// <list type="table">
/// <listheader>
/// <term>Type</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>MEM_IMAGE 0x1000000</term>
/// <term>Indicates that the memory pages within the region are mapped into the view of an image section.</term>
/// </item>
/// <item>
/// <term>MEM_MAPPED 0x40000</term>
/// <term>Indicates that the memory pages within the region are mapped into the view of a section.</term>
/// </item>
/// <item>
/// <term>MEM_PRIVATE 0x20000</term>
/// <term>Indicates that the memory pages within the region are private (that is, not shared by other processes).</term>
/// </item>
/// </list>
/// </summary>
public uint Type ;
/// <summary>A variable for alignment.</summary>
private uint __alignment2 ;
}
/// <summary>Contains a list of memory regions.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_memory_info_list typedef struct
// _MINIDUMP_MEMORY_INFO_LIST { ULONG SizeOfHeader; ULONG SizeOfEntry; ULONG64 NumberOfEntries; } MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MEMORY_INFO_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MEMORY_INFO_LIST
{
/// <summary>
/// The size of the header data for the stream, in bytes. This is generally
/// <code>sizeof(MINIDUMP_MEMORY_INFO_LIST)</code>
/// .
/// </summary>
public uint SizeOfHeader ;
/// <summary>
/// The size of each entry following the header, in bytes. This is generally
/// <code>sizeof(MINIDUMP_MEMORY_INFO)</code>
/// .
/// </summary>
public uint SizeOfEntry ;
/// <summary>
/// The number of entries in the stream. These are generally MINIDUMP_MEMORY_INFO structures. The entries follow the header.
/// </summary>
public ulong NumberOfEntries ;
}
/// <summary>Contains a list of memory ranges.</summary>
/// <remarks>
/// <para>The <c>MINIDUMP_MEMORY64_LIST</c> structure is defined as follows. It is used for full-memory minidumps.</para>
/// <para>
/// <code> typedef struct _MINIDUMP_MEMORY64_LIST { ULONG64 NumberOfMemoryRanges; RVA64 BaseRva; MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0]; } MINIDUMP_MEMORY64_LIST, *PMINIDUMP_MEMORY64_LIST;</code>
/// </para>
/// <para>
/// Note that <c>BaseRva</c> is the overall base RVA for the memory list. To locate the data for a particular descriptor, start at
/// <c>BaseRva</c> and increment by the size of a descriptor until you reach the descriptor.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_memory_list typedef struct
// _MINIDUMP_MEMORY_LIST { ULONG32 NumberOfMemoryRanges; MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[0]; } MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MEMORY_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MEMORY_LIST
{
/// <summary>The number of structures in the <c>MemoryRanges</c> array.</summary>
public uint NumberOfMemoryRanges ;
/// <summary>An array of MINIDUMP_MEMORY_DESCRIPTOR structures.</summary>
public MINIDUMP_MEMORY_DESCRIPTOR [ ] MemoryRanges ;
}
/// <summary>Contains a variety of information.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_misc_info typedef struct
// _MINIDUMP_MISC_INFO { ULONG32 SizeOfInfo; ULONG32 Flags1; ULONG32 ProcessId; ULONG32 ProcessCreateTime; ULONG32 ProcessUserTime;
// ULONG32 ProcessKernelTime; } MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MISC_INFO")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MISC_INFO
{
/// <summary>The size of the structure, in bytes.</summary>
public uint SizeOfInfo ;
/// <summary>
/// <para>The flags that indicate the valid members of this structure. This member can be one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>MINIDUMP_MISC1_PROCESS_ID 0x00000001</term>
/// <term>ProcessId is used.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_MISC1_PROCESS_TIMES 0x00000002</term>
/// <term>ProcessCreateTime, ProcessKernelTime, and ProcessUserTime are used.</term>
/// </item>
/// </list>
/// </summary>
public uint Flags1 ;
/// <summary>The identifier of the process. If <c>Flags1</c> does not specify MINIDUMP_MISC1_PROCESS_ID, this member is unused.</summary>
public uint ProcessId ;
/// <summary>
/// The creation time of the process, in <c>time_t</c> format. If <c>Flags1</c> does not specify MINIDUMP_MISC1_PROCESS_TIMES,
/// this member is unused.
/// </summary>
public uint ProcessCreateTime ;
/// <summary>
/// The time the process has executed in user mode, in seconds. The time that each of the threads of the process has executed in
/// user mode is determined, then all these times are summed to obtain this value. If <c>Flags1</c> does not specify
/// MINIDUMP_MISC1_PROCESS_TIMES, this member is unused.
/// </summary>
public uint ProcessUserTime ;
/// <summary>
/// The time the process has executed in kernel mode, in seconds. The time that each of the threads of the process has executed
/// in kernel mode is determined, then all these times are summed to obtain this value. If <c>Flags1</c> does not specify
/// MINIDUMP_MISC1_PROCESS_TIMES, this member is unused.
/// </summary>
public uint ProcessKernelTime ;
}
/// <summary>Represents information in the miscellaneous information stream.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_misc_info_2 typedef struct
// _MINIDUMP_MISC_INFO_2 { ULONG32 SizeOfInfo; ULONG32 Flags1; ULONG32 ProcessId; ULONG32 ProcessCreateTime; ULONG32
// ProcessUserTime; ULONG32 ProcessKernelTime; ULONG32 ProcessorMaxMhz; ULONG32 ProcessorCurrentMhz; ULONG32 ProcessorMhzLimit;
// ULONG32 ProcessorMaxIdleState; ULONG32 ProcessorCurrentIdleState; } MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MISC_INFO_2")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MISC_INFO_2
{
/// <summary>The size of the structure, in bytes.</summary>
public uint SizeOfInfo ;
/// <summary>
/// <para>The flags that indicate the valid members of this structure. This member can be one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>MINIDUMP_MISC1_PROCESS_ID 0x00000001</term>
/// <term>ProcessId is used.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_MISC1_PROCESS_TIMES 0x00000002</term>
/// <term>ProcessCreateTime, ProcessKernelTime, and ProcessUserTime are used.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004</term>
/// <term>
/// ProcessorMaxMhz, ProcessorCurrentMhz, ProcessorMhzLimit, ProcessorMaxIdleState, and ProcessorCurrentIdleState are used.
/// </term>
/// </item>
/// </list>
/// </summary>
public uint Flags1 ;
/// <summary>
/// The identifier of the process. If <c>Flags1</c> does not specify <c>MINIDUMP_MISC1_PROCESS_ID</c>, this member is unused.
/// </summary>
public uint ProcessId ;
/// <summary>
/// The creation time of the process, in <c>time_t</c> format. If <c>Flags1</c> does not specify
/// <c>MINIDUMP_MISC1_PROCESS_TIMES</c>, this member is unused.
/// </summary>
public uint ProcessCreateTime ;
/// <summary>
/// The time the process has executed in user mode, in seconds. The time that each of the threads of the process has executed in
/// user mode is determined, then all these times are summed to obtain this value. If <c>Flags1</c> does not specify
/// <c>MINIDUMP_MISC1_PROCESS_TIMES</c>, this member is unused.
/// </summary>
public uint ProcessUserTime ;
/// <summary>
/// The time the process has executed in kernel mode, in seconds. The time that each of the threads of the process has executed
/// in kernel mode is determined, then all these times are summed to obtain this value. If <c>Flags1</c> does not specify
/// <c>MINIDUMP_MISC1_PROCESS_TIMES</c>, this member is unused.
/// </summary>
public uint ProcessKernelTime ;
/// <summary>
/// The maximum specified clock frequency of the system processor, in MHz. If <c>Flags1</c> does not specify
/// <c>MINIDUMP_MISC1_PROCESSOR_POWER_INFO</c>, this member is unused.
/// </summary>
public uint ProcessorMaxMhz ;
/// <summary>
/// The processor clock frequency, in MHz. This number is the maximum specified processor clock frequency multiplied by the
/// current processor throttle. If <c>Flags1</c> does not specify <c>MINIDUMP_MISC1_PROCESSOR_POWER_INFO</c>, this member is unused.
/// </summary>
public uint ProcessorCurrentMhz ;
/// <summary>
/// The limit on the processor clock frequency, in MHz. This number is the maximum specified processor clock frequency
/// multiplied by the current processor thermal throttle limit. If <c>Flags1</c> does not specify
/// <c>MINIDUMP_MISC1_PROCESSOR_POWER_INFO</c>, this member is unused.
/// </summary>
public uint ProcessorMhzLimit ;
/// <summary>
/// The maximum idle state of the processor. If <c>Flags1</c> does not specify <c>MINIDUMP_MISC1_PROCESSOR_POWER_INFO</c>, this
/// member is unused.
/// </summary>
public uint ProcessorMaxIdleState ;
/// <summary>
/// The current idle state of the processor. If <c>Flags1</c> does not specify <c>MINIDUMP_MISC1_PROCESSOR_POWER_INFO</c>, this
/// member is unused.
/// </summary>
public uint ProcessorCurrentIdleState ;
}
/// <summary>Contains information for a specific module.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_module typedef struct
// _MINIDUMP_MODULE { ULONG64 BaseOfImage; ULONG32 SizeOfImage; ULONG32 CheckSum; ULONG32 TimeDateStamp; RVA ModuleNameRva;
// VS_FIXEDFILEINFO VersionInfo; MINIDUMP_LOCATION_DESCRIPTOR CvRecord; MINIDUMP_LOCATION_DESCRIPTOR MiscRecord; ULONG64 Reserved0;
// ULONG64 Reserved1; } MINIDUMP_MODULE, *PMINIDUMP_MODULE;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MODULE")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MODULE
{
/// <summary>The base address of the module executable image in memory.</summary>
public ulong BaseOfImage ;
/// <summary>The size of the module executable image in memory, in bytes.</summary>
public uint SizeOfImage ;
/// <summary>The checksum value of the module executable image.</summary>
public uint CheckSum ;
/// <summary>The timestamp value of the module executable image, in <c>time_t</c> format.</summary>
public uint TimeDateStamp ;
/// <summary>An RVA to a MINIDUMP_STRING structure that specifies the name of the module.</summary>
public uint ModuleNameRva ;
/// <summary>A VS_FIXEDFILEINFO structure that specifies the version of the module.</summary>
2021-02-03 15:57:49 -05:00
public VersionDll . VS_FIXEDFILEINFO VersionInfo ;
2021-02-03 10:41:28 -05:00
/// <summary>A MINIDUMP_LOCATION_DESCRIPTOR structure that specifies the CodeView record of the module.</summary>
public MINIDUMP_LOCATION_DESCRIPTOR CvRecord ;
/// <summary>A MINIDUMP_LOCATION_DESCRIPTOR structure that specifies the miscellaneous record of the module.</summary>
public MINIDUMP_LOCATION_DESCRIPTOR MiscRecord ;
/// <summary>Reserved for future use.</summary>
public ulong Reserved0 ;
/// <summary>Reserved for future use.</summary>
public ulong Reserved1 ;
}
/// <summary>Contains module information for the MiniDumpCallback function when the callback type is ModuleCallback.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_module_callback typedef struct
// _MINIDUMP_MODULE_CALLBACK { PWCHAR FullPath; ULONG64 BaseOfImage; ULONG SizeOfImage; ULONG CheckSum; ULONG TimeDateStamp;
// VS_FIXEDFILEINFO VersionInfo; PVOID CvRecord; ULONG SizeOfCvRecord; PVOID MiscRecord; ULONG SizeOfMiscRecord; }
// MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MODULE_CALLBACK")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MODULE_CALLBACK
{
/// <summary>The fully qualified path of the module executable.</summary>
public StrPtrUni FullPath ;
/// <summary>The base address of the module executable image in memory.</summary>
public ulong BaseOfImage ;
/// <summary>The size of the module executable image in memory, in bytes.</summary>
public uint SizeOfImage ;
/// <summary>The checksum value of the module executable image.</summary>
public uint CheckSum ;
/// <summary>The timestamp value of the module executable image, in <c>time_t</c> format.</summary>
public time_t TimeDateStamp ;
/// <summary>A VS_FIXEDFILEINFO structure that specifies the version of the module.</summary>
2021-02-03 15:57:49 -05:00
public VersionDll . VS_FIXEDFILEINFO VersionInfo ;
2021-02-03 10:41:28 -05:00
/// <summary>A pointer to a string containing the CodeView record of the module.</summary>
public IntPtr CvRecord ;
/// <summary>The size of the Codeview record of the module in the <c>CvRecord</c> member, in bytes.</summary>
public uint SizeOfCvRecord ;
/// <summary>A pointer to a string that specifies the miscellaneous record of the module.</summary>
public IntPtr MiscRecord ;
/// <summary>The size of the miscellaneous record of the module in the <c>MiscRecord</c> member, in bytes.</summary>
public uint SizeOfMiscRecord ;
}
/// <summary>Contains a list of modules.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_module_list typedef struct
// _MINIDUMP_MODULE_LIST { ULONG32 NumberOfModules; MINIDUMP_MODULE Modules[0]; } MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_MODULE_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_MODULE_LIST
{
/// <summary>The number of structures in the <c>Modules</c> array.</summary>
public uint NumberOfModules ;
/// <summary>An array of MINIDUMP_MODULE structures.</summary>
public MINIDUMP_MODULE [ ] Modules ;
}
/// <summary>
/// Contains information about a failed memory read operation. This structure is used by the MiniDumpCallbackfunction when the
/// callback type is ReadMemoryFailureCallback.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_read_memory_failure_callback typedef
// struct _MINIDUMP_READ_MEMORY_FAILURE_CALLBACK { ULONG64 Offset; ULONG Bytes; HRESULT FailureStatus; }
// MINIDUMP_READ_MEMORY_FAILURE_CALLBACK, *PMINIDUMP_READ_MEMORY_FAILURE_CALLBACK;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_READ_MEMORY_FAILURE_CALLBACK")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_READ_MEMORY_FAILURE_CALLBACK
{
/// <summary>The offset of the address for the failed memory read operation.</summary>
public ulong Offset ;
/// <summary>The size of the failed memory read operation, in bytes.</summary>
public uint Bytes ;
/// <summary>The resulting error code from the failed memory read operation.</summary>
public HRESULT FailureStatus ;
}
/// <summary>Describes a string.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_string typedef struct
// _MINIDUMP_STRING { ULONG32 Length; WCHAR Buffer[0]; } MINIDUMP_STRING, *PMINIDUMP_STRING;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_STRING")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MINIDUMP_STRING
{
/// <summary>
/// The size of the string in the <c>Buffer</c> member, in bytes. This size does not include the null-terminating character.
/// </summary>
public uint Length ;
/// <summary>The null-terminated string.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0)]
public string Buffer ;
}
/// <summary>Contains processor and operating system information.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_system_info typedef struct
// _MINIDUMP_SYSTEM_INFO { USHORT ProcessorArchitecture; USHORT ProcessorLevel; USHORT ProcessorRevision; union { USHORT Reserved0;
// struct { UCHAR NumberOfProcessors; UCHAR ProductType; }; }; ULONG32 MajorVersion; ULONG32 MinorVersion; ULONG32 BuildNumber;
// ULONG32 PlatformId; RVA CSDVersionRva; union { ULONG32 Reserved1; struct { USHORT SuiteMask; USHORT Reserved2; }; };
// CPU_INFORMATION Cpu; } MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_SYSTEM_INFO")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_SYSTEM_INFO
{
/// <summary>
/// <para>The system's processor architecture. <see cref="Kernel32.SYSTEM_INFO"/> This member can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PROCESSOR_ARCHITECTURE_AMD64 9</term>
/// <term>x64 (AMD or Intel)</term>
/// </item>
/// <item>
/// <term>PROCESSOR_ARCHITECTURE_ARM 5</term>
/// <term>ARM</term>
/// </item>
/// <item>
/// <term>PROCESSOR_ARCHITECTURE_IA64 6</term>
/// <term>Intel Itanium</term>
/// </item>
/// <item>
/// <term>PROCESSOR_ARCHITECTURE_INTEL 0</term>
/// <term>x86</term>
/// </item>
/// <item>
/// <term>PROCESSOR_ARCHITECTURE_UNKNOWN 0xffff</term>
/// <term>Unknown processor.</term>
/// </item>
/// </list>
/// </summary>
public ProcessorArchitecture ProcessorArchitecture ;
/// <summary>
/// <para>The system's architecture-dependent processor level.</para>
/// <para>
/// If <c>ProcessorArchitecture</c> is <c>PROCESSOR_ARCHITECTURE_INTEL</c>, <c>ProcessorLevel</c> can be one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>3</term>
/// <term>Intel 80386</term>
/// </item>
/// <item>
/// <term>4</term>
/// <term>Intel 80486</term>
/// </item>
/// <item>
/// <term>5</term>
/// <term>Intel Pentium</term>
/// </item>
/// <item>
/// <term>6</term>
/// <term>Intel Pentium Pro or Pentium II</term>
/// </item>
/// </list>
/// <para>If <c>ProcessorArchitecture</c> is <c>PROCESSOR_ARCHITECTURE_IA64</c>, <c>ProcessorLevel</c> is set to 1.</para>
/// </summary>
public ushort ProcessorLevel ;
/// <summary>
/// <para>The architecture-dependent processor revision.</para>
/// <list type="table">
/// <listheader>
/// <term>Processor</term>
/// <term>Value</term>
/// </listheader>
/// <item>
/// <term>Intel 80386 or 80486</term>
/// <term>
/// A value of the form xxyz. If xx is equal to 0xFF, y - 0xA is the model number, and z is the stepping identifier. For
/// example, an Intel 80486-D0 system returns 0xFFD0. If xx is not equal to 0xFF, xx + 'A' is the stepping letter and yz is the
/// minor stepping.
/// </term>
/// </item>
/// <item>
/// <term>Intel Pentium, Cyrix, or NextGen 586</term>
/// <term>
/// A value of the form xxyy, where xx is the model number and yy is the stepping. Display this value of 0x0201 as follows:
/// Model xx, Stepping yy
/// </term>
/// </item>
/// </list>
/// </summary>
public ushort ProcessorRevision ;
/// <summary>The number of processors in the system.</summary>
public byte NumberOfProcessors ;
/// <summary>
/// <para>Any additional information about the system. This member can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>VER_NT_DOMAIN_CONTROLLER 0x0000002</term>
/// <term>The system is a domain controller.</term>
/// </item>
/// <item>
/// <term>VER_NT_SERVER 0x0000003</term>
/// <term>The system is a server.</term>
/// </item>
/// <item>
/// <term>VER_NT_WORKSTATION 0x0000001</term>
/// <term>The system is running Windows XP, Windows Vista, Windows 7, or Windows 8.</term>
/// </item>
/// </list>
/// </summary>
public Kernel32 . ProductType ProductType ;
/// <summary>The major version number of the operating system. This member can be 4, 5, or 6.</summary>
public uint MajorVersion ;
/// <summary>The minor version number of the operating system.</summary>
public uint MinorVersion ;
/// <summary>The build number of the operating system.</summary>
public uint BuildNumber ;
/// <summary>
/// <para>The operating system platform. This member can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>VER_PLATFORM_WIN32s 0</term>
/// <term>Not supported</term>
/// </item>
/// <item>
/// <term>VER_PLATFORM_WIN32_WINDOWS 1</term>
/// <term>Not supported.</term>
/// </item>
/// <item>
/// <term>VER_PLATFORM_WIN32_NT 2</term>
/// <term>The operating system platform is Windows.</term>
/// </item>
/// </list>
/// </summary>
public PlatformID PlatformId ;
/// <summary>
/// An RVA (from the beginning of the dump) to a MINIDUMP_STRING that describes the latest Service Pack installed on the system.
/// If no Service Pack has been installed, the string is empty.
/// </summary>
public uint CSDVersionRva ;
/// <summary>
/// <para>
/// The bit flags that identify the product suites available on the system. This member can be a combination of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>VER_SUITE_BACKOFFICE 0x00000004</term>
/// <term>Microsoft BackOffice components are installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_BLADE 0x00000400</term>
/// <term>Windows Server 2003, Web Edition is installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_COMPUTE_SERVER 0x00004000</term>
/// <term>Windows Server 2003, Compute Cluster Edition is installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_DATACENTER 0x00000080</term>
/// <term>Windows Server 2008 R2 Datacenter, Windows Server 2008 Datacenter, or Windows Server 2003, Datacenter Edition is installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_ENTERPRISE 0x00000002</term>
/// <term>Windows Server 2008 R2 Enterprise, Windows Server 2008 Enterprise, or Windows Server 2003, Enterprise Edition is installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_EMBEDDEDNT 0x00000040</term>
/// <term>Windows Embedded is installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_PERSONAL 0x00000200</term>
/// <term>Windows XP Home Edition is installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_SINGLEUSERTS 0x00000100</term>
/// <term>
/// Remote Desktop is supported, but only one interactive session is supported. This value is set unless the system is running
/// in application server mode.
/// </term>
/// </item>
/// <item>
/// <term>VER_SUITE_SMALLBUSINESS 0x00000001</term>
/// <term>
/// Microsoft Small Business Server was once installed on the system, but may have been upgraded to another version of Windows.
/// </term>
/// </item>
/// <item>
/// <term>VER_SUITE_SMALLBUSINESS_RESTRICTED 0x00000020</term>
/// <term>Microsoft Small Business Server is installed with the restrictive client license in force.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_STORAGE_SERVER 0x00002000</term>
/// <term>Windows Storage Server is installed.</term>
/// </item>
/// <item>
/// <term>VER_SUITE_TERMINAL 0x00000010</term>
/// <term>
/// Terminal Services is installed. This value is always set. If VER_SUITE_TERMINAL is set but VER_SUITE_SINGLEUSERTS is not
/// set, the system is running in application server mode.
/// </term>
/// </item>
/// </list>
/// </summary>
public Kernel32 . SuiteMask SuiteMask ;
/// <summary>This member is reserved for future use.</summary>
public ushort Reserved2 ;
/// <summary>
/// <para>X86CpuInfo</para>
/// <para>The CPU information obtained from the CPUID instruction. This structure is supported only for x86 computers.</para>
/// <para>VendorId</para>
/// <para>CPUID subfunction 0. The array elements are as follows:</para>
/// <para>VersionInformation</para>
/// <para>CPUID subfunction 1. Value of EAX.</para>
/// <para>FeatureInformation</para>
/// <para>CPUID subfunction 1. Value of EDX.</para>
/// <para>AMDExtendedCpuFeatures</para>
/// <para>CPUID subfunction 80000001. Value of EBX. This member is supported only if the vendor is "AuthenticAMD".</para>
/// <para>OtherCpuInfo</para>
/// <para>Other CPU information. This structure is supported only for non-x86 computers.</para>
/// <para>ProcessorFeatures</para>
/// <para>For a list of possible values, see the IsProcessorFeaturePresent function.</para>
/// </summary>
public CPU_INFORMATION Cpu ;
}
/// <summary>Contains information for a specific thread.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread typedef struct
// _MINIDUMP_THREAD { ULONG32 ThreadId; ULONG32 SuspendCount; ULONG32 PriorityClass; ULONG32 Priority; ULONG64 Teb;
// MINIDUMP_MEMORY_DESCRIPTOR Stack; MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; } MINIDUMP_THREAD, *PMINIDUMP_THREAD;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD
{
/// <summary>The identifier of the thread.</summary>
public uint ThreadId ;
/// <summary>
/// The suspend count for the thread. If the suspend count is greater than zero, the thread is suspended; otherwise, the thread
/// is not suspended. The maximum value is MAXIMUM_SUSPEND_COUNT.
/// </summary>
public uint SuspendCount ;
/// <summary>The priority class of the thread. See Scheduling Priorities.</summary>
public uint PriorityClass ;
/// <summary>The priority level of the thread.</summary>
public uint Priority ;
/// <summary>The thread environment block.</summary>
public ulong Teb ;
/// <summary>A MINIDUMP_MEMORY_DESCRIPTOR structure.</summary>
public MINIDUMP_MEMORY_DESCRIPTOR Stack ;
/// <summary>A MINIDUMP_LOCATION_DESCRIPTOR structure.</summary>
public MINIDUMP_LOCATION_DESCRIPTOR ThreadContext ;
}
/// <summary>Contains thread information for the MiniDumpCallback function when the callback type is ThreadCallback.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread_callback typedef struct
// _MINIDUMP_THREAD_CALLBACK { ULONG ThreadId; HANDLE ThreadHandle; ULONG Pad; CONTEXT Context; ULONG SizeOfContext; ULONG64
// StackBase; ULONG64 StackEnd; } MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_CALLBACK")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD_CALLBACK
{
/// <summary>The identifier of the thread.</summary>
public uint ThreadId ;
/// <summary>A handle to the thread</summary>
public HTHREAD ThreadHandle ;
/// <summary/>
public uint Pad ;
/// <summary>A CONTEXT structure that contains the processor-specific data.</summary>
public CONTEXT Context ;
/// <summary>The size of the returned processor-specific data in the <c>Context</c> member, in bytes.</summary>
public uint SizeOfContext ;
/// <summary>The base address of the thread stack.</summary>
public ulong StackBase ;
/// <summary>The ending address of the thread stack.</summary>
public ulong StackEnd ;
}
/// <summary>Contains extended information for a specific thread.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread_ex typedef struct
// _MINIDUMP_THREAD_EX { ULONG32 ThreadId; ULONG32 SuspendCount; ULONG32 PriorityClass; ULONG32 Priority; ULONG64 Teb;
// MINIDUMP_MEMORY_DESCRIPTOR Stack; MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; MINIDUMP_MEMORY_DESCRIPTOR BackingStore; }
// MINIDUMP_THREAD_EX, *PMINIDUMP_THREAD_EX;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_EX")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD_EX
{
/// <summary>The identifier of the thread.</summary>
public uint ThreadId ;
/// <summary>
/// The suspend count for the thread. If the suspend count is greater than zero, the thread is suspended; otherwise, the thread
/// is not suspended. The maximum value is MAXIMUM_SUSPEND_COUNT.
/// </summary>
public uint SuspendCount ;
/// <summary>The priority class of the thread. See Scheduling Priorities.</summary>
public uint PriorityClass ;
/// <summary>The priority level of the thread.</summary>
public uint Priority ;
/// <summary>The thread environment block.</summary>
public ulong Teb ;
/// <summary>A MINIDUMP_MEMORY_DESCRIPTOR structure.</summary>
public MINIDUMP_MEMORY_DESCRIPTOR Stack ;
/// <summary>A MINIDUMP_LOCATION_DESCRIPTOR structure.</summary>
public MINIDUMP_LOCATION_DESCRIPTOR ThreadContext ;
/// <summary><c>Intel Itanium:</c> The backing store for the thread.</summary>
public MINIDUMP_MEMORY_DESCRIPTOR BackingStore ;
}
/// <summary>Contains extended thread information for the MiniDumpCallback function when the callback type is ThreadExCallback.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread_ex_callback typedef struct
// _MINIDUMP_THREAD_EX_CALLBACK { ULONG ThreadId; HANDLE ThreadHandle; ULONG Pad; CONTEXT Context; ULONG SizeOfContext; ULONG64
// StackBase; ULONG64 StackEnd; ULONG64 BackingStoreBase; ULONG64 BackingStoreEnd; } MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_EX_CALLBACK")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD_EX_CALLBACK
{
/// <summary>The identifier of the thread.</summary>
public uint ThreadId ;
/// <summary>A handle to the thread</summary>
public HTHREAD ThreadHandle ;
/// <summary/>
public uint Pad ;
/// <summary>A CONTEXT structure that contains the processor-specific data.</summary>
public CONTEXT Context ;
/// <summary>The size of the returned processor-specific data in the <c>Context</c> member, in bytes.</summary>
public uint SizeOfContext ;
/// <summary>The base address of the thread stack.</summary>
public ulong StackBase ;
/// <summary>The ending address of the thread stack.</summary>
public ulong StackEnd ;
/// <summary><c>Intel Itanium:</c> The base address of the thread backing store.</summary>
public ulong BackingStoreBase ;
/// <summary><c>Intel Itanium:</c> The ending address of the thread backing store.</summary>
public ulong BackingStoreEnd ;
}
/// <summary>Contains a list of threads.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread_ex_list typedef struct
// _MINIDUMP_THREAD_EX_LIST { ULONG32 NumberOfThreads; MINIDUMP_THREAD_EX Threads[0]; } MINIDUMP_THREAD_EX_LIST, *PMINIDUMP_THREAD_EX_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_EX_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD_EX_LIST
{
/// <summary>The number of structures in the <c>Threads</c> array.</summary>
public uint NumberOfThreads ;
/// <summary>An array of MINIDUMP_THREAD_EX structures.</summary>
public MINIDUMP_THREAD_EX [ ] Threads ;
}
/// <summary>Contains thread state information.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread_info typedef struct
// _MINIDUMP_THREAD_INFO { ULONG32 ThreadId; ULONG32 DumpFlags; ULONG32 DumpError; ULONG32 ExitStatus; ULONG64 CreateTime; ULONG64
// ExitTime; ULONG64 KernelTime; ULONG64 UserTime; ULONG64 StartAddress; ULONG64 Affinity; } MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_INFO")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD_INFO
{
/// <summary>The identifier of the thread.</summary>
public uint ThreadId ;
/// <summary>
/// <para>The flags that indicate the thread state. This member can be 0 or one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>MINIDUMP_THREAD_INFO_ERROR_THREAD 0x00000001</term>
/// <term>A placeholder thread due to an error accessing the thread. No thread information exists beyond the thread identifier.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_THREAD_INFO_EXITED_THREAD 0x00000004</term>
/// <term>The thread has exited (not running any code) at the time of the dump.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010</term>
/// <term>Thread context could not be retrieved.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_THREAD_INFO_INVALID_INFO 0x00000008</term>
/// <term>Thread information could not be retrieved.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_THREAD_INFO_INVALID_TEB 0x00000020</term>
/// <term>TEB information could not be retrieved.</term>
/// </item>
/// <item>
/// <term>MINIDUMP_THREAD_INFO_WRITING_THREAD 0x00000002</term>
/// <term>This is the thread that called MiniDumpWriteDump.</term>
/// </item>
/// </list>
/// </summary>
public MINIDUMP_THREAD_INFO_FLAG DumpFlags ;
/// <summary>An <c>HRESULT</c> value that indicates the dump status.</summary>
public HRESULT DumpError ;
/// <summary>The thread termination status code.</summary>
public uint ExitStatus ;
/// <summary>The time when the thread was created, in 100-nanosecond intervals since January 1, 1601 (UTC).</summary>
public ulong CreateTime ;
/// <summary>The time when the thread exited, in 100-nanosecond intervals since January 1, 1601 (UTC).</summary>
public ulong ExitTime ;
/// <summary>The time executed in kernel mode, in 100-nanosecond intervals.</summary>
public ulong KernelTime ;
/// <summary>The time executed in user mode, in 100-nanosecond intervals.</summary>
public ulong UserTime ;
/// <summary>The starting address of the thread.</summary>
public ulong StartAddress ;
/// <summary>The processor affinity mask.</summary>
public ulong Affinity ;
}
/// <summary>Contains a list of threads.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread_info_list typedef struct
// _MINIDUMP_THREAD_INFO_LIST { ULONG SizeOfHeader; ULONG SizeOfEntry; ULONG NumberOfEntries; } MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_INFO_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD_INFO_LIST
{
/// <summary>
/// The size of the header data for the stream, in bytes. This is generally
/// <code>sizeof(MINIDUMP_THREAD_INFO_LIST)</code>
/// .
/// </summary>
public uint SizeOfHeader ;
/// <summary>
/// The size of each entry following the header, in bytes. This is generally
/// <code>sizeof(MINIDUMP_THREAD_INFO)</code>
/// .
/// </summary>
public uint SizeOfEntry ;
/// <summary>
/// The number of entries in the stream. These are generally MINIDUMP_THREAD_INFO structures. The entries follow the header.
/// </summary>
public uint NumberOfEntries ;
}
/// <summary>Contains a list of threads.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_thread_list typedef struct
// _MINIDUMP_THREAD_LIST { ULONG32 NumberOfThreads; MINIDUMP_THREAD Threads[0]; } MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_THREAD_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_THREAD_LIST
{
/// <summary>The number of structures in the <c>Threads</c> array.</summary>
public uint NumberOfThreads ;
/// <summary>An array of MINIDUMP_THREAD structures.</summary>
public MINIDUMP_THREAD [ ] Threads ;
}
/// <summary>
/// Contains information about a module that has been unloaded. This information can help diagnose problems calling code that is no
/// longer loaded.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_unloaded_module typedef struct
// _MINIDUMP_UNLOADED_MODULE { ULONG64 BaseOfImage; ULONG32 SizeOfImage; ULONG32 CheckSum; ULONG32 TimeDateStamp; RVA ModuleNameRva;
// } MINIDUMP_UNLOADED_MODULE, *PMINIDUMP_UNLOADED_MODULE;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_UNLOADED_MODULE")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_UNLOADED_MODULE
{
/// <summary>The base address of the module executable image in memory.</summary>
public ulong BaseOfImage ;
/// <summary>The size of the module executable image in memory, in bytes.</summary>
public uint SizeOfImage ;
/// <summary>The checksum value of the module executable image.</summary>
public uint CheckSum ;
/// <summary>The timestamp value of the module executable image, in <c>time_t</c> format.</summary>
public time_t TimeDateStamp ;
/// <summary>An RVA to a MINIDUMP_STRING structure that specifies the name of the module.</summary>
public uint ModuleNameRva ;
}
/// <summary>Contains a list of unloaded modules.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_unloaded_module_list typedef struct
// _MINIDUMP_UNLOADED_MODULE_LIST { ULONG32 SizeOfHeader; ULONG32 SizeOfEntry; ULONG32 NumberOfEntries; }
// MINIDUMP_UNLOADED_MODULE_LIST, *PMINIDUMP_UNLOADED_MODULE_LIST;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_UNLOADED_MODULE_LIST")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_UNLOADED_MODULE_LIST
{
/// <summary>
/// The size of the header data for the stream, in bytes. This is generally
/// <code>sizeof(MINIDUMP_UNLOADED_MODULE_LIST)</code>
/// .
/// </summary>
public uint SizeOfHeader ;
/// <summary>
/// The size of each entry following the header, in bytes. This is generally
/// <code>sizeof(MINIDUMP_UNLOADED_MODULE)</code>
/// .
/// </summary>
public uint SizeOfEntry ;
/// <summary>
/// The number of entries in the stream. These are generally MINIDUMP_UNLOADED_MODULE structures. The entries follow the header.
/// </summary>
public uint NumberOfEntries ;
}
/// <summary>Contains user-defined information stored in a data stream.</summary>
/// <remarks>In this context, a data stream refers to a block of data within a minidump file.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_user_stream typedef struct
// _MINIDUMP_USER_STREAM { ULONG32 Type; ULONG BufferSize; PVOID Buffer; } MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_USER_STREAM")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_USER_STREAM
{
/// <summary>The type of data stream. For more information, see MINIDUMP_STREAM_TYPE.</summary>
public uint Type ;
/// <summary>The size of the user-defined data stream buffer, in bytes.</summary>
public uint BufferSize ;
/// <summary>A pointer to a buffer that contains the user-defined data stream.</summary>
public IntPtr Buffer ;
}
/// <summary>Contains a list of user data streams used by the MiniDumpWriteDump function.</summary>
/// <remarks>In this context, a data stream refers to a block of data within a minidump file.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/ns-minidumpapiset-minidump_user_stream_information typedef
// struct _MINIDUMP_USER_STREAM_INFORMATION { ULONG UserStreamCount; PMINIDUMP_USER_STREAM UserStreamArray; }
// MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION;
[PInvokeData("minidumpapiset.h", MSDNShortId = "NS:minidumpapiset._MINIDUMP_USER_STREAM_INFORMATION")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_USER_STREAM_INFORMATION
{
/// <summary>The number of user streams.</summary>
public uint UserStreamCount ;
/// <summary>An array of MINIDUMP_USER_STREAM structures.</summary>
public MINIDUMP_USER_STREAM [ ] UserStreamArray ;
}
2021-02-03 15:59:26 -05:00
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
2021-02-03 10:41:28 -05:00
[PInvokeData("minidumpapiset.h")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_VM_POST_READ_CALLBACK
{
public ulong Offset ;
public IntPtr Buffer ;
public uint Size ;
public uint Completed ;
public HRESULT Status ;
}
[PInvokeData("minidumpapiset.h")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_VM_PRE_READ_CALLBACK
{
public ulong Offset ;
public IntPtr Buffer ;
public uint Size ;
}
[PInvokeData("minidumpapiset.h")]
[StructLayout(LayoutKind.Sequential)]
public struct MINIDUMP_VM_QUERY_CALLBACK
{
public ulong Offset ;
}
2021-02-03 15:59:26 -05:00
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
2020-08-07 14:37:42 -04:00
}
}