kdp.h

WinCE5.0部分核心源码

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// This source code is licensed under Microsoft Shared Source License
// Version 1.0 for Windows CE.
// For a copy of the license visit http://go.microsoft.com/fwlink/?LinkId=3223.
//
/*++


Module Name:

    kdp.h

Abstract:

    Private include file for the Kernel Debugger subcomponent

Environment:

    WinCE


--*/

// Override kernel's KData.
#define KData (*g_kdKernData.pKData)

#include <winerror.h>

#include "kernel.h"
#include "cpuid.h"
#include "kdstub.h"
#include "hdstub.h"
#include "string.h"
#include "kdpcpu.h"
#include "dbg.h"
#include "KitlProt.h"
#include "osaxs.h"
#include "OsAxsFlexi.h"
#include "kdApi2Structs.h"
#include "osaxsprotocol.h"


// status Constants for Packet waiting
// TODO: remove this since we use KITL
#define KDP_PACKET_RECEIVED    0x0000
#define KDP_PACKET_RESEND      0x0001
#define KDP_PACKET_UNEXPECTED  0x0002
#define KDP_PACKET_NONE        0xFFFF


#ifdef SHx
// for SR_DSP_ENABLED and SR_FPU_DISABLED
#include "shx.h"
#endif

// Useful thing to have.
#define lengthof(x)                     (sizeof(x) / sizeof(*x))


extern DBGPARAM dpCurSettings;

#define KDZONE_INIT             DEBUGZONE(0)    /* 0x0001 */
#define KDZONE_TRAP             DEBUGZONE(1)    /* 0x0002 */
#define KDZONE_API              DEBUGZONE(2)    /* 0x0004 */
#define KDZONE_DBG              DEBUGZONE(3)    /* 0x0008 */
#define KDZONE_SWBP             DEBUGZONE(4)    /* 0x0010 */
#define KDZONE_BREAK            DEBUGZONE(5)    /* 0x0020 */
#define KDZONE_CTRL             DEBUGZONE(6)    /* 0x0040 */
#define KDZONE_MOVE             DEBUGZONE(7)    /* 0x0080 */
#define KDZONE_KERNCTXADDR      DEBUGZONE(8)    /* 0x0100 */
#define KDZONE_PACKET           DEBUGZONE(9)    /* 0x0200 */
#define KDZONE_STACKW           DEBUGZONE(10)   /* 0x0400 */
#define KDZONE_CONCAN           DEBUGZONE(11)   /* 0x0800 */
#define KDZONE_VIRTMEM          DEBUGZONE(12)   /* 0x1000 */
#define KDZONE_HANDLEEX         DEBUGZONE(13)   /* 0x2000 */
#define KDZONE_ALERT            DEBUGZONE(15)   /* 0x8000 */

#define KDZONE_FLEXPTI          KDZONE_DBG


#define KDZONE_DEFAULT          (0x8000) // KDZONE_ALERT

#define _O_RDONLY   0x0000  /* open for reading only */
#define _O_WRONLY   0x0001  /* open for writing only */
#define _O_RDWR     0x0002  /* open for reading and writing */
#define _O_APPEND   0x0008  /* writes done at eof */

#define _O_CREAT    0x0100  /* create and open file */
#define _O_TRUNC    0x0200  /* open and truncate */
#define _O_EXCL     0x0400  /* open only if file doesn't already exist */

extern VOID NKOtherPrintfW(LPWSTR lpszFmt, ...);
#define DEBUGGERPRINTF NKOtherPrintfW
#include "debuggermsg.h"


// version of Kd.dll
#define CUR_KD_VER (500)


// ------------------------------- OS Access specifics --------------------------


// DmKdReadControlSpace Api commands

