kdctrl.c

See Hanoi.cpp for the implementation of this cla

            break;
              
        case HANDLE_THREADSTACK_REQUEST:

            //
            // The request is to set up for a thread stack walk
            //

            pWalkThread = (PTHREAD)SH3strtoul(AdditionalData->Buffer, 16);

            if (!CheckIfPThreadExists (pWalkThread)) // Check that pWalkThread is valid 
            { // No: Exit with error 
                DEBUGGERMSG(KDZONE_CTRL, (L"ThreadStack impossible on pWalkThread %8.8lx. This is not a valid pThread value!\r\n", pWalkThread)); 
                AdditionalData->Length = 0;
                break; // Unsucessful
            }
            
            fThreadWalk=TRUE;
	
            pStackTemp = pWalkThread->pcstkTop;
			dwReturnAddr = (ULONG)pStackTemp;
            if (!TranslateRA(&dwReturnAddr, pWalkThread, dwFrameTop)) {
				DEBUGGERMSG( KDZONE_CTRL, (TEXT("ThreadStack: Failed TranslateRA on pWalkThread = %08X\r\n"), pWalkThread));
                AdditionalData->Length = 0;
                break; // Unsucessful
            }
            DEBUGGERMSG(KDZONE_CTRL, (L"Walking thread %8.8lx Proc %8.8lx\r\n",
                    pWalkThread, pLastProc));
            pStk=pStackTemp;
            pLastProc=pWalkThread->pProc;
            DEBUGGERMSG(KDZONE_CTRL, (L"Walking thread %8.8lx Proc %8.8lx\r\n",
                    pWalkThread, pLastProc));

            //
            // The thread's context will be returned in AdditionalData->Buffer
            //

            AdditionalData->Length = sizeof(CONTEXT);
            if (pWalkThread == pCurThread)
                memcpy(AdditionalData->Buffer, Context, sizeof(CONTEXT));
            else
                CpuContextToContext((CONTEXT*)AdditionalData->Buffer, &pWalkThread->ctx);
            if ((ZeroPtr(CONTEXT_TO_PROGRAM_COUNTER((PCONTEXT)AdditionalData->Buffer)) > (1 << VA_SECTION)) || 
                (ZeroPtr(CONTEXT_TO_PROGRAM_COUNTER((PCONTEXT)AdditionalData->Buffer)) < (DWORD)DllLoadBase))
                 CONTEXT_TO_PROGRAM_COUNTER((PCONTEXT)AdditionalData->Buffer) =
                        (UINT)MapPtrProc(CONTEXT_TO_PROGRAM_COUNTER((PCONTEXT)AdditionalData->Buffer), pLastProc);

            m->ReturnStatus = STATUS_SUCCESS;

            DEBUGGERMSG(KDZONE_CTRL, (L"ThreadStack (pStk) %8.8lx (pLastProc) %8.8lx (pCurThread) %8.8lx (pWalkThread) %8.8lx\r\n",
                    pStk, pLastProc, pCurThread, pWalkThread)); 
            break;

        case HANDLE_THREADSTACK_TERMINATE:

            //
            // The request is to terminate a thread stack walk
            //

