windows-xp/Source/XPSP1/NT/sdktools/debuggers/minidump/mdump.h

/*++

Copyright(c) 1999-2002 Microsoft Corporation

Module Name:

    mdump.h

Abstract:

    Private header for minidump user-mode crashdump support.
    
Author:

    Matthew D Hendel (math) 20-Aug-1999

--*/


#pragma once

#include "platform.h"

#define IsFlagSet(_var, _flag) ( ((_var) & (_flag)) != 0 )

#define IsFlagClear(_var, _flag) ( !IsFlagSet(_var, _flag) )


//
// StartOfStack gives the lowest address of the stack. SizeOfStack gives
// the size of the stack. Used together, they will give the memory region
// used by the stack.
//

#define StartOfStack(_thread) ((_thread)->StackEnd)

#define SizeOfStack(_thread) ((ULONG)((_thread)->StackBase - (_thread)->StackEnd)))


// Types of memory regions.
typedef enum
{
    MEMBLOCK_OTHER,
    MEMBLOCK_MERGED,
    MEMBLOCK_STACK,
    MEMBLOCK_STORE,
    MEMBLOCK_DATA_SEG,
    MEMBLOCK_UNWIND_INFO,
    MEMBLOCK_INSTR_WINDOW,
    MEMBLOCK_PEB,
    MEMBLOCK_TEB,
    MEMBLOCK_INDIRECT,
    MEMBLOCK_PRIVATE_RW,
} MEMBLOCK_TYPE;

//
// A VA_RANGE is a range of addresses that represents Size bytes beginning
// at Start.
//

typedef struct _VA_RANGE {
    ULONG64 Start;
    ULONG Size;
    MEMBLOCK_TYPE Type;
    LIST_ENTRY NextLink;
} VA_RANGE, *PVA_RANGE;


//
// INTERNAL_MODULE is the structure minidump uses internally to manage modules.
// A linked list of INTERNAL_MODULE structures are built up when
// GenGetProcessInfo is called.
//
//

typedef struct _INTERNAL_MODULE {

    //
    // File handle to the image.
    //
    
    HANDLE FileHandle;

    //
    // Base address, size, CheckSum, and TimeDateStamp for the image.
    //
    
    ULONG64 BaseOfImage;
    ULONG SizeOfImage;
    ULONG CheckSum;
    ULONG TimeDateStamp;

    //
    // Version information for the image.
    //
    
    VS_FIXEDFILEINFO VersionInfo;


    //
    // Buffer and size containing NB10 record for given module.
    //
    
    PVOID CvRecord;
    ULONG SizeOfCvRecord;

    //
    // Buffer and size of MISC debug record. We only get this with
    // images that have been split.
    //

    PVOID MiscRecord;
    ULONG SizeOfMiscRecord;

    //
    // Full path to the image.
    //
    
    WCHAR FullPath [ MAX_PATH + 1];
    // Portion of full path to write in the module list.  This
    // allows paths to be filtered out for privacy reasons.
    PWSTR SavePath;

    //
    // What sections of the module does the client want written.
    //
    
    ULONG WriteFlags;
    
    //
    // Next image pointer.
    //

    LIST_ENTRY ModulesLink;

} INTERNAL_MODULE, *PINTERNAL_MODULE;


//
// INTERNAL_UNLOADED_MODULE is the structure minidump uses
// internally to manage unloaded modules.
// A linked list of INTERNAL_UNLOADED_MODULE structures are built up when
// GenGetProcessInfo is called.
//
//

typedef struct _INTERNAL_UNLOADED_MODULE {

    ULONG64 BaseOfImage;
    ULONG SizeOfImage;
    ULONG CheckSum;
    ULONG TimeDateStamp;

    //
    // As much of the path to the image as can be recovered.
    //
    
    WCHAR Path[MAX_PATH + 1];

    //
    // Next image pointer.
    //

    LIST_ENTRY ModulesLink;

} INTERNAL_UNLOADED_MODULE, *PINTERNAL_UNLOADED_MODULE;



//
// INTERNAL_THREAD is the structure the minidump uses internally to
// manage threads. A list of INTERNAL_THREAD structures is built when
// GenGetProcessInfo is called.
//

typedef struct _INTERNAL_THREAD {

    //
    // The Win32 thread id of the thread an an open handle for the
    // thread.
    //
    
    ULONG ThreadId;
    HANDLE ThreadHandle;

    //
    // Suspend count, priority, priority class for the thread.
    //
    
    ULONG SuspendCount;
    ULONG PriorityClass;
    ULONG Priority;

    //
    // Thread TEB, Context and Size of Context.
    //
    
    ULONG64 Teb;
    ULONG SizeOfTeb;
    CONTEXT Context;
    ULONG SizeOfContext;

    //
    // Stack variables. Remember, the stack grows down, so StackBase is
    // the highest stack address and StackEnd is the lowest.
    //
    
    ULONG64 StackBase;
    ULONG64 StackEnd;

    //
    // Backing store variables.
    //

    ULONG64 BackingStoreBase;
    ULONG BackingStoreSize;

    //
    // What sections of the module we should actually write to the file.
    //
    
    ULONG WriteFlags;
    
    //
    // Link to next thread.
    //
    
    LIST_ENTRY ThreadsLink;

} INTERNAL_THREAD, *PINTERNAL_THREAD;