#define HANDLE_PROCESS_INFO_REQUEST         (0) 
#define HANDLE_GET_NEXT_OFFSET_REQUEST      (1)
#define HANDLE_STACKWALK_REQUEST            (2)
#define HANDLE_THREADSTACK_REQUEST          (3)
#define HANDLE_THREADSTACK_TERMINATE        (4)
#define HANDLE_RELOAD_MODULES_REQUEST       (5)
#define HANDLE_RELOAD_MODULES_INFO          (6)
#define HANDLE_PROCESS_ZONE_REQUEST         (7)
#define HANDLE_PROCESS_THREAD_INFO_REQ      (10)
#define HANDLE_GETCURPROCTHREAD             (11)
#define HANDLE_GET_EXCEPTION_REGISTRATION   (12)
#define HANDLE_MODULE_REFCOUNT_REQUEST      (13)
#define HANDLE_DESC_HANDLE_DATA             (14)
#define HANDLE_GET_HANDLE_DATA              (15)

#include <pshpack1.h>

// DmKdReadControlSpace Api structures

// structures for HANDLE_RELOAD_MODULES_INFO protocol
typedef struct tagReloadModInfoBase
{
    DWORD dwBasePtr;
    DWORD dwModuleSize;
} DBGKD_RELOAD_MOD_INFO_BASE;

typedef struct tagReloadModInfoV8
{
    DWORD dwRwDataStart;
    DWORD dwRwDataEnd;
} DBGKD_RELOAD_MOD_INFO_V8;

typedef struct tagReloadModInfoV14
{
    DWORD dwTimeStamp;
} DBGKD_RELOAD_MOD_INFO_V14;

/*
    For processes:
        hDll            = NULL
        dwInUse         = 1 << pid
        wFlags          = 0
        bTrustLevel     = proc.bTrustLevel

    For modules:
        hDll            = &mod
        dwInUse         = mod.inuse
        wFlags          = mod.wFlags
        bTrustLevel     = mod.bTrustLevel
*/

typedef struct tagReloadModInfoV15
{
    HMODULE hDll;
    DWORD dwInUse;
    WORD wFlags;
    BYTE bTrustLevel;
} DBGKD_RELOAD_MOD_INFO_V15;

#include <poppack.h>

#include <pshpack4.h>

//
// structures for HANDLE_MODULE_REFCOUNT_REQUEST protocol
//
// also in:
// /tools/ide/debugger/dmcpp/kdapi.cpp and
// /tools/ide/debugger/odcpu/odlib/datamgr.cpp
typedef struct tagGetModuleRefCountProc
{
    WORD wRefCount;

    // This is not a string. It is an array of characters. It probably won't
    // be null-terminated.
    WCHAR szProcName[15];
} DBGKD_GET_MODULE_REFCNT_PROC;

typedef struct tagGetModuleRefCount
{
    UINT32 nProcs;

    // Array with length = nProcs
    DBGKD_GET_MODULE_REFCNT_PROC pGMRCP[];
} DBGKD_GET_MODULE_REFCNT;

// structures and defines for HANDLE_DESC_HANDLE_DATA

// DBGKD_HANDLE_FIELD_DESC.nType
#define KD_FIELD_UINT                   0   // unsigned int
#define KD_FIELD_SINT                   1   // signed int
#define KD_FIELD_CHAR                   2   // ASCII character
#define KD_FIELD_WCHAR                  3   // Unicode character
#define KD_FIELD_CHAR_STR               4   // ASCII string pointer
#define KD_FIELD_WCHAR_STR              5   // Unicode string pointer
#define KD_FIELD_PTR                    6   // Pointer (any type)
#define KD_FIELD_BOOL                   7   // Boolean (true/false)
#define KD_FIELD_HANDLE                 8   // Handle (any type)
#define KD_FIELD_BITS                   9   // bit array (size <= 32)

// Some useful aliases
#define KD_FIELD_INT                    KD_FIELD_SINT
#define KD_FIELD_BOOLEAN                KD_FIELD_BOOL
#define KD_FIELD_WIDE_STR               KD_FIELD_WCHAR_STR

