示例#1
0
void PrintContext(CONTEXT* context)
{
    while (context)
    {
        printf("{");
        PAIR* list = context->list;
        while (list)
        {
            printf("%s: ", list->identifier);
            VALUE value = list->value;
            if (value.type == VAL_PRIMITIVE)
                printf("%i", value.data.primitive);
            else if (value.type == VAL_STRING)
                printf("%s", value.data.string);
            else if (value.type == VAL_REFERENCE)
            {
                printf("[");
                PrintContext(value.data.reference);
                printf("]");
            }
            else if (value.type == VAL_FUNCTION)
                printf("f()");
            else
                printf("nil");
            printf(", ");

            list = list->next;
        }
        context = context->parent;
        printf("}");
        if (context) printf("\n");
    }
}
示例#2
0
void StdoutConsumer::Consume(const Log::Entry& entry)
{
   PrintHeader(entry);
   PrintMessage(std::cout, entry, true);
   PrintContext(entry);
   PrintNewLine(std::cout, true);
}
示例#3
0
void CDebugger::DumpCrash(DWORD dwThreadId, DWORD dwProcessId, DWORD_PTR dwAddress) {
    PrintContext(dwThreadId);
    PrintDisAsm(dwProcessId, dwAddress);
    PrintCallStack(dwThreadId, dwProcessId);

    m_pCrash->Send();
    m_pCrash->PrintLog();
}
示例#4
0
VOID ShowContext(VOID * ip, VOID * handle, ADDRINT gax)
{
    CONTEXT ctxt;
    
    // Capture the context. This must be done first before some floating point
    // registers have been overwritten
    PIN_MakeContext(handle, &ctxt);

    static bool first = false;

    if (first)
    {
        cout << "ip:    " << ip << endl;
    
        PrintContext(&ctxt);

        cout << endl;
    }

#if defined(TARGET_IA32) || defined(TARGET_IA32E)
    ASSERTX(gax == ctxt._gax);
#endif    
}
示例#5
0
IOReturn CLASS::AddressDevice(uint32_t deviceSlot, uint16_t maxPacketSize, bool wantSAR, uint8_t speed, int32_t highSpeedHubSlot, int32_t highSpeedPort)
{
	ringStruct* pRing;
	ContextStruct *pContext, *pHubContext;
	uint32_t routeString;
	int32_t retFromCMD;
	uint16_t currentPortOnHub, currentHubAddress, addr;
	TRBStruct localTrb = { 0 };

	pRing = GetRing(deviceSlot, 1, 0U);
	if (pRing->isInactive())
		return kIOReturnInternalError;
	currentPortOnHub = _deviceZero.PortOnHub;
	currentHubAddress = _deviceZero.HubAddress;
	routeString = 0U;
	for (int32_t depth = 0; depth < 5; ++depth) {
		if (currentHubAddress == _hub3Address || currentHubAddress == _hub2Address)
			break;
		if (currentPortOnHub > kMaxExternalHubPorts)
			currentPortOnHub = kMaxExternalHubPorts;
		routeString = (routeString << 4) + currentPortOnHub;
		addr = currentHubAddress;
		currentHubAddress = _addressMapper.HubAddress[addr];
		currentPortOnHub = _addressMapper.PortOnHub[addr];
	}
	if (currentHubAddress != _hub3Address && currentHubAddress != _hub2Address) {
		IOLog("%s: Root hub port not found in topology: hub: %u, rootHubSS: %u rootHubHS: %u\n", __FUNCTION__,
			  currentHubAddress, _hub3Address, _hub2Address);
		return kIOReturnInternalError;
	}
	if (!currentPortOnHub || currentPortOnHub > _rootHubNumPorts) {
		IOLog("%s: Root hub port number invalid: %u\n", __FUNCTION__, currentPortOnHub);
		return kIOReturnInternalError;
	}
	GetInputContext();
	pContext = GetInputContextPtr();
	pContext->_ic.dwInCtx1 = XHCI_INCTX_1_ADD_MASK(1U) | XHCI_INCTX_1_ADD_MASK(0U);
	pContext = GetInputContextPtr(1);
	pContext->_s.dwSctx1 |= XHCI_SCTX_1_RH_PORT_SET(static_cast<uint32_t>(currentPortOnHub));
	pContext->_s.dwSctx0 = XHCI_SCTX_0_CTX_NUM_SET(1U);
#if 0
	uint32_t portSpeed = Read32Reg(&_pXHCIOperationalRegisters->prs[currentPortOnHub - 1U].PortSC);
	if (m_invalid_regspace)
		return kIOReturnNoDevice;
	portSpeed = XHCI_PS_SPEED_GET(portSpeed);
	if (portSpeed >= XDEV_SS) {
		SetSlCtxSpeed(pContext, portSpeed);
		maxPacketSize = 512U;
		goto skip_low_full;
	}
#else
	if ((currentHubAddress == _hub3Address) &&
		(speed < kUSBDeviceSpeedSuper || maxPacketSize != 512U))
		IOLog("%s: Inconsistent device speed %u (maxPacketSize %u) for topology rooted in SuperSpeed hub\n",
			  __FUNCTION__, speed, maxPacketSize);
#endif
	switch (speed) {
		case kUSBDeviceSpeedLow:
			SetSlCtxSpeed(pContext, XDEV_LS);
			break;
		case kUSBDeviceSpeedFull:
		default:
			SetSlCtxSpeed(pContext, XDEV_FS);
			break;
		case kUSBDeviceSpeedHigh:
			SetSlCtxSpeed(pContext, XDEV_HS);
			goto skip_low_full;
		case kUSBDeviceSpeedSuper:
			SetSlCtxSpeed(pContext, XDEV_SS);
			goto skip_low_full;
	}
	/*
	 * Note: Only for Low or Full Speed devices
	 */
	if (highSpeedHubSlot) {
		pContext->_s.dwSctx2 |= XHCI_SCTX_2_TT_PORT_NUM_SET(highSpeedPort);
		pContext->_s.dwSctx2 |= XHCI_SCTX_2_TT_HUB_SID_SET(highSpeedHubSlot);
		pHubContext = GetSlotContext(highSpeedHubSlot);
		if (pHubContext && XHCI_SCTX_0_MTT_GET(pHubContext->_s.dwSctx0))
			pContext->_s.dwSctx0 |= XHCI_SCTX_0_MTT_SET(1U);
		else
			pContext->_s.dwSctx0 &= ~XHCI_SCTX_0_MTT_SET(1U);
	}
skip_low_full:
#if kMaxActiveInterrupters > 1
	pContext->_s.dwSctx2 |= XHCI_SCTX_2_IRQ_TARGET_SET(1U);
#endif
	pContext->_s.dwSctx0 |= XHCI_SCTX_0_ROUTE_SET(routeString);
	pContext = GetInputContextPtr(2);
	pContext->_e.dwEpCtx1 |= XHCI_EPCTX_1_EPTYPE_SET(CTRL_EP);
	pContext->_e.dwEpCtx1 |= XHCI_EPCTX_1_MAXP_SIZE_SET(static_cast<uint32_t>(maxPacketSize));
	pContext->_e.qwEpCtx2 |= (pRing->physAddr + pRing->dequeueIndex * sizeof *pRing->ptr) & XHCI_EPCTX_2_TR_DQ_PTR_MASK;
	if (pRing->cycleState)
		pContext->_e.qwEpCtx2 |= XHCI_EPCTX_2_DCS_SET(1U);
	else
		pContext->_e.qwEpCtx2 &= ~static_cast<uint64_t>(XHCI_EPCTX_2_DCS_SET(1U));
	pContext->_e.dwEpCtx1 |= XHCI_EPCTX_1_CERR_SET(3U);
	pContext->_e.dwEpCtx4 |= XHCI_EPCTX_4_AVG_TRB_LEN_SET(8U);
	SetTRBAddr64(&localTrb, _inputContext.physAddr);
	localTrb.d |= XHCI_TRB_3_SLOT_SET(deviceSlot);
	if (!wantSAR)
		localTrb.d |= XHCI_TRB_3_BSR_BIT;
	retFromCMD = WaitForCMD(&localTrb, XHCI_TRB_TYPE_ADDRESS_DEVICE, 0);
	ReleaseInputContext();
	if (retFromCMD == -1)
		return kIOReturnInternalError;
	else if (retFromCMD > -1000)
		return kIOReturnSuccess;
	else if (retFromCMD == -1000 - XHCI_TRB_ERROR_PARAMETER) {
#if 0
		PrintContext(GetInputContextPtr());
		PrintContext(GetInputContextPtr(1));
		PrintContext(GetInputContextPtr(2));
#endif
	}
	return TranslateXHCIStatus(-1000 - retFromCMD, deviceSlot, false);
}
示例#6
0
IOReturn CLASS::UIMCreateControlEndpoint(UInt8 functionNumber, UInt8 endpointNumber, UInt16 maxPacketSize,
										 UInt8 speed, USBDeviceAddress highSpeedHub, int highSpeedPort)
{
	TRBStruct localTrb = { 0U };
	IOReturn rc;
	ContextStruct* pContext;
	ringStruct* pRing;
	int32_t retFromCMD;
	uint16_t packetSize;
	uint8_t slot;

	if (functionNumber == _hub3Address || functionNumber == _hub2Address)
		return kIOReturnSuccess;
	packetSize = maxPacketSize != 9U ? maxPacketSize : 512U;
	if (!functionNumber) {
		if (_numEndpoints >= _maxNumEndpoints)
			return kIOUSBEndpointCountExceeded;
		retFromCMD = WaitForCMD(&localTrb, XHCI_TRB_TYPE_ENABLE_SLOT, 0);
		if (retFromCMD == -1 || retFromCMD <= -1000)
			return retFromCMD == (-1000 - XHCI_TRB_ERROR_NO_SLOTS) ? kIOUSBDeviceCountExceeded : kIOReturnInternalError;
		slot = static_cast<uint8_t>(retFromCMD);
#if 0
		/*
		 * Note: Added Mavericks
		 */
		if (_vendorID == kVendorIntel && _IntelSlotWorkaround && slot == _numSlots) {
			_IntelSlotWorkaround = false;
			retFromCMD = CleanupControlEndpoint(slot, true);
			_IntelSWSlot = slot;
			if (retFromCMD == -1 || retFromCMD <= -1000)
				return kIOReturnInternalError;
			ClearTRB(&localTrb, true);
			retFromCMD = WaitForCMD(&localTrb, XHCI_TRB_TYPE_ENABLE_SLOT, 0);
			if (retFromCMD == -1 || retFromCMD <= -1000)
				return retFromCMD == (-1000 - XHCI_TRB_ERROR_NO_SLOTS) ? kIOUSBDeviceCountExceeded : kIOReturnInternalError;
			slot = static_cast<uint8_t>(retFromCMD);
			if (slot == _numSlots)
				ExecuteGetPortBandwidthWorkaround();
		}
		_IntelSlotWorkaround = false;
#endif
		if (!slot || slot > _numSlots) {
			/*
			 * Sanity check.  Bail out, 'cause UIMDeleteEndpoint
			 *   won't handle invalid slot # well.
			 */
			CleanupControlEndpoint(slot, true);
			IOLog("%s: xHC assigned invalid slot number %u\n", __FUNCTION__, slot);
			return kIOUSBDeviceCountExceeded;
		}
		pRing = CreateRing(slot, 1, 0U);
		if (!pRing || pRing->md) {
			CleanupControlEndpoint(slot, true);
			return kIOReturnInternalError;
		}
		_addressMapper.Slot[0] = slot;
		_addressMapper.Active[0] = true;
		rc = AllocRing(pRing, 1);
		if (rc != kIOReturnSuccess) {
			CleanupControlEndpoint(slot, false);
			return kIOReturnNoMemory;
		}
		rc = MakeBuffer(kIOMemoryPhysicallyContiguous | kIODirectionInOut,
						GetDeviceContextSize(),
						-PAGE_SIZE,
						&SlotPtr(slot)->md,
						reinterpret_cast<void**>(&SlotPtr(slot)->ctx),
						&SlotPtr(slot)->physAddr);
		if (rc != kIOReturnSuccess) {
			CleanupControlEndpoint(slot, false);
			return kIOReturnNoMemory;
		}
		if (!pRing->asyncEndpoint) {
			pRing->epType = CTRL_EP;
			pRing->asyncEndpoint = XHCIAsyncEndpoint::withParameters(this, pRing, packetSize, 0U, 0U);
			if (!pRing->asyncEndpoint) {
				CleanupControlEndpoint(slot, false);
				return kIOReturnNoMemory;
			}
			static_cast<void>(__sync_fetch_and_add(&_numEndpoints, 1));
		}
		SetDCBAAAddr64(&_dcbaa.ptr[slot], ConstSlotPtr(slot)->physAddr);
		return AddressDevice(slot,
							 packetSize,
							 false,
							 speed,
							 GetSlotID(highSpeedHub),
							 highSpeedPort);
	}
	if (endpointNumber)
		return kIOReturnInternalError;
	slot = GetSlotID(functionNumber);
	if (!slot)
		return kIOReturnInternalError;
	pContext = GetSlotContext(slot, 1);
	if (!pContext)
		return kIOReturnInternalError;
	if (XHCI_EPCTX_1_MAXP_SIZE_GET(pContext->_e.dwEpCtx1) == packetSize)
		return kIOReturnSuccess;
	GetInputContext();
	pContext = GetInputContextPtr();
	pContext->_ic.dwInCtx1 = XHCI_INCTX_1_ADD_MASK(1U);
	pContext = GetInputContextPtr(2);
	pContext->_e.dwEpCtx1 = XHCI_EPCTX_1_MAXP_SIZE_SET(static_cast<uint32_t>(packetSize));
	SetTRBAddr64(&localTrb, _inputContext.physAddr);
	localTrb.d = XHCI_TRB_3_SLOT_SET(static_cast<uint32_t>(slot));
	retFromCMD = WaitForCMD(&localTrb, XHCI_TRB_TYPE_EVALUATE_CTX, 0);
	ReleaseInputContext();
	if (retFromCMD == -1)
		return kIOReturnInternalError;
	if (retFromCMD > -1000)
		return kIOReturnSuccess;
	if (retFromCMD == -1000 - XHCI_TRB_ERROR_PARAMETER) {
#if 0
		PrintContext(GetInputContextPtr());
		PrintContext(GetInputContextPtr(2));
#endif
	}
	return kIOReturnInternalError;
}
示例#7
0
文件: regs.c 项目: chunhualiu/OpenNT
VOID
IntelRegistersp(
    IN HANDLE CurrentProcess,
    IN HANDLE CurrentThread,
    IN LPSTR ArgumentString
    )
