333 lines
10 KiB
C
333 lines
10 KiB
C
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1992.
|
|
//
|
|
// File: PCH.cxx
|
|
//
|
|
// Contents: Pre-compiled header
|
|
//
|
|
// History: 21-Dec-92 BartoszM Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#define KDEXTMODE
|
|
|
|
//
|
|
// Following define prevents the inclusion of extra filter related fields
|
|
// in the FSRTL_COMMON_FCB_HEADER in fsrtl.h, whcih aren't in ntifs.h (used
|
|
// by FAT)
|
|
//
|
|
|
|
#define BUILDING_FSKDEXT
|
|
|
|
#ifndef __FATKDPCH_H
|
|
#define __FATKDPCH_H
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <ntos.h>
|
|
#include <zwapi.h>
|
|
|
|
// typedef int DCB;
|
|
#include <windef.h>
|
|
#include <windows.h>
|
|
|
|
#include <memory.h>
|
|
#include <fsrtl.h>
|
|
|
|
#undef CREATE_NEW
|
|
#undef OPEN_EXISTING
|
|
|
|
|
|
//#include <ntifs.h>
|
|
//#include <ntdddisk.h>
|
|
|
|
//#include "..\nodetype.h"
|
|
//#include "..\Fat.h"
|
|
//#include "..\Lfn.h"
|
|
//#include "..\FatStruc.h"
|
|
//#include "..\FatData.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
//#include <imagehlp.h>
|
|
|
|
// Stolen from ntrtl.h to override RECOMASSERT
|
|
#undef ASSERT
|
|
#undef ASSERTMSG
|
|
|
|
#if DBG
|
|
#define ASSERT( exp ) \
|
|
if (!(exp)) \
|
|
RtlAssert( #exp, __FILE__, __LINE__, NULL )
|
|
|
|
#define ASSERTMSG( msg, exp ) \
|
|
if (!(exp)) \
|
|
RtlAssert( #exp, __FILE__, __LINE__, msg )
|
|
|
|
#else
|
|
#define ASSERT( exp )
|
|
#define ASSERTMSG( msg, exp )
|
|
#endif // DBG
|
|
|
|
#define KDEXT_64BIT
|
|
|
|
#include <wdbgexts.h>
|
|
|
|
#define OFFSET(struct, elem) ((char *) &(struct->elem) - (char *) struct)
|
|
|
|
#define _DRIVER
|
|
|
|
#define KDBG_EXT
|
|
|
|
#include "wmistr.h"
|
|
|
|
#pragma hdrstop
|
|
|
|
|
|
typedef struct _STATE {
|
|
ULONG mask;
|
|
ULONG value;
|
|
CHAR *pszname;
|
|
} STATE;
|
|
|
|
VOID
|
|
PrintState(STATE *ps, ULONG state);
|
|
|
|
typedef VOID (*ELEMENT_DUMP_ROUTINE)(
|
|
IN ULONG64 RemoteAddress,
|
|
IN LONG Options
|
|
);
|
|
|
|
typedef ELEMENT_DUMP_ROUTINE *PELEMENT_DUMP_ROUTINE;
|
|
|
|
struct _NODE_TYPE_INFO_NEW;
|
|
typedef struct _NODE_TYPE_INFO_NEW *PNODE_TYPE_INFO_NEW;
|
|
|
|
typedef VOID (*STRUCT_DUMP_ROUTINE)(
|
|
IN ULONG64 Address,
|
|
IN LONG Options,
|
|
IN PNODE_TYPE_INFO_NEW InfoNode
|
|
);
|
|
|
|
typedef STRUCT_DUMP_ROUTINE *PSTRUCT_DUMP_ROUTINE;
|
|
|
|
#define DUMP_ROUTINE( X) \
|
|
VOID \
|
|
X( IN ULONG64 Address, \
|
|
IN LONG Options, \
|
|
IN PNODE_TYPE_INFO_NEW InfoNode)
|
|
|
|
//
|
|
// Node types, names, and associated dump routines.
|
|
//
|
|
|
|
typedef struct _NODE_TYPE_INFO_NEW {
|
|
USHORT TypeCode; // should be NODE_TYPE_CODE
|
|
char *Text;
|
|
char *TypeName;
|
|
STRUCT_DUMP_ROUTINE DumpRoutine;
|
|
// char *flagsfield; // TODO: add field to specify field recursion (dump params) as well?
|
|
// STATE *flagsinfo;
|
|
|
|
} NODE_TYPE_INFO_NEW;
|
|
|
|
#define NodeTypeName( InfoIndex) (NewNodeTypeCodes[ (InfoIndex)].Text)
|
|
#define NodeTypeTypeName( InfoIndex) (NewNodeTypeCodes[ (InfoIndex)].TypeName)
|
|
#define NodeTypeDumpFunction( InfoIndex) (NewNodeTypeCodes[ (InfoIndex)].DumpRoutine)
|
|
#define NodeTypeSize( InfoIndex) (NewNodeTypeCodes[ (InfoIndex)].Size)
|
|
|
|
|
|
//
|
|
// Define the global in memory structure tag information
|
|
//
|
|
|
|
extern NODE_TYPE_INFO_NEW NewNodeTypeCodes[];
|
|
|
|
#define TypeCodeInfoIndex( X) SearchTypeCodeIndex( X, NewNodeTypeCodes)
|
|
|
|
ULONG
|
|
SearchTypeCodeIndex (
|
|
IN USHORT TypeCode,
|
|
IN NODE_TYPE_INFO_NEW TypeCodes[]
|
|
);
|
|
|
|
|
|
#define AVERAGE(TOTAL,COUNT) ((COUNT) != 0 ? (TOTAL)/(COUNT) : 0)
|
|
|
|
//
|
|
// DUMP_WITH_OFFSET -- for dumping pointers contained in structures.
|
|
//
|
|
|
|
#define DUMP8_WITH_OFFSET(type, ptr, element, label) \
|
|
dprintf( "\n(%03x) %8hx %s ", \
|
|
FIELD_OFFSET(type, element), \
|
|
(USHORT)((UCHAR)ptr.element), \
|
|
label )
|
|
|
|
#define DUMP16_WITH_OFFSET(type, ptr, element, label) \
|
|
dprintf( "\n(%03x) %8hx %s ", \
|
|
FIELD_OFFSET(type, element), \
|
|
(USHORT)ptr.element, \
|
|
label )
|
|
|
|
#define DUMP_WITH_OFFSET(type, ptr, element, label) \
|
|
dprintf( "\n(%03x) %08x %s ", \
|
|
FIELD_OFFSET(type, element), \
|
|
ptr.element, \
|
|
label )
|
|
|
|
#define DUMP64_WITH_OFFSET(type, ptr, element, label) \
|
|
dprintf( "\n(%03x) %016I64x %s ", \
|
|
FIELD_OFFSET(type, element), \
|
|
ptr.element, \
|
|
label )
|
|
|
|
//
|
|
// DUMP_EMBW_OFFSET -- for dumping elements embedded in structures.
|
|
//
|
|
|
|
#define DUMP_EMBW_OFFSET(type, address, element, label) \
|
|
dprintf( "\n(%03x) %08x -> %s ", \
|
|
FIELD_OFFSET(type, element), \
|
|
((PUCHAR)address) + FIELD_OFFSET(type, element), \
|
|
label )
|
|
|
|
#define ReadM( B, A, L) { \
|
|
ULONG RmResult; \
|
|
if (!ReadMemory( (A), (B), (L), &RmResult)) { \
|
|
dprintf( "Unable to read %d bytes at 0x%I64x\n", (L), (A)); \
|
|
return; \
|
|
} \
|
|
}
|
|
|
|
#define RM( Addr, Obj, pObj, Type, Result ) { \
|
|
(pObj) = (Type)(Addr); \
|
|
if ( !ReadMemory( (Addr), &(Obj), sizeof( Obj ), &(Result)) ) { \
|
|
dprintf( "Unable to read %d bytes at %p\n", sizeof(Obj), (Addr)); \
|
|
return; \
|
|
} \
|
|
}
|
|
|
|
#define RMSS( Addr, Length, Obj, pObj, Type, Result ) { \
|
|
(pObj) = (Type)(Addr); \
|
|
if ( !ReadMemory( (Addr), &(Obj), (Length), &(Result)) ) { \
|
|
dprintf( "Unable to read %d bytes at %p\n", (Length), (Addr)); \
|
|
return; \
|
|
} \
|
|
}
|
|
|
|
|
|
#define ROE( X) { \
|
|
ULONG _E_; \
|
|
if (_E_ = (X)) { \
|
|
dprintf("Error %d (File %s Line %d)\n", _E_, __FILE__, __LINE__); \
|
|
return; \
|
|
} \
|
|
}
|
|
VOID
|
|
DumpStr(
|
|
IN ULONG FieldOffset,
|
|
IN ULONG64 StringAddress,
|
|
IN PUCHAR Label,
|
|
IN BOOLEAN CrFirst,
|
|
IN BOOLEAN Wide
|
|
);
|
|
|
|
//
|
|
// ....( TYPE, LOCAL_RECORD, REMOTE_ADDRESS_OF_RECORD, TYPE_FIELD_NAME, LABEL)
|
|
//
|
|
|
|
#define DUMP_UCST_OFFSET( type, ptr, address, resident, element, label) \
|
|
DumpWStr( FIELD_OFFSET(type, element), \
|
|
resident ? (((PUCHAR)address) + FIELD_OFFSET(type, element)) : *((PVOID*)&(ptr.element)), \
|
|
resident ? &(ptr.element) : NULL, \
|
|
label, TRUE \
|
|
)
|
|
|
|
#define DUMP_UCST_OFFSET_NO_CR( type, ptr, address, resident, element, label) \
|
|
DumpWStr( FIELD_OFFSET(type, element), \
|
|
resident ? (((PUCHAR)address) + FIELD_OFFSET(type, element)) : *((PVOID*)&(ptr.element)), \
|
|
resident ? &(ptr.element) : NULL, \
|
|
label, FALSE \
|
|
)
|
|
|
|
#define DUMP_STRN_OFFSET( type, ptr, address, resident, element, label) \
|
|
DumpStr( FIELD_OFFSET(type, element), \
|
|
resident ? (((PUCHAR)address) + FIELD_OFFSET(type, element)) : *((PVOID*)&(ptr.element)), \
|
|
resident ? &(ptr.element) : NULL, \
|
|
label, TRUE \
|
|
)
|
|
|
|
#define DUMP_STRN_OFFSET_NO_CR( type, ptr, address, resident, element, label) \
|
|
DumpStr( FIELD_OFFSET(type, element), \
|
|
resident ? (((PUCHAR)address) + FIELD_OFFSET(type, element)) : *((PVOID*)&(ptr.element)), \
|
|
resident ? &(ptr.element) : NULL, \
|
|
label, FALSE \
|
|
)
|
|
|
|
#define DUMP_RAW_TERM_STRN_OFFSET( type, ptr, address, element, label) \
|
|
dprintf( "\n(%03x) %08x -> %s = '%s'", \
|
|
FIELD_OFFSET(type, element), \
|
|
((PUCHAR)address) + FIELD_OFFSET(type, element), \
|
|
label , \
|
|
ptr.element)
|
|
|
|
VOID
|
|
DumpList(
|
|
IN ULONG64 RemoteListEntryAddress,
|
|
IN ELEMENT_DUMP_ROUTINE ProcessElementRoutine,
|
|
IN ULONG OffsetToContainerStart,
|
|
IN BOOLEAN ProcessThisEntry,
|
|
IN ULONG Options
|
|
);
|
|
|
|
VOID
|
|
ParseAndDump (
|
|
IN PCHAR args,
|
|
IN STRUCT_DUMP_ROUTINE DumpFunction,
|
|
ULONG Processor,
|
|
HANDLE hCurrentThread
|
|
);
|
|
|
|
ULONG
|
|
Dt( IN UCHAR *Type,
|
|
IN ULONG64 Addr,
|
|
IN ULONG Recur,
|
|
IN ULONG FieldInfoCount,
|
|
IN FIELD_INFO FieldInfo[]
|
|
);
|
|
|
|
//
|
|
// Definitions nicked from fsrtl/largemcb.c to enable dumping of FAT/UDFS
|
|
// MCB structures
|
|
//
|
|
|
|
typedef struct _MAPPING {
|
|
VBN NextVbn;
|
|
LBN Lbn;
|
|
} MAPPING;
|
|
typedef MAPPING *PMAPPING;
|
|
|
|
typedef struct _NONOPAQUE_MCB {
|
|
PFAST_MUTEX FastMutex;
|
|
ULONG MaximumPairCount;
|
|
ULONG PairCount;
|
|
POOL_TYPE PoolType;
|
|
PMAPPING Mapping;
|
|
} NONOPAQUE_MCB;
|
|
typedef NONOPAQUE_MCB *PNONOPAQUE_MCB;
|
|
|
|
//
|
|
// A macro to return the size, in bytes, of a retrieval mapping structure
|
|
//
|
|
|
|
#define SizeOfMapping(MCB) ((sizeof(MAPPING) * (MCB)->MaximumPairCount))
|
|
|
|
#endif
|
|
|