//            pWalkThread = (PTHREAD)SH3strtoul(AdditionalData->Buffer, 16);

            fThreadWalk = FALSE;
            m->ReturnStatus = STATUS_SUCCESS;

            break;

		case HANDLE_RELOAD_MODULES_REQUEST:
			AdditionalData->Length = (WORD)ReloadAllSymbols( AdditionalData->Buffer, FALSE);
			m->ReturnStatus = STATUS_SUCCESS;			
			break;

		case HANDLE_RELOAD_MODULES_INFO:
			AdditionalData->Length = (WORD)ReloadAllSymbols( AdditionalData->Buffer, TRUE);
			m->ReturnStatus = STATUS_SUCCESS;			
			break;

		case HANDLE_PROCESS_ZONE_REQUEST:
			AdditionalData->Length = ProcessZone(AdditionalData->Buffer);
			m->ReturnStatus = STATUS_SUCCESS;			
			break;

		case HANDLE_KERNEL_DATA_AREA: 
			NKOtherPrintfW( TEXT("Memory start address = %08X\r\n"), pTOC->ulRAMStart);
			memcpy( AdditionalData->Buffer, &(pTOC->ulRAMStart), sizeof(DWORD));
			AdditionalData->Length = sizeof(DWORD);
			m->ReturnStatus = STATUS_SUCCESS;			
			break;

		case HANDLE_GETCURPROCTHREAD:
			memcpy( AdditionalData->Buffer, &pCurProc, sizeof(DWORD));
			memcpy( AdditionalData->Buffer+(sizeof(DWORD)), &pCurThread, sizeof(DWORD));
			memcpy( AdditionalData->Buffer+(sizeof(DWORD)*2), &hCurProc, sizeof(DWORD));
			memcpy( AdditionalData->Buffer+(sizeof(DWORD)*3), &hCurThread, sizeof(DWORD));
			memcpy( AdditionalData->Buffer+(sizeof(DWORD)*4), &(pCurThread->pOwnerProc), sizeof(DWORD));
			memcpy( AdditionalData->Buffer+(sizeof(DWORD)*5), &((PROCESS *)(pCurThread->pOwnerProc)->hProc), sizeof(DWORD));
			AdditionalData->Length = sizeof(DWORD)*6;
			m->ReturnStatus = STATUS_SUCCESS;
			break;

        default:
            AdditionalData->Length = 0;
            break; // Unsucessful
    }

    if (AdditionalData->Length > a->TransferCount) {
        AdditionalData->Length = (USHORT)a->TransferCount;
    }

    a->ActualBytesRead = AdditionalData->Length;

    KdpSendPacket(
        PACKET_TYPE_KD_STATE_MANIPULATE,
        &MessageHeader,
        AdditionalData
        );
}

#if defined(PPC)
#pragma optimize("", on)
#endif

VOID
KdpWriteControlSpace (
    IN PDBGKD_MANIPULATE_STATE m,
    IN PSTRING AdditionalData,
    IN PCONTEXT Context
    )

/*++

Routine Description:

    This function is called in response of a write control space state
    manipulation message.  Its function is to write implementation
    specific system data.

Arguments:

    m - Supplies the state manipulation message.

    AdditionalData - Supplies any additional data for the message.

    Context - Supplies the current context.

Return Value:

    None.

--*/

{
    PDBGKD_WRITE_MEMORY a = &m->u.WriteMemory;
    STRING MessageHeader;
    ULONG Thread;
    LPSTR Params;

    MessageHeader.Length = sizeof(*m);
    MessageHeader.Buffer = (PCHAR)m;

    m->ReturnStatus = STATUS_UNSUCCESSFUL; // By default (shorter and safer)

    //
    // None of these commands actually write anything directly to memory
    //

    a->ActualBytesWritten = 0;

//	DEBUGGERMSG(KDZONE_CTRL,  (L"%8.8lx WriteControlSpace\r\n", (ULONG)a->TargetBaseAddress));
    switch((ULONG)a->TargetBaseAddress) {

        case HANDLE_PROCESS_SWITCH_REQUEST:

            // Unsupported in CE
//            Params = AdditionalData->Buffer;
//            Process = SH3strtoul(Params, 16);
            break; // Unsuccessful

        case HANDLE_THREAD_SWITCH_REQUEST:

            Params = AdditionalData->Buffer;
            Thread = SH3strtoul(Params, 16);

            if (!SwitchToThread((PTHREAD)Thread)) {
                break; // Unsuccessful
            }

            m->ReturnStatus = STATUS_SUCCESS;

            break;

        case HANDLE_STACKWALK_REQUEST:

            //
            // The request is to initialize kernel stackwalk state
            //
            DEBUGGERMSG(KDZONE_STACKW, (L"+++ Write HANDLE_STACKWALK_REQUEST\r\n"));
            if (!fThreadWalk) {
                pStk=pCurThread->pcstkTop;
                pLastProc=pCurProc;
                pWalkThread=pCurThread;
            }
            DEBUGGERMSG(KDZONE_STACKW, (L"Init Stack Walk pStk=%8.8lx pLastProc=%8.8lx pWalkThread=%8.8lx\r\n",
                    pStk, pLastProc, pCurThread)); 

            m->ReturnStatus = STATUS_SUCCESS;

            DEBUGGERMSG(KDZONE_STACKW, (L"--- Write HANDLE_STACKWALK_REQUEST\r\n"));
            break;

        case HANDLE_BKPT_GLOBAL_REQUEST:

            bGlobalBreakPoint=TRUE;

            m->ReturnStatus = STATUS_SUCCESS;
            break;

        case HANDLE_BKPT_THREAD_REQUEST:

            bGlobalBreakPoint=FALSE;

            m->ReturnStatus = STATUS_SUCCESS;
            break;
       default:
            break; // Unsuccessful
    }

    KdpSendPacket(
        PACKET_TYPE_KD_STATE_MANIPULATE,
        &MessageHeader,
        AdditionalData
        );
}