/*++

Routine Description:

    This routine dumps out the 16 bit register set from the vdmtib


Arguments:

    CurrentProcess -- Supplies a handle to the current process
    CurrentThread -- Supplies a handle to the current thread
    ArgumentString -- Supplies a pointer to the commands argument string

Return Value:

    None.

Notes:

    This routine assumes that the pointers to the ntsd routines have already
    been set up.

--*/
{
    BOOL Status;
    ULONG Address, BytesRead;
    CONTEXT IntelRegisters;

    UNREFERENCED_PARAMETER(CurrentThread);

    //
    // Get the address of the VdmTib
    //

    if (sscanf(ArgumentString, "%lx", &Address) < 0) {
        Address = (*GetExpression)(
            "ntvdm!VdmTib"
            );
    }

    if (!Address) {
        (*Print)("Error geting VdmTib address\n");
        return;
    }

    //
    // Read the 16 bit context
    //

    Status = ReadProcessMem(
        CurrentProcess,
        &(((PVDM_TIB)Address)->VdmContext),
        &IntelRegisters,
        sizeof(CONTEXT),
        &BytesRead
        );

    if ((!Status) || (BytesRead != sizeof(CONTEXT))) {
        GetLastError();
        (*Print)("Could not get VdmContext\n");
    } else {
        PrintContext(&IntelRegisters);
    }
}