// DBGKD_HANDLE_FIELD_DESC.nFieldId
//
// Minimal implementation requires KD_HDATA_HANDLE, KD_HDATA_AKY, and
// KD_HDATA_TYPE
//
#define KD_HDATA_HANDLE                 0   // Handle value
#define KD_HDATA_AKY                    1   // Handle access key
#define KD_HDATA_REFCNT                 2   // Total refs to handle in system
#define KD_HDATA_TYPE                   3   // Handle type
#define KD_HDATA_NAME                   4   // Handle name, NULL if none
#define KD_HDATA_THREAD_SUSPEND         5   // Thread suspend count
#define KD_HDATA_THREAD_PID             6   // Thread's parent process
#define KD_HDATA_THREAD_BPRIO           7   // Thread's base priority
#define KD_HDATA_THREAD_CPRIO           8   // Thread's current priority
#define KD_HDATA_THREAD_KTIME           9   // Thread's time spent in kmode
#define KD_HDATA_THREAD_UTIME           10  // Thread's time spent in user mode
#define KD_HDATA_PROC_PID               11  // Process's PID
#define KD_HDATA_PROC_TRUST             12  // Process's trust level
#define KD_HDATA_PROC_VMBASE            13  // ??
#define KD_HDATA_PROC_BASEPTR           14  // ??
#define KD_HDATA_PROC_CMDLINE           15  // Process's commandline
#define KD_HDATA_EVENT_STATE            16  // Event's current state
#define KD_HDATA_EVENT_RESET            17  // Event's manual reset property
#define KD_HDATA_MUTEX_LOCKCNT          18  // Mutex's lock count
#define KD_HDATA_MUTEX_OWNER            19  // Mutex's current owner
#define KD_HDATA_SEM_COUNT              20  // Semaphore's lock counter
#define KD_HDATA_SEM_MAXCOUNT           21  // Semaphore's maximum locks allowed
#define KD_HDATA_FILE_NAME              22  // File's name

typedef struct
{
    UINT16 nType;

    // This is a unique ID that maps in PB to the name of the field. There is
    // a table that correlates these to strings.
    UINT16 nFieldId;
} DBGKD_HANDLE_FIELD_DESC;

typedef union
{
    struct
    {
        // These are both bit arrays that filter out handle data. Note that
        // MAX_PROCESSES == 32 and NUM_SYSTEM_SETS == 32, so they're both
        // 32-bit values. If you don't want to filter, use -1 (all bits set)
        UINT32 nPIDFilter;
        UINT32 nAPIFilter;
    } in;

    struct
    {
        UINT32 cFields;

        // The length of the array goes up to the MTU for KITL. It holds the
        // common subset of properties shared by all the handles requested.
        DBGKD_HANDLE_FIELD_DESC pFieldDesc[];
    } out;
} DBGKD_HANDLE_DESC_DATA;

//
// structures and defines for HANDLE_GET_HANDLE_DATA
//

typedef struct
{
    // This is a unique ID that maps in PB to the name of the field. There is
    // a table that correlates these to string IDs.
    UINT16 nFieldId;

    // Determine whether field is valid. This happens sometimes, e.g. when a
    // thread is still referenced but the thread itself has died.
    BOOL fValid : 1;

    // The data
    UINT32 nData;
} DBGKD_HANDLE_FIELD_DATA;

