RTDECL(void) RTLogWriteDebugger(const char *pch, size_t cb)
{
if (pch[cb] != '\0')
AssertBreakpoint();
DbgPrint("%s", pch);
return;
}
DECLHIDDEN(VOID) vboxUsbPnPStateGbgChange(ENMVBOXUSB_PNPSTATE enmOldState, ENMVBOXUSB_PNPSTATE enmNewState)
{
/* *ensure the state change is valid */
switch (enmNewState)
{
case ENMVBOXUSB_PNPSTATE_STARTED:
Assert(enmOldState == ENMVBOXUSB_PNPSTATE_START_PENDING
|| ENMVBOXUSB_PNPSTATE_REMOVE_PENDING
|| ENMVBOXUSB_PNPSTATE_STOPPED
|| ENMVBOXUSB_PNPSTATE_STOP_PENDING);
break;
case ENMVBOXUSB_PNPSTATE_STOP_PENDING:
Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STARTED);
break;
case ENMVBOXUSB_PNPSTATE_STOPPED:
Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STOP_PENDING);
break;
case ENMVBOXUSB_PNPSTATE_SURPRISE_REMOVED:
Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STARTED);
break;
case ENMVBOXUSB_PNPSTATE_REMOVE_PENDING:
Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STARTED);
break;
case ENMVBOXUSB_PNPSTATE_REMOVED:
Assert(enmOldState == ENMVBOXUSB_PNPSTATE_REMOVE_PENDING
|| enmOldState == ENMVBOXUSB_PNPSTATE_SURPRISE_REMOVED);
break;
default:
AssertBreakpoint();
break;
}
}
RTDECL(void) RTLogWriteDebugger(const char *pch, size_t cb)
{
if (pch[cb] != '\0')
AssertBreakpoint();
if ( !g_frtSolarisSplSetsEIF
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
|| ASMIntAreEnabled()
#else
/* PORTME: Check if interrupts are enabled, if applicable. */
#endif
)
cmn_err(CE_CONT, pch);
return;
}
/**
* Initializes the global variables related to windows version.
*/
static void rtR3InitWindowsVersion(void)
{
Assert(g_hModNtDll != NULL);
/*
* ASSUMES OSVERSIONINFOEX starts with the exact same layout as OSVERSIONINFO (safe).
*/
AssertCompileMembersSameSizeAndOffset(OSVERSIONINFOEX, szCSDVersion, OSVERSIONINFO, szCSDVersion);
AssertCompileMemberOffset(OSVERSIONINFOEX, wServicePackMajor, sizeof(OSVERSIONINFO));
/*
* Use the NT version of GetVersionExW so we don't get fooled by
* compatability shims.
*/
RT_ZERO(g_WinOsInfoEx);
g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
LONG (__stdcall *pfnRtlGetVersion)(OSVERSIONINFOEXW *);
*(FARPROC *)&pfnRtlGetVersion = GetProcAddress(g_hModNtDll, "RtlGetVersion");
LONG rcNt = -1;
if (pfnRtlGetVersion)
rcNt = pfnRtlGetVersion(&g_WinOsInfoEx);
if (rcNt != 0)
{
/*
* Couldn't find it or it failed, try the windows version of the API.
*/
RT_ZERO(g_WinOsInfoEx);
g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
if (!GetVersionExW((POSVERSIONINFOW)&g_WinOsInfoEx))
{
/*
* If that didn't work either, just get the basic version bits.
*/
RT_ZERO(g_WinOsInfoEx);
g_WinOsInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
if (GetVersionExW((POSVERSIONINFOW)&g_WinOsInfoEx))
Assert(g_WinOsInfoEx.dwPlatformId != VER_PLATFORM_WIN32_NT || g_WinOsInfoEx.dwMajorVersion < 5);
else
{
AssertBreakpoint();
RT_ZERO(g_WinOsInfoEx);
}
}
}
if (g_WinOsInfoEx.dwOSVersionInfoSize)
g_enmWinVer = rtR3InitWinSimplifiedVersion(&g_WinOsInfoEx);
}
int vboxVhwaHlpGetSurfInfo(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pSurf)
{
for (int i = 0; i < VBoxCommonFromDeviceExt(pDevExt)->cDisplays; ++i)
{
PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[i];
if (pSource->Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
{
int rc = vboxVhwaHlpGetSurfInfoForSource(pDevExt, pSurf, i);
AssertRC(rc);
return rc;
}
}
AssertBreakpoint();
return VERR_NOT_SUPPORTED;
}
RTDECL(void) RTLogWriteDebugger(const char *pch, size_t cb)
{
if (pch[cb] != '\0')
AssertBreakpoint();
if (!RTThreadPreemptIsEnabled(NIL_RTTHREAD)) /** @todo this will change when preemptions hook are implemented. */
return;
if ( !g_frtSolSplSetsEIF
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
|| ASMIntAreEnabled()
#else
/* PORTME: Check if interrupts are enabled, if applicable. */
#endif
)
cmn_err(CE_CONT, pch);
return;
}
bool VBoxWddmFillMode(PVBOXMP_DEVEXT pExt, uint32_t iDisplay, VIDEO_MODE_INFORMATION *pInfo, D3DDDIFORMAT enmFormat, ULONG w, ULONG h)
{
switch (enmFormat)
{
case D3DDDIFMT_A8R8G8B8:
if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 32))
{
WARN(("unsupported mode info for format(%d)", enmFormat));
return false;
}
VBoxFillVidModeInfo(pInfo, w, h, 32, 0, 0);
return true;
case D3DDDIFMT_R8G8B8:
if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 24))
{
WARN(("unsupported mode info for format(%d)", enmFormat));
return false;
}
VBoxFillVidModeInfo(pInfo, w, h, 24, 0, 0);
return true;
case D3DDDIFMT_R5G6B5:
if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 16))
{
WARN(("unsupported mode info for format(%d)", enmFormat));
return false;
}
VBoxFillVidModeInfo(pInfo, w, h, 16, 0, 0);
return true;
case D3DDDIFMT_P8:
if (!VBoxMPValidateVideoModeParamsGuest(pExt, iDisplay, w, h, 8))
{
WARN(("unsupported mode info for format(%d)", enmFormat));
return false;
}
VBoxFillVidModeInfo(pInfo, w, h, 8, 0, 0);
return true;
default:
WARN(("unsupported enmFormat(%d)", enmFormat));
AssertBreakpoint();
break;
}
return false;
}
RTDECL(void) RTLogWriteDebugger(const char *pch, size_t cb)
{
if (pch[cb] != '\0')
AssertBreakpoint();
/* cmn_err() acquires adaptive mutexes. Not preemption safe, see @bugref{6657}. */
if (!RTThreadPreemptIsEnabled(NIL_RTTHREAD))
return;
if ( !g_frtSolSplSetsEIF
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
|| ASMIntAreEnabled()
#else
/* PORTME: Check if interrupts are enabled, if applicable. */
#endif
)
{
cmn_err(CE_CONT, pch);
}
return;
}
static DWORD vboxDispIfSwitchToXPDM(PVBOXDISPIF pIf)
{
DWORD err = NO_ERROR;
AssertBreakpoint();
OSVERSIONINFO OSinfo;
OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
GetVersionEx (&OSinfo);
if (OSinfo.dwMajorVersion >= 5)
{
HMODULE hUser = GetModuleHandle("USER32");
if (NULL != hUser)
{
bool bSupported = true;
*(uintptr_t *)&pIf->modeData.xpdm.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
Log((__FUNCTION__": pfnChangeDisplaySettingsEx = %p\n", pIf->modeData.xpdm.pfnChangeDisplaySettingsEx));
bSupported &= !!(pIf->modeData.xpdm.pfnChangeDisplaySettingsEx);
if (!bSupported)
{
Log((__FUNCTION__": pfnChangeDisplaySettingsEx function pointer failed to initialize\n"));
err = ERROR_NOT_SUPPORTED;
}
}
else
{
Log((__FUNCTION__": failed to get USER32 handle, err (%d)\n", GetLastError()));
err = ERROR_NOT_SUPPORTED;
}
}
else
{
Log((__FUNCTION__": can not switch to VBOXDISPIF_MODE_XPDM, because os is not >= w2k\n"));
err = ERROR_NOT_SUPPORTED;
}
return err;
}
void UIFrameBuffer::doProcessVHWACommand(QEvent *pEvent)
{
Q_UNUSED(pEvent);
/* should never be here */
AssertBreakpoint();
}
DECL_FORCE_INLINE(int) rtCritSectEnter(PRTCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
{
AssertPtr(pCritSect);
AssertReturn(pCritSect->u32Magic == RTCRITSECT_MAGIC, VERR_SEM_DESTROYED);
/*
* Return straight away if NOP.
*/
if (pCritSect->fFlags & RTCRITSECT_FLAGS_NOP)
return VINF_SUCCESS;
/*
* How is calling and is the order right?
*/
RTNATIVETHREAD NativeThreadSelf = RTThreadNativeSelf();
#ifdef RTCRITSECT_STRICT
RTTHREAD hThreadSelf = pCritSect->pValidatorRec
? RTThreadSelfAutoAdopt()
: RTThreadSelf();
int rc9;
if (pCritSect->pValidatorRec) /* (bootstap) */
{
rc9 = RTLockValidatorRecExclCheckOrder(pCritSect->pValidatorRec, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
if (RT_FAILURE(rc9))
return rc9;
}
#endif
/*
* Increment the waiter counter.
* This becomes 0 when the section is free.
*/
if (ASMAtomicIncS32(&pCritSect->cLockers) > 0)
{
/*
* Nested?
*/
if (pCritSect->NativeThreadOwner == NativeThreadSelf)
{
if (!(pCritSect->fFlags & RTCRITSECT_FLAGS_NO_NESTING))
{
#ifdef RTCRITSECT_STRICT
rc9 = RTLockValidatorRecExclRecursion(pCritSect->pValidatorRec, pSrcPos);
if (RT_FAILURE(rc9))
{
ASMAtomicDecS32(&pCritSect->cLockers);
return rc9;
}
#endif
pCritSect->cNestings++;
return VINF_SUCCESS;
}
AssertBreakpoint(); /* don't do normal assertion here, the logger uses this code too. */
ASMAtomicDecS32(&pCritSect->cLockers);
return VERR_SEM_NESTED;
}
/*
* Wait for the current owner to release it.
*/
#ifndef RTCRITSECT_STRICT
RTTHREAD hThreadSelf = RTThreadSelf();
#endif
for (;;)
{
#ifdef RTCRITSECT_STRICT
rc9 = RTLockValidatorRecExclCheckBlocking(pCritSect->pValidatorRec, hThreadSelf, pSrcPos,
!(pCritSect->fFlags & RTCRITSECT_FLAGS_NO_NESTING),
RT_INDEFINITE_WAIT, RTTHREADSTATE_CRITSECT, false);
if (RT_FAILURE(rc9))
{
ASMAtomicDecS32(&pCritSect->cLockers);
return rc9;
}
#else
RTThreadBlocking(hThreadSelf, RTTHREADSTATE_CRITSECT, false);
#endif
int rc = RTSemEventWait(pCritSect->EventSem, RT_INDEFINITE_WAIT);
RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_CRITSECT);
if (pCritSect->u32Magic != RTCRITSECT_MAGIC)
return VERR_SEM_DESTROYED;
if (rc == VINF_SUCCESS)
break;
AssertMsg(rc == VERR_TIMEOUT || rc == VERR_INTERRUPTED, ("rc=%Rrc\n", rc));
}
AssertMsg(pCritSect->NativeThreadOwner == NIL_RTNATIVETHREAD, ("pCritSect->NativeThreadOwner=%p\n", pCritSect->NativeThreadOwner));
}
/*
* First time
*/
pCritSect->cNestings = 1;
ASMAtomicWriteHandle(&pCritSect->NativeThreadOwner, NativeThreadSelf);
#ifdef RTCRITSECT_STRICT
RTLockValidatorRecExclSetOwner(pCritSect->pValidatorRec, hThreadSelf, pSrcPos, true);
#endif
return VINF_SUCCESS;
}
