gdb_input.c File Reference

#include "kdgdb.h"

Include dependency graph for gdb_input.c:

Go to the source code of this file.

Macros
#define	hex_to_pid   hex_to_tid

Functions
static KDSTATUS	LOOP_IF_SUCCESS (int x)
static UINT_PTR	hex_to_tid (char *buffer)
static ULONG64	hex_to_address (char *buffer)
static KDSTATUS	handle_gdb_set_thread (void)
static KDSTATUS	handle_gdb_thread_alive (void)
static KDSTATUS	handle_gdb_query (void)
static BOOLEAN	ReadMemorySendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
static KDSTATUS	handle_gdb_read_mem (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static BOOLEAN	WriteMemorySendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
static KDSTATUS	handle_gdb_write_mem (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static BOOLEAN	WriteBreakPointSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
static KDSTATUS	handle_gdb_insert_breakpoint (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static BOOLEAN	RestoreBreakPointSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
static KDSTATUS	handle_gdb_remove_breakpoint (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static KDSTATUS	handle_gdb_c (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static KDSTATUS	handle_gdb_s (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static KDSTATUS	handle_gdb_v (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
KDSTATUS	gdb_receive_and_interpret_packet (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

Variables
static ULONG_PTR	gdb_run_tid
struct {
ULONG_PTR   Address
ULONG   Handle
}	BreakPointHandles [32]
UINT_PTR	gdb_dbg_pid
UINT_PTR	gdb_dbg_tid

Macro Definition Documentation

hex_to_pid

#define hex_to_pid   hex_to_tid

Definition at line 47 of file gdb_input.c.

Function Documentation

gdb_receive_and_interpret_packet()

KDSTATUS gdb_receive_and_interpret_packet	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 994 of file gdb_input.c.

{
    KDSTATUS Status;
 
    do
    {
        KDDBGPRINT("KDGBD: Receiving packet.\n");
        Status = gdb_receive_packet(KdContext);
        KDDBGPRINT("KDGBD: Packet \"%s\" received with status %u\n", gdb_input, Status);
 
        if (Status != KdPacketReceived)
            return Status;
 
        Status = (KDSTATUS)-1;
 
        switch (gdb_input[0])
        {
        case '?':
            /* Send the Status */
            Status = LOOP_IF_SUCCESS(gdb_send_exception());
            break;
        case '!':
            Status = LOOP_IF_SUCCESS(send_gdb_packet("OK"));
            break;
        case 'c':
        case 'C':
            Status = handle_gdb_c(State, MessageData, MessageLength, KdContext);
            break;
        case 'g':
            Status = LOOP_IF_SUCCESS(gdb_send_registers());
            break;
        case 'H':
            Status = LOOP_IF_SUCCESS(handle_gdb_set_thread());
            break;
        case 'm':
            Status = handle_gdb_read_mem(State, MessageData, MessageLength, KdContext);
            break;
        case 'p':
            Status = LOOP_IF_SUCCESS(gdb_send_register());
            break;
        case 'q':
            Status = LOOP_IF_SUCCESS(handle_gdb_query());
            break;
        case 's':
            Status = handle_gdb_s(State, MessageData, MessageLength, KdContext);
            break;
        case 'T':
            Status = LOOP_IF_SUCCESS(handle_gdb_thread_alive());
            break;
        case 'v':
            Status = handle_gdb_v(State, MessageData, MessageLength, KdContext);
            break;
        case 'X':
            Status = handle_gdb_write_mem(State, MessageData, MessageLength, KdContext);
            break;
        case 'z':
            Status = handle_gdb_remove_breakpoint(State, MessageData, MessageLength, KdContext);
            break;
        case 'Z':
            Status = handle_gdb_insert_breakpoint(State, MessageData, MessageLength, KdContext);
            break;
        default:
            /* We don't know how to handle this request. */
            KDDBGPRINT("Unsupported GDB command: %s.\n", gdb_input);
            Status = LOOP_IF_SUCCESS(send_gdb_packet(""));
        }
    } while (Status == (KDSTATUS)-1);
 
    return Status;
}

Referenced by KdReceivePacket().

handle_gdb_c()

static KDSTATUS handle_gdb_c ( _Out_ DBGKD_MANIPULATE_STATE64 *  State, _Out_ PSTRING  MessageData, _Out_ PULONG  MessageLength, _Inout_ PKD_CONTEXT  KdContext  )

static

Definition at line 897 of file gdb_input.c.

{
    KDSTATUS Status;
 
    /* Tell GDB everything is fine, we will handle it */
    Status = send_gdb_packet("OK");
    if (Status != KdPacketReceived)
        return Status;
 
 
    if (CurrentStateChange.NewState == DbgKdExceptionStateChange)
    {
        DBGKM_EXCEPTION64* Exception = &CurrentStateChange.u.Exception;
        ULONG_PTR ProgramCounter = KdpGetContextPc(&CurrentContext);
 
        /* See if we should update the program counter */
        if ((Exception->ExceptionRecord.ExceptionCode == STATUS_BREAKPOINT)
            && ((*(KD_BREAKPOINT_TYPE*)ProgramCounter) == KD_BREAKPOINT_VALUE))
        {
            /* We must get past the breakpoint instruction */
            KdpSetContextPc(&CurrentContext, ProgramCounter + KD_BREAKPOINT_SIZE);
 
            SetContextManipulateHandler(State, MessageData, MessageLength, KdContext);
            KdpManipulateStateHandler = ContinueManipulateStateHandler;
            return KdPacketReceived;
        }
#if defined(_M_IX86) || defined(_M_AMD64)
        if ((Exception->ExceptionRecord.ExceptionCode == STATUS_ASSERTION_FAILURE)
            && ((*(KD_BREAKPOINT_TYPE*)ProgramCounter) == 0xCD)
            && (*((KD_BREAKPOINT_TYPE*)ProgramCounter + 1) == 0x2C))
        {
            /* INT 2C (a.k.a. runtime check failure) */
            KdpSetContextPc(&CurrentContext, ProgramCounter + 2);
 
            SetContextManipulateHandler(State, MessageData, MessageLength, KdContext);
            KdpManipulateStateHandler = ContinueManipulateStateHandler;
            return KdPacketReceived;
        }
#endif
    }
 
    return ContinueManipulateStateHandler(State, MessageData, MessageLength, KdContext);
}

Referenced by gdb_receive_and_interpret_packet(), and handle_gdb_v().

handle_gdb_insert_breakpoint()

static KDSTATUS handle_gdb_insert_breakpoint ( _Out_ DBGKD_MANIPULATE_STATE64 *  State, _Out_ PSTRING  MessageData, _Out_ PULONG  MessageLength, _Inout_ PKD_CONTEXT  KdContext  )

static

Definition at line 750 of file gdb_input.c.

{
    State->ReturnStatus = STATUS_SUCCESS; /* ? */
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    if (MessageData)
        MessageData->Length = 0;
    *MessageLength = 0;
 
    switch (gdb_input[1])
    {
        case '0':
        {
            ULONG_PTR Address = hex_to_address(&gdb_input[3]);
            ULONG i;
            BOOLEAN HasFreeSlot = FALSE;
 
            KDDBGPRINT("Inserting breakpoint at %p.\n", (void*)Address);
 
            for (i = 0; i < (sizeof(BreakPointHandles) / sizeof(BreakPointHandles[0])); i++)
            {
                if (BreakPointHandles[i].Address == 0)
                    HasFreeSlot = TRUE;
            }
 
            if (!HasFreeSlot)
            {
                /* We don't have a way to keep track of this break point. Fail. */
                KDDBGPRINT("No breakpoint slot available!\n");
                return LOOP_IF_SUCCESS(send_gdb_packet("E01"));
            }
 
            State->ApiNumber = DbgKdWriteBreakPointApi;
            State->u.WriteBreakPoint.BreakPointAddress = Address;
            /* FIXME : ignoring all other Z0 arguments */
 
            /* KD will reply with KdSendPacket. Catch it */
            KdpSendPacketHandler = WriteBreakPointSendHandler;
            return KdPacketReceived;
        }
    }
 
    KDDBGPRINT("Unhandled 'Z' packet: %s\n", gdb_input);
    return LOOP_IF_SUCCESS(send_gdb_packet("E01"));
}

Referenced by gdb_receive_and_interpret_packet().

handle_gdb_query()

static KDSTATUS handle_gdb_query ( void  )

static

Definition at line 156 of file gdb_input.c.

{
    if (strncmp(gdb_input, "qSupported:", 11) == 0)
    {
#if MONOPROCESS
        return send_gdb_packet("PacketSize=1000;qXfer:libraries:read+;");
#else
        return send_gdb_packet("PacketSize=1000;multiprocess+;qXfer:libraries:read+;");
#endif
    }
 
    if (strncmp(gdb_input, "qAttached", 9) == 0)
    {
#if MONOPROCESS
        return send_gdb_packet("1");
#else
        UINT_PTR queried_pid = hex_to_pid(&gdb_input[10]);
        /* Let's say we created system process */
        if (gdb_pid_to_handle(queried_pid) == NULL)
            return send_gdb_packet("0");
        else
            return send_gdb_packet("1");
#endif
    }
 
    if (strncmp(gdb_input, "qRcmd,", 6) == 0)
    {
        return send_gdb_packet("OK");
    }
 
    if (strcmp(gdb_input, "qC") == 0)
    {
        char gdb_out[64];
#if MONOPROCESS
        sprintf(gdb_out, "QC:%"PRIxPTR";",
            handle_to_gdb_tid(PsGetThreadId((PETHREAD)(ULONG_PTR)CurrentStateChange.Thread)));
#else
        sprintf(gdb_out, "QC:p%"PRIxPTR".%"PRIxPTR";",
            handle_to_gdb_pid(PsGetThreadProcessId((PETHREAD)(ULONG_PTR)CurrentStateChange.Thread)),
            handle_to_gdb_tid(PsGetThreadId((PETHREAD)(ULONG_PTR)CurrentStateChange.Thread)));
#endif
        return send_gdb_packet(gdb_out);
    }
 
    if (strncmp(gdb_input, "qfThreadInfo", 12) == 0)
    {
        PEPROCESS Process;
        char gdb_out[40];
        LIST_ENTRY* CurrentProcessEntry;
 
        CurrentProcessEntry = ProcessListHead->Flink;
        if (CurrentProcessEntry == NULL) /* Ps is not initialized */
        {
#if MONOPROCESS
            return send_gdb_packet("m1");
#else
            return send_gdb_packet("mp1.1");
#endif
        }
 
        /* We will push threads as we find them */
        start_gdb_packet();
 
        /* Start with the system thread */
#if MONOPROCESS
        send_gdb_partial_packet("m1");
#else
        send_gdb_partial_packet("mp1.1");
#endif
 
        /* List all the processes */
        for ( ;
            CurrentProcessEntry != ProcessListHead;
            CurrentProcessEntry = CurrentProcessEntry->Flink)
        {
            LIST_ENTRY* CurrentThreadEntry;
 
            Process = CONTAINING_RECORD(CurrentProcessEntry, EPROCESS, ActiveProcessLinks);
 
            /* List threads from this process */
            for ( CurrentThreadEntry = Process->ThreadListHead.Flink;
                 CurrentThreadEntry != &Process->ThreadListHead;
                 CurrentThreadEntry = CurrentThreadEntry->Flink)
            {
                PETHREAD Thread = CONTAINING_RECORD(CurrentThreadEntry, ETHREAD, ThreadListEntry);
 
#if MONOPROCESS
                _snprintf(gdb_out, 40, ",%p", handle_to_gdb_tid(Thread->Cid.UniqueThread));
#else
                _snprintf(gdb_out, 40, ",p%p.%p",
                    handle_to_gdb_pid(Process->UniqueProcessId),
                    handle_to_gdb_tid(Thread->Cid.UniqueThread));
#endif
                send_gdb_partial_packet(gdb_out);
            }
        }
 
        return finish_gdb_packet();
    }
 
    if (strncmp(gdb_input, "qsThreadInfo", 12) == 0)
    {
        /* We sent the whole thread list on first qfThreadInfo call */
        return send_gdb_packet("l");
    }
 
    if (strncmp(gdb_input, "qGetTIBAddr:", 12) == 0)
    {
        ULONG_PTR Pid, Tid;
        PETHREAD Thread;
 
#if MONOPROCESS
        Pid = 0;
        Tid = hex_to_tid(&gdb_input[12]);
 
        KDDBGPRINT(" %p.\n", Tid);
 
        Thread = find_thread(Pid, Tid);
#else
        Pid = hex_to_pid(&gdb_input[13]);
        Tid = hex_to_tid(strstr(&gdb_input[13], ".") + 1);
 
        /* We cannot use PsLookupProcessThreadByCid as we could be running at any IRQL.
         * So loop. */
        KDDBGPRINT(" p%p.%p.\n", Pid, Tid);
        Thread = find_thread(Pid, Tid);
#endif
        return send_gdb_memory(&Thread->Tcb.Teb, sizeof(Thread->Tcb.Teb));
    }
 
    if (strncmp(gdb_input, "qThreadExtraInfo,", 17) == 0)
    {
        ULONG_PTR Pid, Tid;
        PETHREAD Thread;
        PEPROCESS Process;
        char out_string[64];
        STRING String = {0, 64, out_string};
 
        KDDBGPRINT("Giving extra info for");
 
#if MONOPROCESS
        Pid = 0;
        Tid = hex_to_tid(&gdb_input[17]);
 
        KDDBGPRINT(" %p.\n", Tid);
 
        Thread = find_thread(Pid, Tid);
        Process = CONTAINING_RECORD(Thread->Tcb.Process, EPROCESS, Pcb);
#else
        Pid = hex_to_pid(&gdb_input[18]);
        Tid = hex_to_tid(strstr(&gdb_input[18], ".") + 1);
 
        /* We cannot use PsLookupProcessThreadByCid as we could be running at any IRQL.
         * So loop. */
        KDDBGPRINT(" p%p.%p.\n", Pid, Tid);
 
        Process = find_process(Pid);
        Thread = find_thread(Pid, Tid);
#endif
 
        if (PsGetThreadProcessId(Thread) == 0)
        {
            String.Length = sprintf(out_string, "SYSTEM");
        }
        else
        {
            String.Length = sprintf(out_string, "%.*s", 16, Process->ImageFileName);
        }
 
        return gdb_send_debug_io(&String, FALSE);
    }
 
    if (strcmp(gdb_input, "qTStatus") == 0)
    {
        /* No tracepoint support */
        return send_gdb_packet("T0");
    }
 
    if (strcmp(gdb_input, "qSymbol::") == 0)
    {
        /* No need */
        return send_gdb_packet("OK");
    }
 
    if (strncmp(gdb_input, "qXfer:libraries:read::", 22) == 0)
    {
        static LIST_ENTRY* CurrentEntry = NULL;
        char str_helper[256];
        char name_helper[64];
        ULONG_PTR Offset = hex_to_address(&gdb_input[22]);
        ULONG_PTR ToSend = hex_to_address(strstr(&gdb_input[22], ",") + 1);
        ULONG Sent = 0;
        static BOOLEAN allDone = FALSE;
 
        KDDBGPRINT("KDGDB: qXfer:libraries:read !\n");
 
        /* Start the packet */
        start_gdb_packet();
 
        if (allDone)
        {
            send_gdb_partial_packet("l");
            allDone = FALSE;
            return finish_gdb_packet();
        }
 
        send_gdb_partial_packet("m");
        Sent++;
 
        /* Are we starting ? */
        if (Offset == 0)
        {
            Sent += send_gdb_partial_binary("<?xml version=\"1.0\"?>", 21);
            Sent += send_gdb_partial_binary("<library-list>", 14);
 
            CurrentEntry = ModuleListHead->Flink;
 
            if (!CurrentEntry)
            {
                /* Ps is not initialized. Send end of XML data or mark that we are finished. */
                Sent += send_gdb_partial_binary("</library-list>", 15);
                allDone = TRUE;
                return finish_gdb_packet();
            }
        }
 
        for ( ;
            CurrentEntry != ModuleListHead;
            CurrentEntry = CurrentEntry->Flink)
        {
            PLDR_DATA_TABLE_ENTRY TableEntry = CONTAINING_RECORD(CurrentEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
            PVOID DllBase = (PVOID)((ULONG_PTR)TableEntry->DllBase + 0x1000);
            LONG mem_length;
            USHORT i;
 
            /* Convert names to lower case. Yes this _is_ ugly */
            for (i = 0; i < (TableEntry->BaseDllName.Length / sizeof(WCHAR)); i++)
            {
                name_helper[i] = (char)TableEntry->BaseDllName.Buffer[i];
                if (name_helper[i] >= 'A' && name_helper[i] <= 'Z')
                    name_helper[i] += 'a' - 'A';
            }
            name_helper[i] = 0;
 
            /* GDB doesn't load the file if you don't prefix it with a drive letter... */
            mem_length = _snprintf(str_helper, 256, "<library name=\"C:\\%s\"><segment address=\"0x%p\"/></library>", &name_helper, DllBase);
 
            /* DLL name must be too long. */
            if (mem_length < 0)
            {
                KDDBGPRINT("Failed to report %wZ\n", &TableEntry->BaseDllName);
                continue;
            }
 
            if ((Sent + mem_length) > ToSend)
            {
                /* We're done for this pass */
                return finish_gdb_packet();
            }
 
            Sent += send_gdb_partial_binary(str_helper, mem_length);
        }
 
        if ((ToSend - Sent) > 15)
        {
            Sent += send_gdb_partial_binary("</library-list>", 15);
            allDone = TRUE;
        }
 
        return finish_gdb_packet();
    }
 
    KDDBGPRINT("KDGDB: Unknown query: %s\n", gdb_input);
    return send_gdb_packet("");
}

Referenced by gdb_receive_and_interpret_packet().

handle_gdb_read_mem()

static KDSTATUS handle_gdb_read_mem ( _Out_ DBGKD_MANIPULATE_STATE64 *  State, _Out_ PSTRING  MessageData, _Out_ PULONG  MessageLength, _Inout_ PKD_CONTEXT  KdContext  )

static

Definition at line 503 of file gdb_input.c.

{
    State->ApiNumber = DbgKdReadVirtualMemoryApi;
    State->ReturnStatus = STATUS_SUCCESS; /* ? */
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    if (MessageData)
        MessageData->Length = 0;
    *MessageLength = 0;
 
    /* Set the TLB according to the process being read. Pid 0 means any process. */
#if MONOPROCESS
    if ((gdb_dbg_tid != 0) && gdb_tid_to_handle(gdb_dbg_tid) != PsGetCurrentThreadId())
    {
        PETHREAD AttachedThread = find_thread(0, gdb_dbg_tid);
        PKPROCESS AttachedProcess;
        if (AttachedThread == NULL)
        {
            KDDBGPRINT("The current GDB debug thread is invalid!");
            return LOOP_IF_SUCCESS(send_gdb_packet("E03"));
        }
 
        AttachedProcess = AttachedThread->Tcb.Process;
        if (AttachedProcess == NULL)
        {
            KDDBGPRINT("The current GDB debug thread is invalid!");
            return LOOP_IF_SUCCESS(send_gdb_packet("E03"));
        }
        __writecr3(AttachedProcess->DirectoryTableBase[0]);
    }
#else
    if ((gdb_dbg_pid != 0) && gdb_pid_to_handle(gdb_dbg_pid) != PsGetCurrentProcessId())
    {
        PEPROCESS AttachedProcess = find_process(gdb_dbg_pid);
        if (AttachedProcess == NULL)
        {
            KDDBGPRINT("The current GDB debug thread is invalid!");
            return LOOP_IF_SUCCESS(send_gdb_packet("E03"));
        }
        /* Only do this if Ps is initialized */
        if (ProcessListHead->Flink)
            __writecr3(AttachedProcess->Pcb.DirectoryTableBase[0]);
    }
#endif
 
    State->u.ReadMemory.TargetBaseAddress = hex_to_address(&gdb_input[1]);
    State->u.ReadMemory.TransferCount = hex_to_address(strstr(&gdb_input[1], ",") + 1);
 
    /* KD will reply with KdSendPacket. Catch it */
    KdpSendPacketHandler = ReadMemorySendHandler;
    return KdPacketReceived;
}

Referenced by gdb_receive_and_interpret_packet().

handle_gdb_remove_breakpoint()

static KDSTATUS handle_gdb_remove_breakpoint ( _Out_ DBGKD_MANIPULATE_STATE64 *  State, _Out_ PSTRING  MessageData, _Out_ PULONG  MessageLength, _Inout_ PKD_CONTEXT  KdContext  )

static

Definition at line 844 of file gdb_input.c.

{
    State->ReturnStatus = STATUS_SUCCESS; /* ? */
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    if (MessageData)
        MessageData->Length = 0;
    *MessageLength = 0;
 
    switch (gdb_input[1])
    {
        case '0':
        {
            ULONG_PTR Address = hex_to_address(&gdb_input[3]);
            ULONG i, Handle = 0;
 
            KDDBGPRINT("Removing breakpoint on %p.\n", (void*)Address);
 
            for (i = 0; i < (sizeof(BreakPointHandles) / sizeof(BreakPointHandles[0])); i++)
            {
                if (BreakPointHandles[i].Address == Address)
                {
                    Handle = BreakPointHandles[i].Handle;
                    break;
                }
            }
 
            if (Handle == 0)
            {
                KDDBGPRINT("Received %s, but breakpoint was never inserted ?!\n", gdb_input);
                return LOOP_IF_SUCCESS(send_gdb_packet("E01"));
            }
 
            State->ApiNumber = DbgKdRestoreBreakPointApi;
            State->u.RestoreBreakPoint.BreakPointHandle = Handle;
            /* FIXME : ignoring all other z0 arguments */
 
            /* KD will reply with KdSendPacket. Catch it */
            KdpSendPacketHandler = RestoreBreakPointSendHandler;
            return KdPacketReceived;
        }
    }
 
    KDDBGPRINT("Unhandled 'Z' packet: %s\n", gdb_input);
    return LOOP_IF_SUCCESS(send_gdb_packet("E01"));
}

Referenced by gdb_receive_and_interpret_packet().

handle_gdb_s()

static KDSTATUS handle_gdb_s ( _Out_ DBGKD_MANIPULATE_STATE64 *  State, _Out_ PSTRING  MessageData, _Out_ PULONG  MessageLength, _Inout_ PKD_CONTEXT  KdContext  )

static

Definition at line 947 of file gdb_input.c.

{
    KDDBGPRINT("Single stepping.\n");
    /* Set CPU single step mode and continue */
    KdpSetSingleStep(&CurrentContext);
    SetContextManipulateHandler(State, MessageData, MessageLength, KdContext);
    KdpManipulateStateHandler = ContinueManipulateStateHandler;
    return KdPacketReceived;
}

Referenced by gdb_receive_and_interpret_packet(), and handle_gdb_v().

handle_gdb_set_thread()

static KDSTATUS handle_gdb_set_thread ( void  )

static

Definition at line 69 of file gdb_input.c.

{
    KDSTATUS Status;
 
    switch (gdb_input[1])
    {
    case 'c':
        if (strcmp(&gdb_input[2], "-1") == 0)
            gdb_run_tid = (ULONG_PTR)-1;
        else
            gdb_run_tid = hex_to_tid(&gdb_input[2]);
        Status = send_gdb_packet("OK");
        break;
    case 'g':
        KDDBGPRINT("Setting debug thread: %s.\n", gdb_input);
#if MONOPROCESS
        gdb_dbg_pid = 0;
        if (strncmp(&gdb_input[2], "-1", 2) == 0)
        {
            gdb_dbg_tid = (UINT_PTR)-1;
        }
        else
        {
            gdb_dbg_tid = hex_to_tid(&gdb_input[2]);
        }
#else
        if (strncmp(&gdb_input[2], "p-1", 3) == 0)
        {
            gdb_dbg_pid = (UINT_PTR)-1;
            gdb_dbg_tid = (UINT_PTR)-1;
        }
        else
        {
            char* ptr = strstr(gdb_input, ".") + 1;
            gdb_dbg_pid = hex_to_pid(&gdb_input[3]);
            if (strncmp(ptr, "-1", 2) == 0)
                gdb_dbg_tid = (UINT_PTR)-1;
            else
                gdb_dbg_tid = hex_to_tid(ptr);
        }
#endif
        Status = send_gdb_packet("OK");
        break;
    default:
        KDDBGPRINT("KDGBD: Unknown 'H' command: %s\n", gdb_input);
        Status = send_gdb_packet("");
    }
 
    return Status;
}

Referenced by gdb_receive_and_interpret_packet().

handle_gdb_thread_alive()

static KDSTATUS handle_gdb_thread_alive ( void  )

static

Definition at line 122 of file gdb_input.c.

{
    ULONG_PTR Pid, Tid;
    PETHREAD Thread;
    KDSTATUS Status;
 
#if MONOPROCESS
    Pid = 0;
    Tid = hex_to_tid(&gdb_input[1]);
 
    KDDBGPRINT("Checking if %p is alive.\n", Tid);
 
#else
    Pid = hex_to_pid(&gdb_input[2]);
    Tid = hex_to_tid(strstr(gdb_input, ".") + 1);
 
    /* We cannot use PsLookupProcessThreadByCid as we could be running at any IRQL.
     * So loop. */
    KDDBGPRINT("Checking if p%p.%p is alive.\n", Pid, Tid);
#endif
 
    Thread = find_thread(Pid, Tid);
 
    if (Thread != NULL)
        Status = send_gdb_packet("OK");
    else
        Status = send_gdb_packet("E03");
 
    return Status;
}

Referenced by gdb_receive_and_interpret_packet().

handle_gdb_v()

static KDSTATUS handle_gdb_v ( _Out_ DBGKD_MANIPULATE_STATE64 *  State, _Out_ PSTRING  MessageData, _Out_ PULONG  MessageLength, _Inout_ PKD_CONTEXT  KdContext  )

static

Definition at line 963 of file gdb_input.c.

{
    if (strncmp(gdb_input, "vCont", 5) == 0)
    {
        if (gdb_input[5] == '?')
        {
            /* Report what we support */
            return LOOP_IF_SUCCESS(send_gdb_packet("vCont;c;s"));
        }
 
        if (strncmp(gdb_input, "vCont;c", 7) == 0)
        {
            return handle_gdb_c(State, MessageData, MessageLength, KdContext);
        }
 
        if (strncmp(gdb_input, "vCont;s", 7) == 0)
        {
 
            return handle_gdb_s(State, MessageData, MessageLength, KdContext);
        }
    }
 
    KDDBGPRINT("Unhandled 'v' packet: %s\n", gdb_input);
    return LOOP_IF_SUCCESS(send_gdb_packet(""));
}

Referenced by gdb_receive_and_interpret_packet().

handle_gdb_write_mem()

static KDSTATUS handle_gdb_write_mem ( _Out_ DBGKD_MANIPULATE_STATE64 *  State, _Out_ PSTRING  MessageData, _Out_ PULONG  MessageLength, _Inout_ PKD_CONTEXT  KdContext  )

static

Definition at line 606 of file gdb_input.c.

{
    /* Maximal input buffer is 0x1000. Each byte is encoded on two bytes by GDB */
    static UCHAR OutBuffer[0x800];
    ULONG BufferLength;
    char* blob_ptr;
    UCHAR* OutPtr;
 
    State->ApiNumber = DbgKdWriteVirtualMemoryApi;
    State->ReturnStatus = STATUS_SUCCESS; /* ? */
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
 
    /* Set the TLB according to the process being read. Pid 0 means any process. */
#if MONOPROCESS
    if ((gdb_dbg_tid != 0) && gdb_tid_to_handle(gdb_dbg_tid) != PsGetCurrentThreadId())
    {
        PETHREAD AttachedThread = find_thread(0, gdb_dbg_tid);
        PKPROCESS AttachedProcess;
        if (AttachedThread == NULL)
        {
            KDDBGPRINT("The current GDB debug thread is invalid!");
            return LOOP_IF_SUCCESS(send_gdb_packet("E03"));
        }
 
        AttachedProcess = AttachedThread->Tcb.Process;
        if (AttachedProcess == NULL)
        {
            KDDBGPRINT("The current GDB debug thread is invalid!");
            return LOOP_IF_SUCCESS(send_gdb_packet("E03"));
        }
        __writecr3(AttachedProcess->DirectoryTableBase[0]);
    }
#else
    if ((gdb_dbg_pid != 0) && gdb_pid_to_handle(gdb_dbg_pid) != PsGetCurrentProcessId())
    {
        PEPROCESS AttachedProcess = find_process(gdb_dbg_pid);
        if (AttachedProcess == NULL)
        {
            KDDBGPRINT("The current GDB debug thread is invalid!");
            return LOOP_IF_SUCCESS(send_gdb_packet("E03"));
        }
        /* Only do this if Ps is initialized */
        if (ProcessListHead->Flink)
            __writecr3(AttachedProcess->Pcb.DirectoryTableBase[0]);
    }
#endif
 
    State->u.WriteMemory.TargetBaseAddress = hex_to_address(&gdb_input[1]);
    BufferLength = hex_to_address(strstr(&gdb_input[1], ",") + 1);
    if (BufferLength == 0)
    {
        /* Nothing to do */
        return LOOP_IF_SUCCESS(send_gdb_packet("OK"));
    }
 
    State->u.WriteMemory.TransferCount = BufferLength;
    MessageData->Length = BufferLength;
    MessageData->Buffer = (CHAR*)OutBuffer;
 
    OutPtr = OutBuffer;
    blob_ptr = strstr(strstr(&gdb_input[1], ",") + 1, ":") + 1;
    while (BufferLength)
    {
        if (BufferLength >= 4)
        {
            *((ULONG*)OutPtr) = *((ULONG*)blob_ptr);
            OutPtr += 4;
            blob_ptr += 4;
            BufferLength -= 4;
        }
        else if (BufferLength >= 2)
        {
            *((USHORT*)OutPtr) = *((USHORT*)blob_ptr);
            OutPtr += 2;
            blob_ptr += 2;
            BufferLength -= 2;
        }
        else
        {
            *OutPtr++ = *blob_ptr++;
            BufferLength--;
        }
    }
 
    /* KD will reply with KdSendPacket. Catch it */
    KdpSendPacketHandler = WriteMemorySendHandler;
    return KdPacketReceived;
}

Referenced by gdb_receive_and_interpret_packet().

hex_to_address()

static ULONG64 hex_to_address ( char *  buffer )

static

Definition at line 51 of file gdb_input.c.

{
    ULONG64 ret = 0;
    char hex;
    while (*buffer)
    {
        hex = hex_value(*buffer++);
        if (hex < 0)
            return ret;
        ret <<= 4;
        ret += hex;
    }
    return ret;
}

Referenced by handle_gdb_insert_breakpoint(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_remove_breakpoint(), and handle_gdb_write_mem().

hex_to_tid()

static UINT_PTR hex_to_tid ( char *  buffer )

static

Definition at line 33 of file gdb_input.c.

{
    ULONG_PTR ret = 0;
    char hex;
    while (*buffer)
    {
        hex = hex_value(*buffer++);
        if (hex < 0)
            return ret;
        ret <<= 4;
        ret += hex;
    }
    return ret;
}

Referenced by handle_gdb_query(), handle_gdb_set_thread(), and handle_gdb_thread_alive().

LOOP_IF_SUCCESS()

static KDSTATUS LOOP_IF_SUCCESS ( int  x )

inlinestatic

Definition at line 25 of file gdb_input.c.

{
    return (x == KdPacketReceived) ? (KDSTATUS)-1 : x;
}

Referenced by gdb_receive_and_interpret_packet(), handle_gdb_insert_breakpoint(), handle_gdb_read_mem(), handle_gdb_remove_breakpoint(), handle_gdb_v(), and handle_gdb_write_mem().

ReadMemorySendHandler()

static BOOLEAN ReadMemorySendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 458 of file gdb_input.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
 
    if (PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
    {
        // KdAssert
        KDDBGPRINT("Wrong packet type (%lu) received after DbgKdReadVirtualMemoryApi request.\n", PacketType);
        return FALSE;
    }
 
    if (State->ApiNumber != DbgKdReadVirtualMemoryApi)
    {
        KDDBGPRINT("Wrong API number (%lu) after DbgKdReadVirtualMemoryApi request.\n", State->ApiNumber);
        return FALSE;
    }
 
    /* Check status. Allow to send partial data. */
    if (!MessageData->Length && !NT_SUCCESS(State->ReturnStatus))
        send_gdb_ntstatus(State->ReturnStatus);
    else
        send_gdb_memory(MessageData->Buffer, MessageData->Length);
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = NULL;
 
#if MONOPROCESS
    if (gdb_dbg_tid != 0)
    /* Reset the TLB */
#else
    if ((gdb_dbg_pid != 0) && gdb_pid_to_handle(gdb_dbg_pid) != PsGetCurrentProcessId())
#endif
    {
        /* Only do this if Ps is initialized */
        if (ProcessListHead->Flink)
            __writecr3(PsGetCurrentProcess()->Pcb.DirectoryTableBase[0]);
    }
 
    return TRUE;
}

Referenced by handle_gdb_read_mem().

RestoreBreakPointSendHandler()

static BOOLEAN RestoreBreakPointSendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 802 of file gdb_input.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
    ULONG i;
 
    if (PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
    {
        // KdAssert
        KDDBGPRINT("Wrong packet type (%lu) received after DbgKdRestoreBreakPointApi request.\n", PacketType);
        return FALSE;
    }
 
    if (State->ApiNumber != DbgKdRestoreBreakPointApi)
    {
        KDDBGPRINT("Wrong API number (%lu) after DbgKdRestoreBreakPointApi request.\n", State->ApiNumber);
        return FALSE;
    }
 
    /* We ignore failure here. If DbgKdRestoreBreakPointApi fails,
     * this means that the breakpoint was already invalid for KD. So clean it up on our side. */
    for (i = 0; i < (sizeof(BreakPointHandles) / sizeof(BreakPointHandles[0])); i++)
    {
        if (BreakPointHandles[i].Handle == State->u.RestoreBreakPoint.BreakPointHandle)
        {
            BreakPointHandles[i].Address = 0;
            BreakPointHandles[i].Handle = 0;
            break;
        }
    }
 
    send_gdb_packet("OK");
 
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = NULL;
    return TRUE;
}

Referenced by handle_gdb_remove_breakpoint().

WriteBreakPointSendHandler()

static BOOLEAN WriteBreakPointSendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 702 of file gdb_input.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
 
    if (PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
    {
        // KdAssert
        KDDBGPRINT("Wrong packet type (%lu) received after DbgKdWriteBreakPointApi request.\n", PacketType);
        return FALSE;
    }
 
    if (State->ApiNumber != DbgKdWriteBreakPointApi)
    {
        KDDBGPRINT("Wrong API number (%lu) after DbgKdWriteBreakPointApi request.\n", State->ApiNumber);
        return FALSE;
    }
 
    /* Check status */
    if (!NT_SUCCESS(State->ReturnStatus))
    {
        KDDBGPRINT("Inserting breakpoint failed!\n");
        send_gdb_ntstatus(State->ReturnStatus);
    }
    else
    {
        /* Keep track of the address+handle couple */
        ULONG i;
        for (i = 0; i < (sizeof(BreakPointHandles) / sizeof(BreakPointHandles[0])); i++)
        {
            if (BreakPointHandles[i].Address == 0)
            {
                BreakPointHandles[i].Address = (ULONG_PTR)State->u.WriteBreakPoint.BreakPointAddress;
                BreakPointHandles[i].Handle = State->u.WriteBreakPoint.BreakPointHandle;
                break;
            }
        }
        send_gdb_packet("OK");
    }
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = NULL;
    return TRUE;
}

Referenced by handle_gdb_insert_breakpoint().

WriteMemorySendHandler()

static BOOLEAN WriteMemorySendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 562 of file gdb_input.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
 
    if (PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
    {
        // KdAssert
        KDDBGPRINT("Wrong packet type (%lu) received after DbgKdWriteVirtualMemoryApi request.\n", PacketType);
        return FALSE;
    }
 
    if (State->ApiNumber != DbgKdWriteVirtualMemoryApi)
    {
        KDDBGPRINT("Wrong API number (%lu) after DbgKdWriteVirtualMemoryApi request.\n", State->ApiNumber);
        return FALSE;
    }
 
    /* Check status */
    if (!NT_SUCCESS(State->ReturnStatus))
        send_gdb_ntstatus(State->ReturnStatus);
    else
        send_gdb_packet("OK");
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = NULL;
 
#if MONOPROCESS
    if (gdb_dbg_tid != 0)
    /* Reset the TLB */
#else
    if ((gdb_dbg_pid != 0) && gdb_pid_to_handle(gdb_dbg_pid) != PsGetCurrentProcessId())
#endif
    {
        /* Only do this if Ps is initialized */
        if (ProcessListHead->Flink)
            __writecr3(PsGetCurrentProcess()->Pcb.DirectoryTableBase[0]);
    }
    return TRUE;
}

Referenced by handle_gdb_write_mem().

Variable Documentation

Address

_In_ MEMORY_AREA _In_ PVOID Address

Definition at line 14 of file gdb_input.c.

Referenced by handle_gdb_insert_breakpoint(), handle_gdb_remove_breakpoint(), and WriteBreakPointSendHandler().

struct { ... } BreakPointHandles[32]

Referenced by handle_gdb_insert_breakpoint(), handle_gdb_remove_breakpoint(), RestoreBreakPointSendHandler(), and WriteBreakPointSendHandler().

gdb_dbg_pid

UINT_PTR gdb_dbg_pid

Definition at line 20 of file gdb_input.c.

Referenced by FirstSendHandler(), gdb_send_register(), gdb_send_registers(), handle_gdb_read_mem(), handle_gdb_set_thread(), handle_gdb_write_mem(), ReadMemorySendHandler(), send_kd_state_change(), and WriteMemorySendHandler().

gdb_dbg_tid

UINT_PTR gdb_dbg_tid

Definition at line 21 of file gdb_input.c.

Referenced by FirstSendHandler(), gdb_send_register(), gdb_send_registers(), handle_gdb_read_mem(), handle_gdb_set_thread(), handle_gdb_write_mem(), ReadMemorySendHandler(), send_kd_state_change(), and WriteMemorySendHandler().

gdb_run_tid

ULONG_PTR gdb_run_tid

static

Definition at line 11 of file gdb_input.c.

Referenced by handle_gdb_set_thread().

Handle

__in WDFOBJECT Handle

Definition at line 15 of file gdb_input.c.

Referenced by FxObject::_GetObjectFromHandle(), AccpCloseObjectHandle(), AccpOpenNamedObject(), AccRewriteGetNamedRights(), AccRewriteSetNamedRights(), AcpiAcquireGlobalLock(), AcpiAcquireMutex(), AcpiEvaluateObject(), AcpiEvaluateObjectTyped(), AcpiEvDataTableRegionSetup(), AcpiEvPciConfigRegionSetup(), AcpiEvSystemMemoryRegionSetup(), AcpiGetName(), AcpiGetObjectInfo(), AcpiGetParent(), AcpiGetType(), AcpiNsInitializeDevices(), AcpiNsValidateHandle(), AcpiOsAcquireLock(), AcpiOsAcquireMutex(), AcpiOsDeleteLock(), AcpiOsDeleteMutex(), AcpiOsDeleteSemaphore(), AcpiOsReleaseLock(), AcpiOsReleaseMutex(), AcpiOsSignalSemaphore(), AcpiOsWaitSemaphore(), AcpiReleaseGlobalLock(), AcpiReleaseMutex(), AcpiRsGetMethodData(), AcpiUtGetMutexObject(), AddBootStoreEntry(), AdjustHandleCounts(), AfdSelect(), BiOpenKey(), BlockIoEfiCompareDevice(), BlockIoEfiCreateDeviceEntry(), BlockIoEfiGetChildHandle(), BlockIoEfiGetDeviceInformation(), BmCloseDataStore(), BmOpenDataStore(), BroadcastOpen(), CloseBootStore(), CloseDeviceList(), CloseIniBootLoaderStore(), CloseKernelSoundDevice(), CloseNt4SoundDevice(), co_IntCopyImage(), CON_API(), ConsoleEfiGraphicalOpenProtocol(), ConSrvCloseHandle(), ConSrvGetObject(), ConSrvInsertObject(), ConSrvRemoveObject(), ConStreamInit(), ConStreamInitEx(), ConStreamSetOSHandle(), CreateCallProc(), CreateHandle(), CreateTimer(), CreateTimerQueue(), DbgkpFreeDebugEvent(), DbgkpOpenHandles(), DbgkpSectionToFileHandle(), DebugActiveProcess(), DebugActiveProcessStop(), DebugSetProcessKillOnExit(), DECLARE_INTERFACE_(), DeleteBootStoreEntry(), DestroySoundDeviceInstance(), DosCreateFile(), DosCreateFileEx(), DosOpenFile(), DriverProc(), EfiCloseProtocol(), EfiOpenProtocol(), EfiVmCloseProtocol(), EfiVmOpenProtocol(), EfiVmpCloseProtocol(), EfiVmpFreeInterfaceEntry(), ElfGetLogHandleEntryByHandle(), EmsAlloc(), EmsFree(), EmsIntHandler(), EmsMap(), EnumerateBootStoreEntries(), ExChangeHandle(), ExCreateCallback(), ExCreateHandle(), ExDestroyHandle(), ExDupHandleTable(), ExEnumHandleTable(), ExMapHandleToPointer(), ExpAllocateHandleTableEntry(), ExpDesktopOkToClose(), ExpFreeHandleTableEntry(), ExpLookupHandleTableEntry(), ExpWindowStationOkToClose(), ExSweepHandleTable(), Ext2InvalidateVolumes(), extract_resource(), FatGetCompatibilityModeValue(), FatIsFujitsuFMR(), file_running_action(), FltpOpenFilterServicesKey(), FsRtlDeregisterUncProvider(), FsRtlRegisterUncProvider(), FxObjectHandleCreate(), FxObjectHandleGetGlobals(), FxObjectHandleGetPtr(), FxObjectHandleGetPtrAndGlobals(), FxObjectHandleGetPtrOffset(), GetConnectionHandle(), GetEmsHandleRecord(), GetKernelObjectSecurity(), GetObjectType(), GetRegistryValueBuffer(), GetSocketStructure(), GetSoundDeviceInstanceHandle(), GetStdHandle(), GetXmsHandleRecord(), GlobalFlags(), GlobalHandle(), GlobalReAlloc(), GlobalSize(), HalpDmaAllocateChildAdapter(), HalpGetNMICrashFlag(), HalpMarkAcpiHal(), HalpMarkChipsetDecode(), HalpRegisterPciDebuggingDeviceInfo(), HalpReportSerialNumber(), handle_gdb_remove_breakpoint(), handle_to_gdb_tid(), hGetPEBHandle(), IKsPin_PinMasterClock(), InsertConsole(), IntCreateMenu(), FxEvtDmaEnablerFillCallback::Invoke(), FxEvtDmaEnablerFlushCallback::Invoke(), FxEvtDmaEnablerEnableCallback::Invoke(), FxEvtDmaEnablerDisableCallback::Invoke(), FxEvtDmaEnablerSelfManagedIoStartCallback::Invoke(), FxEvtDmaEnablerSelfManagedIoStopCallback::Invoke(), IoCreateController(), IoCreateSymbolicLink(), IoCreateUnprotectedSymbolicLink(), IoDeleteSymbolicLink(), IoFastQueryNetworkAttributes(), IopCreateDeviceKeyPath(), IopCreateEvent(), IopCreateRegistryKeyEx(), IopCreateRootDirectories(), IopGetRegistryValue(), IopOpenLinkOrRenameTarget(), IopQueryAttributesFile(), KeDeregisterNmiCallback(), KiAcquireApcLockAtSynchLevel(), KiAcquireApcLockRaiseToDpc(), KiAcquireApcLockRaiseToSynch(), KiAcquireProcessLockRaiseToSynch(), KillSelectsForFCB(), KiReleaseApcLock(), KiReleaseApcLockFromSynchLevel(), KiReleaseProcessLock(), KiReleaseProcessLockFromSynchLevel(), KsSynchronousDeviceControl(), LoadModule(), LocalFlags(), LockHandles(), LpcpCreatePort(), LsapValidateDbObject(), main(), MapDefaultKey(), MesBufferHandleReset(), MesHandleFree(), MesIncrementalHandleReset(), MmCreatePhysicalMemorySection(), MockObReferenceObjectByHandle(), ModifyBootStoreEntry(), MountMgrValidateBackPointer(), MountMgrVolumeMountPointChanged(), Mx::MxClose(), Mx::MxReferenceObjectByHandle(), NdisWriteConfiguration(), NdrMesProcEncodeDecode(), NdrMesTypeDecode2(), NdrMesTypeEncode2(), NdrMesTypeFree2(), nfs41_CreateConnection(), nfs41_DeleteConnection(), NlsInit(), NotificationCallback(), NotifyAddrChange(), NotifyRouteChange(), NtAcceptConnectPort(), NtApphelpCacheControl(), NtClose(), NtCreateKey(), NtCreateSection(), NtDeleteFile(), NtOpenKey(), NtOpenSection(), NtQuerySecurityObject(), NtSecureConnectPort(), NtSetSecurityObject(), NtUnloadKey2(), NtUserSetWindowsHookEx(), NtUserSetWinEventHook(), ObCloseHandle(), ObFindHandleForObject(), ObInitSystem(), ObInsertObject(), ObIsKernelHandle(), ObOpenObjectByName(), ObOpenObjectByPointer(), ObpCloseHandle(), ObpCloseHandleCallback(), ObpCloseHandleTableEntry(), ObpCreateDosDevicesDirectory(), ObpCreateHandle(), ObpCreateUnnamedHandle(), ObpReferenceProcessObjectByHandle(), ObQueryObjectAuditingByHandle(), ObReferenceFileObjectForWrite(), ObReferenceObjectByHandle(), ObSetHandleAttributes(), ODBC32_SQLEndTran(), ODBC32_SQLFreeHandle(), ODBC32_SQLGetDiagField(), ODBC32_SQLGetDiagFieldW(), ODBC32_SQLGetDiagRec(), ODBC32_SQLGetDiagRecA(), ODBC32_SQLGetDiagRecW(), OkayToCloseProc(), OnlineMountedVolumes(), OpenBootStore(), OpenBootStore_UStr(), OpenBootStoreByHandle(), OpenDeviceKey(), OpenFilter(), OpenIniBootLoaderStore(), OpenKernelSoundDeviceByName(), OpenNt4KernelSoundDevice(), OpenNt4SoundDevice(), OpenPredefinedKey(), PerfEvtDeviceD0EntryStart(), PerfEvtDeviceD0EntryStop(), PerfEvtDeviceD0ExitStart(), PerfEvtDeviceD0ExitStop(), PerfEvtDevicePrepareHardwareStart(), PerfEvtDevicePrepareHardwareStop(), PerfEvtDeviceReleaseHardwareStart(), PerfEvtDeviceReleaseHardwareStop(), PerfIoComplete(), PerfIoStart(), PerformanceAnalysisIOProcess(), PerformanceAnalysisPowerProcess(), PerformanceGetDriverDeviceAdd(), ProcessIdToHandle(), PsCreateSystemThread(), QSI_DEF(), QueryBootStoreEntry(), QueryBootStoreOptions(), QueryNt4WaveDeviceFormatSupport(), QueryVolumeName(), ReconcileThisDatabaseWithMasterWorker(), RegCleanupRegistry(), RegInitializeRegistry(), RegOverridePredefKey(), RestoreBreakPointSendHandler(), RtlCreateUserThread(), RtlFreeHandle(), RtlIsValidHandle(), RtlIsValidIndexHandle(), RtlpCloseHandleCallback(), RtlpCreateAtomHandle(), RtlpDphPointerFromHandle(), RtlpMakeHandleAllocated(), SampValidateDbObject(), ScmCheckAccess(), ScmCreateManagerHandle(), ScmCreateServiceHandle(), ScmGetServiceFromHandle(), ScmGetServiceManagerFromHandle(), select(), SendIoctl(), SerenumDetectLegacyDevice(), SerenumDetectPnpDevice(), SermouseDetectLegacyDevice(), SetBootStoreOptions(), SetHandle(), SetKernelObjectSecurity(), SetNt4WaveDeviceFormat(), SetRegistryValue(), START_TEST(), StartDefragThread(), SyncOverlappedDeviceIoControl(), TdiCloseDevice(), TdiOpenDevice(), Test_EmptyFile(), test_group_equal(), test_ndr_buffer(), test_owner_equal(), test_pack_RPC_MESSAGE(), test_query_handle(), test_query_handle_ex(), Test_RawSize(), Test_SectionContents(), Test_Truncate(), TestDuplicate(), TestEventConcurrent(), TestIoCreateFile(), TestObRootSecurity(), TestReference(), ThirdPartyVDDBop(), UDFInvalidateVolumes(), UnlockHandles(), UnregisterDeviceNotification(), FxIoTargetRemote::UnregisterForPnpNotification(), UpdatePollWithFCB(), USBAudioRegCreateMediaCategoriesKey(), USBH_ResetDevice(), User32CreateWindowEx(), UserCreateMenu(), VerifyAccess_(), VerifyEventWaitable(), VfAddContextToHandle(), VfWdfObjectGetTypedContext(), WahEnumerateHandleContexts(), WahInsertHandleContext(), WahReferenceContextByHandle(), WahRemoveHandleContext(), WaitForMultipleObjectsEx(), _FX_DRIVER_GLOBALS::WaitForSignal(), WdfObjectAllocateContext(), WdfObjectDereferenceActual(), WdfObjectGetTypedContextWorker(), WdfObjectReferenceActual(), WdmAudCloseSoundDeviceByMMixer(), WdmAudCommitWaveBufferByLegacy(), WdmAudGetWavePositionByLegacy(), WdmAudOpenSysAudioDevice(), WdmAudQueryMixerInfoByLegacy(), WdmAudResetStreamByLegacy(), WdmAudSetWaveStateByLegacy(), WPUModifyIFSHandle(), write_raw_file(), WriteFileEx_Committer(), WriteFileEx_Remixer(), WriteSdbFile(), WSPAccept(), WSPAsyncSelect(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPDuplicateSocket(), WSPEnumNetworkEvents(), WSPEventSelect(), WSPGetOverlappedResult(), WSPGetSockName(), WSPGetSockOpt(), WSPIoctl(), WSPListen(), WSPRecv(), WSPRecvFrom(), WsProcDetachSocket(), WsProcGetAsyncHelper(), WsProcOpenAsyncHelperDevice(), WSPSelect(), WSPSend(), WSPSendTo(), WSPShutdown(), WsSockAddApiReference(), WsSockAssociateHandle(), WsSockDeleteSockets(), WsSockFindIfsSocket(), WsSockGetSocket(), WsSockGetSocketNoExport(), WsTcFindIfsProviderForSocket(), XmsAlloc(), XmsBopProcedure(), XmsFree(), XmsLock(), XmsRealloc(), and XmsUnlock().