VOID
KdpReadIoSpace (
    IN PDBGKD_MANIPULATE_STATE m,
    IN PSTRING AdditionalData,
    IN PCONTEXT Context
    )

/*++

Routine Description:

    This function is called in response of a read io space state
    manipulation message.  Its function is to read system io
    locations.

Arguments:

    m - Supplies the state manipulation message.

    AdditionalData - Supplies any additional data for the message.

    Context - Supplies the current context.

Return Value:

    None.

--*/

{
    PDBGKD_READ_WRITE_IO a = &m->u.ReadWriteIo;
    STRING MessageHeader;
#if !defined(x86)
    PUCHAR b;
    PUSHORT s;
    PULONG l;
#endif

    MessageHeader.Length = sizeof(*m);
    MessageHeader.Buffer = (PCHAR)m;

    KD_ASSERT(AdditionalData->Length == 0);

    m->ReturnStatus = STATUS_SUCCESS;

    //
    // Check Size and Alignment
    //

    switch ( a->DataSize ) {
#if defined (x86) // x86 processor have a separate io mapping
        case 1:
            a->DataValue = _inp( (SHORT) a->IoAddress);
            break;
        case 2:
            a->DataValue = _inpw ((SHORT) a->IoAddress);
            break;
        case 4:
            a->DataValue = _inpd ((SHORT) a->IoAddress);
            break;
#else // all processors other than x86 use the default memory mapped version
        case 1:
            b = (PUCHAR)MmDbgReadCheck(a->IoAddress);
            if ( b ) {
                a->DataValue = (ULONG)*b;
            } else {
                m->ReturnStatus = STATUS_ACCESS_VIOLATION;
            }
            break;
        case 2:
            if ((ULONG)a->IoAddress & 1 ) {
                m->ReturnStatus = STATUS_DATATYPE_MISALIGNMENT;
            } else {
                s = (PUSHORT)MmDbgReadCheck(a->IoAddress);
                if ( s ) {
                    a->DataValue = (ULONG)*s;
                } else {
                    m->ReturnStatus = STATUS_ACCESS_VIOLATION;
                }
            }
            break;
        case 4:
            if ((ULONG)a->IoAddress & 3 ) {
                m->ReturnStatus = STATUS_DATATYPE_MISALIGNMENT;
            } else {
                l = (PULONG)MmDbgReadCheck(a->IoAddress);
                if ( l ) {
                    a->DataValue = (ULONG)*l;
                } else {
                    m->ReturnStatus = STATUS_ACCESS_VIOLATION;
                }
            }
            break;
#endif
        default:
            m->ReturnStatus = STATUS_INVALID_PARAMETER;
    }

    KdpSendPacket(
        PACKET_TYPE_KD_STATE_MANIPULATE,
        &MessageHeader,
        NULL
        );
}

VOID
KdpWriteIoSpace (
    IN PDBGKD_MANIPULATE_STATE m,
    IN PSTRING AdditionalData,
    IN PCONTEXT Context
    )

/*++

Routine Description:

    This function is called in response of a write io space state
    manipulation message.  Its function is to write to system io
    locations.

Arguments:

    m - Supplies the state manipulation message.

    AdditionalData - Supplies any additional data for the message.

    Context - Supplies the current context.

Return Value:

    None.

--*/