//
// INTERNAL_FUNCTION_TABLE is the structure minidump uses
// internally to manage function tables.
// A linked list of INTERNAL_FUNCTION_TABLE structures is built up when
// GenGetProcessInfo is called.
//

typedef struct _INTERNAL_FUNCTION_TABLE {

    ULONG64 MinimumAddress;
    ULONG64 MaximumAddress;
    ULONG64 BaseAddress;
    ULONG EntryCount;
    DYNAMIC_FUNCTION_TABLE RawTable;
    PVOID RawEntries;

    LIST_ENTRY TableLink;

} INTERNAL_FUNCTION_TABLE, *PINTERNAL_FUNCTION_TABLE;


typedef struct _INTERNAL_PROCESS {

    //
    // The process id for the process.
    //

    ULONG ProcessId;

    //
    // Process data.
    //

    ULONG64 Peb;
    ULONG SizeOfPeb;

    //
    // Process run time information.
    //

    BOOL TimesValid;
    ULONG CreateTime;
    ULONG UserTime;
    ULONG KernelTime;

    //
    // An open handle to the process with read permissions.
    //
    
    HANDLE ProcessHandle;

    //
    // Number of threads for the process.
    //
    
    ULONG NumberOfThreads;
    ULONG NumberOfThreadsToWrite;
    ULONG MaxStackOrStoreSize;

    //
    // Number of modules for the process.
    //
    
    ULONG NumberOfModules;
    ULONG NumberOfModulesToWrite;

    //
    // Number of unloaded modules for the process.
    //
    
    ULONG NumberOfUnloadedModules;

    //
    // Number of function tables for the process.
    //
    
    ULONG NumberOfFunctionTables;

    //
    // Thread, module and function table lists for the process.
    //
    
    LIST_ENTRY ThreadList;
    LIST_ENTRY ModuleList;
    LIST_ENTRY UnloadedModuleList;
    LIST_ENTRY FunctionTableList;

    //
    // List of memory blocks to include for the process.
    //

    LIST_ENTRY MemoryBlocks;
    ULONG NumberOfMemoryBlocks;
    ULONG SizeOfMemoryBlocks;

} INTERNAL_PROCESS, *PINTERNAL_PROCESS;


//
// The visible streams are: (1) machine info, (2) exception, (3) thread list,
// (4) module list (5) memory list (6) misc info.
// We also add two extra for post-processing tools that want to add data later.
//

#define NUMBER_OF_STREAMS   (8)

//
// MINIDUMP_STREAM_INFO is the structure used by the minidump to manage
// it's internal data streams.
//

typedef struct _MINIDUMP_STREAM_INFO {

    //
    // How many streams we have.
    //
    
    ULONG NumberOfStreams;
    
    //
    // Reserved space for header.
    //
    
    ULONG RvaOfHeader;
    ULONG SizeOfHeader;

    //
    // Reserved space for directory.
    //

    ULONG RvaOfDirectory;
    ULONG SizeOfDirectory;

    //
    // Reserved space for system info.
    //

    ULONG RvaOfSystemInfo;
    ULONG SizeOfSystemInfo;
    ULONG VersionStringLength;

    //
    // Reserved space for misc info.
    //

    ULONG RvaOfMiscInfo;

    //
    // Reserved space for exception list.
    //
    
    ULONG RvaOfException;
    ULONG SizeOfException;

    //
    // Reserved space for thread list.
    //
    
    ULONG RvaOfThreadList;
    ULONG SizeOfThreadList;
    ULONG RvaForCurThread;
    ULONG ThreadStructSize;

    //
    // Reserved space for module list.
    //
    
    ULONG RvaOfModuleList;
    ULONG SizeOfModuleList;
    ULONG RvaForCurModule;

    //
    // Reserved space for unloaded module list.
    //
    
    ULONG RvaOfUnloadedModuleList;
    ULONG SizeOfUnloadedModuleList;
    ULONG RvaForCurUnloadedModule;

    //
    // Reserved space for function table list.
    //
    
    ULONG RvaOfFunctionTableList;
    ULONG SizeOfFunctionTableList;

    //
    // Reserved space for memory descriptors.
    //
    
    ULONG RvaOfMemoryDescriptors;
    ULONG SizeOfMemoryDescriptors;
    ULONG RvaForCurMemoryDescriptor;

    //
    // Reserved space for actual memory data.
    //
    
    ULONG RvaOfMemoryData;
    ULONG SizeOfMemoryData;
    ULONG RvaForCurMemoryData;

    //
    // Reserved space for strings.
    //
    
    ULONG RvaOfStringPool;
    ULONG SizeOfStringPool;
    ULONG RvaForCurString;

    //
    // Reserved space for other data like contexts, debug info records,
    // etc.
    //
    
    ULONG RvaOfOther;
    ULONG SizeOfOther;
    ULONG RvaForCurOther;

    //
    // Reserved space for user streams.
    //
    
    ULONG RvaOfUserStreams;
    ULONG SizeOfUserStreams;

    //
    // Reserved space for handle data.
    //

    ULONG RvaOfHandleData;
    ULONG SizeOfHandleData;

} MINIDUMP_STREAM_INFO, *PMINIDUMP_STREAM_INFO;


typedef struct _EXCEPTION_INFO {
    DWORD ThreadId;
    EXCEPTION_POINTERS ExceptionPointers;
    BOOL FreeExceptionPointers;
} EXCEPTION_INFO, *PEXCEPTION_INFO;