typedef union
{
    struct
    {
        // These are both bit arrays that filter out handle data. Note that
        // MAX_PROCESSES == 32 and NUM_SYSTEM_SETS == 32, so they're both
        // 32-bit values. If you don't want to filter, use -1 (all bits set)
        UINT32 nPIDFilter;
        UINT32 nAPIFilter;

        // Index for continuation. Starts at NULL, should be copied from the
        // out part for each iteration.
        HANDLE hStart;
    } in;

    struct
    {
        // NULL if finished, otherwise this packet should be sent again with
        // out.hContinue copied into in.hStart
        HANDLE hContinue;

        // The length of pFields is expanded to fit the MTU. The order of the
        // fields follows the order of the handles in the kernel's handle list.
        // Fields belonging to the same handle will be clustered together in
        // identical order to the DESC_DATA query. If there is not sufficient
        // space to store complete data for a handle, it will not be stored.
        //
        // Note that cFields = cFieldsPerHandle * cHandles
        UINT32 cFields;
        DBGKD_HANDLE_FIELD_DATA pFields[];
    } out;
} DBGKD_HANDLE_GET_DATA;

typedef DBGKD_HANDLE_FIELD_DESC *PDBGKD_HANDLE_FIELD_DESC;
typedef const DBGKD_HANDLE_FIELD_DESC *PCDBGKD_HANDLE_FIELD_DESC;
typedef DBGKD_HANDLE_DESC_DATA *PDBGKD_HANDLE_DESC_DATA;
typedef const DBGKD_HANDLE_DESC_DATA *PCDBGKD_HANDLE_DESC_DATA;
typedef DBGKD_HANDLE_FIELD_DATA *PDBGKD_HANDLE_FIELD_DATA;
typedef const DBGKD_HANDLE_FIELD_DATA *PCDBGKD_HANDLE_FIELD_DATA;
typedef DBGKD_HANDLE_GET_DATA *PDBGKD_HANDLE_GET_DATA;
typedef const DBGKD_HANDLE_GET_DATA *PCDBGKD_HANDLE_GET_DATA;
#include <poppack.h>

//
// WriteControlSpace Api commands
//

#define HANDLE_PROCESS_SWITCH_REQUEST  0
#define HANDLE_THREAD_SWITCH_REQUEST   1
//#define HANDLE_STACKWALK_REQUEST       2
#define HANDLE_DELETE_HANDLE           3



// ------------------------------- END of OS Access specifics --------------------------



extern BOOL g_fForceReload;
extern BOOL g_fKdbgRegistered;


// KdStub State Notification Flags
extern BOOL g_fDbgKdStateMemoryChanged; // Set this signal to TRUE to notify the host that target memory has changed and host-side must refresh


#define PAGE_ALIGN(Va)  ((ULONG)(Va) & ~(PAGE_SIZE - 1))
#define BYTE_OFFSET(Va) ((ULONG)(Va) & (PAGE_SIZE - 1))


//
// Ke stub routines and definitions
//


#if defined(x86)

//
// There is no need to sweep the i386 cache because it is unified (no
// distinction is made between instruction and data entries).
//

#define KeSweepCurrentIcache()

#elif defined(SHx)

//
// There is no need to sweep the SH3 cache because it is unified (no
// distinction is made between instruction and data entries).
//

extern void FlushCache (void);

#define KeSweepCurrentIcache() FlushCache()

#else

extern void FlushICache (void);

#define KeSweepCurrentIcache() FlushICache()

#endif


#define VER_PRODUCTBUILD 0


#define STATUS_SYSTEM_BREAK             ((NTSTATUS)0x80000114L)


//
// TRAPA / BREAK immediate field value for breakpoints
//

#define DEBUGBREAK_STOP_BREAKPOINT         1

#define DEBUG_PROCESS_SWITCH_BREAKPOINT       2
#define DEBUG_THREAD_SWITCH_BREAKPOINT        3
#define DEBUG_BREAK_IN                        4
#define DEBUG_REGISTER_BREAKPOINT             5


#if defined (ARM)

// returns TRUE if Concan Coprocessors found and active,
BOOL DetectConcanCoprocessors ();

void GetConcanRegisters (PCONCAN_REGS);
void SetConcanRegisters (PCONCAN_REGS);

#endif

typedef ULONG KSPIN_LOCK;

//
// Miscellaneous
//

#if DBG