{
    PDBGKD_READ_WRITE_IO a = &m->u.ReadWriteIo;
    STRING MessageHeader;
#if !defined(x86)
    PUCHAR b;
    PUSHORT s;
    PULONG l;
#endif

    MessageHeader.Length = sizeof(*m);
    MessageHeader.Buffer = (PCHAR)m;

    KD_ASSERT(AdditionalData->Length == 0);

    m->ReturnStatus = STATUS_SUCCESS;

    //
    // Check Size and Alignment
    //

    switch ( a->DataSize ) {
#if defined(x86) // x86 processor have a separate io mapping
        case 1:
            _outp ((SHORT) a->IoAddress, a->DataValue);
            break;
        case 2:
            _outpw ((SHORT) a->IoAddress, (WORD) a->DataValue);
            break;
        case 4:
            _outpd ((SHORT) a->IoAddress, (DWORD) a->DataValue);
            break;
#else // all processors other than x86 use the default memory mapped version
        case 1:
            b = (PUCHAR)MmDbgWriteCheck(a->IoAddress);
            if ( b ) {
                WRITE_REGISTER_UCHAR(b,(UCHAR)a->DataValue);
            } else {
                m->ReturnStatus = STATUS_ACCESS_VIOLATION;
            }
            break;
        case 2:
            if ((ULONG)a->IoAddress & 1 ) {
                m->ReturnStatus = STATUS_DATATYPE_MISALIGNMENT;
            } else {
                s = (PUSHORT)MmDbgWriteCheck(a->IoAddress);
                if ( s ) {
                    WRITE_REGISTER_USHORT(s,(USHORT)a->DataValue);
                } else {
                    m->ReturnStatus = STATUS_ACCESS_VIOLATION;
                }
            }
            break;
        case 4:
            if ((ULONG)a->IoAddress & 3 ) {
                m->ReturnStatus = STATUS_DATATYPE_MISALIGNMENT;
            } else {
                l = (PULONG)MmDbgWriteCheck(a->IoAddress);
                if ( l ) {
                    WRITE_REGISTER_ULONG(l,a->DataValue);
                } else {
                    m->ReturnStatus = STATUS_ACCESS_VIOLATION;
                }
            }
            break;
#endif
        default:
            m->ReturnStatus = STATUS_INVALID_PARAMETER;
    }

    KdpSendPacket(
        PACKET_TYPE_KD_STATE_MANIPULATE,
        &MessageHeader,
        NULL
        );
}

DWORD ReloadAllSymbols(LPBYTE lpBuffer, BOOL fDoCopy)
{
	int i;
	DWORD dwSize;
	PMODULE pMod;
	WCHAR *szModName;
	DWORD dwBasePtr, dwModuleSize;

	dwSize = 0;
	for (i=0; i < MAX_PROCESSES; i++)
		if (kdProcArray[i].dwVMBase)  {
			szModName = kdProcArray[i].lpszProcName;
			dwBasePtr = (DWORD)kdProcArray[i].BasePtr;
			if (dwBasePtr == 0x10000)
				dwBasePtr |= kdProcArray[i].dwVMBase;
			dwModuleSize = kdProcArray[i].e32.e32_vsize;
			if (fDoCopy) kdbgWtoA(szModName,lpBuffer+dwSize);
			dwSize = dwSize+kdbgwcslen(szModName)+1;
			if (fDoCopy) memcpy( lpBuffer+dwSize,  &dwBasePtr, sizeof(DWORD));
			dwSize += sizeof(DWORD);
			if (fDoCopy) memcpy( lpBuffer+dwSize,  &dwModuleSize, sizeof(DWORD));
			dwSize += sizeof(DWORD);
		}
	pMod = pModList;
	while(pMod) {
		szModName = pMod->lpszModName;
		dwBasePtr = (DWORD)pMod->BasePtr & 0x01FFFFFF;
		dwModuleSize = pMod->e32.e32_vsize;
		if (fDoCopy) kdbgWtoA(szModName, lpBuffer+dwSize);
		dwSize = dwSize+kdbgwcslen(szModName)+1;
		if (fDoCopy) memcpy( lpBuffer+dwSize,  &dwBasePtr, sizeof(DWORD));
		dwSize += sizeof(DWORD);
		if (fDoCopy) memcpy( lpBuffer+dwSize,  &dwModuleSize, sizeof(DWORD));
		dwSize += sizeof(DWORD);
		pMod=pMod->pMod;
	}
	if (!fDoCopy)  {
		memcpy( lpBuffer, &dwSize, sizeof(DWORD));
	}
	return dwSize;
}