/**
* Deletes the critical section.
*
* @returns VBox status code.
* @param pCritSect The PDM critical section to destroy.
*/
VMMR3DECL(int) PDMR3CritSectDelete(PPDMCRITSECT pCritSect)
{
if (!RTCritSectIsInitialized(&pCritSect->s.Core))
return VINF_SUCCESS;
/*
* Find and unlink it.
*/
PVM pVM = pCritSect->s.pVMR3;
PUVM pUVM = pVM->pUVM;
AssertReleaseReturn(pVM, VERR_PDM_CRITSECT_IPE);
PPDMCRITSECTINT pPrev = NULL;
RTCritSectEnter(&pUVM->pdm.s.ListCritSect);
PPDMCRITSECTINT pCur = pUVM->pdm.s.pCritSects;
while (pCur)
{
if (pCur == &pCritSect->s)
{
int rc = pdmR3CritSectDeleteOne(pVM, pUVM, pCur, pPrev, false /* not final */);
RTCritSectLeave(&pUVM->pdm.s.ListCritSect);
return rc;
}
/* next */
pPrev = pCur;
pCur = pCur->pNext;
}
RTCritSectLeave(&pUVM->pdm.s.ListCritSect);
AssertReleaseMsgFailed(("pCritSect=%p wasn't found!\n", pCritSect));
return VERR_PDM_CRITSECT_NOT_FOUND;
}
void hgcmObjDeleteHandle (uint32_t handle)
{
int rc = VINF_SUCCESS;
LogFlow(("MAIN::hgcmObjDeleteHandle: handle 0x%08X\n", handle));
if (handle)
{
rc = hgcmObjEnter ();
if (RT_SUCCESS(rc))
{
ObjectAVLCore *pCore = (ObjectAVLCore *)RTAvlULRemove (&g_pTree, handle);
if (pCore)
{
AssertRelease(pCore->pSelf);
pCore->pSelf->Dereference ();
}
hgcmObjLeave ();
}
else
{
AssertReleaseMsgFailed (("Failed to acquire object pool semaphore, rc = %Rrc", rc));
}
}
LogFlow(("MAIN::hgcmObjDeleteHandle: rc = %Rrc, return void\n", rc));
return;
}
static DECLCALLBACK(int) tstSupSemMREInf(RTTHREAD hSelf, void *pvUser)
{
SUPSEMEVENTMULTI hEventMulti = (SUPSEMEVENTMULTI)pvUser;
RTThreadUserSignal(hSelf);
int rc = SUPSemEventMultiWaitNoResume(g_pSession, hEventMulti, RT_INDEFINITE_WAIT);
AssertReleaseMsgFailed(("%Rrc\n", rc));
return rc;
}
static DECLCALLBACK(int) tstSupSemSRETimed(RTTHREAD hSelf, void *pvUser)
{
SUPSEMEVENT hEvent = (SUPSEMEVENT)pvUser;
RTThreadUserSignal(hSelf);
int rc = SUPSemEventWaitNoResume(g_pSession, hEvent, 120*1000);
AssertReleaseMsgFailed(("%Rrc\n", rc));
return rc;
}
/**
* Initializes the symbol tree.
*/
static int dbgfR3SymbolInit(PVM pVM)
{
PDBGFSYM pSym = (PDBGFSYM)MMR3HeapAlloc(pVM, MM_TAG_DBGF_SYMBOL, sizeof(*pSym));
if (pSym)
{
pSym->Core.Key = 0;
pSym->Core.KeyLast = ~0;
pSym->pModule = NULL;
pSym->szName[0] = '\0';
if (RTAvlrGCPtrInsert(&pVM->dbgf.s.SymbolTree, &pSym->Core))
return VINF_SUCCESS;
AssertReleaseMsgFailed(("Failed to insert %RGv-%RGv!\n", pSym->Core.Key, pSym->Core.KeyLast));
return VERR_INTERNAL_ERROR;
}
return VERR_NO_MEMORY;
}
void WinAltGrMonitor::updateStateFromKeyEvent(unsigned iDownScanCode,
bool fKeyDown, bool fExtendedKey)
{
LONG messageTime = GetMessageTime();
/* We do not want the make/break: */
AssertRelease(~iDownScanCode & 0x80);
/* Depending on m_enmFakeControlDetectionState: */
switch (m_enmFakeControlDetectionState)
{
case NONE:
case FAKE_CONTROL_DOWN:
if ( iDownScanCode == 0x1D /* left control */
&& fKeyDown
&& !fExtendedKey)
m_enmFakeControlDetectionState = LAST_EVENT_WAS_LEFT_CONTROL_DOWN;
else
m_enmFakeControlDetectionState = NONE;
break;
case LAST_EVENT_WAS_LEFT_CONTROL_DOWN:
if ( iDownScanCode == 0x38 /* Alt */
&& fKeyDown
&& fExtendedKey
&& m_timeOfLastKeyEvent == messageTime
&& doesCurrentLayoutHaveAltGr())
{
m_enmFakeControlDetectionState = FAKE_CONTROL_DOWN;
break;
}
else
m_enmFakeControlDetectionState = LEFT_CONTROL_DOWN;
/* Fall through. */
case LEFT_CONTROL_DOWN:
if ( iDownScanCode == 0x1D /* left control */
&& !fKeyDown
&& !fExtendedKey)
m_enmFakeControlDetectionState = NONE;
break;
default:
AssertReleaseMsgFailed(("Unknown AltGr detection state.\n"));
}
m_timeOfLastKeyEvent = messageTime;
}
HGCMObject *hgcmObjReference (uint32_t handle, HGCMOBJ_TYPE enmObjType)
{
LogFlow(("MAIN::hgcmObjReference: handle 0x%08X\n", handle));
HGCMObject *pObject = NULL;
if ((handle & 0x7FFFFFFF) == 0)
{
return pObject;
}
int rc = hgcmObjEnter ();
if (RT_SUCCESS(rc))
{
ObjectAVLCore *pCore = (ObjectAVLCore *)RTAvlULGet (&g_pTree, handle);
Assert(!pCore || (pCore->pSelf && pCore->pSelf->Type() == enmObjType));
if ( pCore
&& pCore->pSelf
&& pCore->pSelf->Type() == enmObjType)
{
pObject = pCore->pSelf;
AssertRelease(pObject);
pObject->Reference ();
}
hgcmObjLeave ();
}
else
{
AssertReleaseMsgFailed (("Failed to acquire object pool semaphore, rc = %Rrc", rc));
}
LogFlow(("MAIN::hgcmObjReference: return pObject %p\n", pObject));
return pObject;
}
uint32_t hgcmObjMake (HGCMObject *pObject, uint32_t u32HandleIn)
{
int handle = 0;
LogFlow(("MAIN::hgcmObjGenerateHandle: pObject %p\n", pObject));
int rc = hgcmObjEnter ();
if (RT_SUCCESS(rc))
{
ObjectAVLCore *pCore = &pObject->m_core;
/* Generate a new handle value. */
uint32_t volatile *pu32HandleCountSource = pObject->Type () == HGCMOBJ_CLIENT?
&g_u32ClientHandleCount:
&g_u32InternalHandleCount;
uint32_t u32Start = *pu32HandleCountSource;
for (;;)
{
uint32_t Key;
if (u32HandleIn == 0)
{
Key = ASMAtomicIncU32 (pu32HandleCountSource);
if (Key == u32Start)
{
/* Rollover. Something is wrong. */
AssertReleaseFailed ();
break;
}
/* 0 and 0x80000000 are not valid handles. */
if ((Key & 0x7FFFFFFF) == 0)
{
/* Over the invalid value, reinitialize the source. */
*pu32HandleCountSource = pObject->Type () == HGCMOBJ_CLIENT?
0:
0x80000000;
continue;
}
}
else
{
Key = u32HandleIn;
}
/* Insert object to AVL tree. */
pCore->AvlCore.Key = Key;
bool bRC = RTAvlULInsert(&g_pTree, &pCore->AvlCore);
/* Could not insert a handle. */
if (!bRC)
{
if (u32HandleIn == 0)
{
/* Try another generated handle. */
continue;
}
else
{
/* Could not use the specified handle. */
break;
}
}
/* Initialize backlink. */
pCore->pSelf = pObject;
/* Reference the object for time while it resides in the tree. */
pObject->Reference ();
/* Store returned handle. */
handle = Key;
Log(("Object key inserted 0x%08X\n", Key));
break;
}
hgcmObjLeave ();
}
else
{
AssertReleaseMsgFailed (("MAIN::hgcmObjGenerateHandle: Failed to acquire object pool semaphore"));
}
LogFlow(("MAIN::hgcmObjGenerateHandle: handle = 0x%08X, rc = %Rrc, return void\n", handle, rc));
return handle;
}
/**
* Process one request.
*
* @returns IPRT status code.
*
* @param pReq Request packet to process.
*/
DECLHIDDEN(int) rtReqProcessOne(PRTREQINT pReq)
{
LogFlow(("rtReqProcessOne: pReq=%p type=%d fFlags=%#x\n", pReq, pReq->enmType, pReq->fFlags));
/*
* Process the request.
*/
Assert(pReq->enmState == RTREQSTATE_QUEUED);
pReq->enmState = RTREQSTATE_PROCESSING;
int rcRet = VINF_SUCCESS; /* the return code of this function. */
int rcReq = VERR_NOT_IMPLEMENTED; /* the request status. */
switch (pReq->enmType)
{
/*
* A packed down call frame.
*/
case RTREQTYPE_INTERNAL:
{
uintptr_t *pauArgs = &pReq->u.Internal.aArgs[0];
union
{
PFNRT pfn;
DECLCALLBACKMEMBER(int, pfn00)(void);
DECLCALLBACKMEMBER(int, pfn01)(uintptr_t);
DECLCALLBACKMEMBER(int, pfn02)(uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn03)(uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn04)(uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn05)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn06)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn07)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn08)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn09)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn10)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn11)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
DECLCALLBACKMEMBER(int, pfn12)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t);
} u;
u.pfn = pReq->u.Internal.pfn;
#ifndef RT_ARCH_X86
switch (pReq->u.Internal.cArgs)
{
case 0: rcRet = u.pfn00(); break;
case 1: rcRet = u.pfn01(pauArgs[0]); break;
case 2: rcRet = u.pfn02(pauArgs[0], pauArgs[1]); break;
case 3: rcRet = u.pfn03(pauArgs[0], pauArgs[1], pauArgs[2]); break;
case 4: rcRet = u.pfn04(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3]); break;
case 5: rcRet = u.pfn05(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4]); break;
case 6: rcRet = u.pfn06(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5]); break;
case 7: rcRet = u.pfn07(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6]); break;
case 8: rcRet = u.pfn08(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7]); break;
case 9: rcRet = u.pfn09(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8]); break;
case 10: rcRet = u.pfn10(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9]); break;
case 11: rcRet = u.pfn11(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9], pauArgs[10]); break;
case 12: rcRet = u.pfn12(pauArgs[0], pauArgs[1], pauArgs[2], pauArgs[3], pauArgs[4], pauArgs[5], pauArgs[6], pauArgs[7], pauArgs[8], pauArgs[9], pauArgs[10], pauArgs[11]); break;
default:
AssertReleaseMsgFailed(("cArgs=%d\n", pReq->u.Internal.cArgs));
rcRet = rcReq = VERR_INTERNAL_ERROR;
break;
}
#else /* RT_ARCH_X86 */
size_t cbArgs = pReq->u.Internal.cArgs * sizeof(uintptr_t);
# ifdef __GNUC__
__asm__ __volatile__("movl %%esp, %%edx\n\t"
"subl %2, %%esp\n\t"
"andl $0xfffffff0, %%esp\n\t"
"shrl $2, %2\n\t"
"movl %%esp, %%edi\n\t"
"rep movsl\n\t"
"movl %%edx, %%edi\n\t"
"call *%%eax\n\t"
"mov %%edi, %%esp\n\t"
: "=a" (rcRet),
"=S" (pauArgs),
"=c" (cbArgs)
: "0" (u.pfn),
"1" (pauArgs),
"2" (cbArgs)
: "edi", "edx");
# else
__asm
{
xor edx, edx /* just mess it up. */
mov eax, u.pfn
mov ecx, cbArgs
shr ecx, 2
mov esi, pauArgs
mov ebx, esp
sub esp, cbArgs
and esp, 0xfffffff0
mov edi, esp
rep movsd
call eax
mov esp, ebx
mov rcRet, eax
}
# endif
#endif /* RT_ARCH_X86 */
if ((pReq->fFlags & (RTREQFLAGS_RETURN_MASK)) == RTREQFLAGS_VOID)
rcRet = VINF_SUCCESS;
rcReq = rcRet;
break;
}
default:
AssertMsgFailed(("pReq->enmType=%d\n", pReq->enmType));
rcReq = VERR_NOT_IMPLEMENTED;
break;
}
/*
* Complete the request and then release our request handle reference.
*/
pReq->iStatusX = rcReq;
pReq->enmState = RTREQSTATE_COMPLETED;
if (pReq->fFlags & RTREQFLAGS_NO_WAIT)
LogFlow(("rtReqProcessOne: Completed request %p: rcReq=%Rrc rcRet=%Rrc (no wait)\n",
pReq, rcReq, rcRet));
else
{
/* Notify the waiting thread. */
LogFlow(("rtReqProcessOne: Completed request %p: rcReq=%Rrc rcRet=%Rrc - notifying waiting thread\n",
pReq, rcReq, rcRet));
ASMAtomicXchgSize(&pReq->fEventSemClear, false);
int rc2 = RTSemEventSignal(pReq->EventSem);
if (rc2 != VINF_SUCCESS)
{
AssertRC(rc2);
rcRet = rc2;
}
}
RTReqRelease(pReq);
return rcRet;
}
/**
* Waits for the debugger to respond.
*
* @returns VBox status. (clearify)
* @param pVM Pointer to the VM.
*/
static int dbgfR3VMMWait(PVM pVM)
{
PVMCPU pVCpu = VMMGetCpu(pVM);
LogFlow(("dbgfR3VMMWait:\n"));
/** @todo stupid GDT/LDT sync hack. go away! */
SELMR3UpdateFromCPUM(pVM, pVCpu);
int rcRet = VINF_SUCCESS;
/*
* Waits for the debugger to reply (i.e. issue an command).
*/
for (;;)
{
/*
* Wait.
*/
uint32_t cPollHack = 1; /** @todo this interface is horrible now that we're using lots of VMR3ReqCall stuff all over DBGF. */
for (;;)
{
int rc;
if ( !VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS | VM_FF_REQUEST)
&& !VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_REQUEST))
{
rc = RTSemPingWait(&pVM->dbgf.s.PingPong, cPollHack);
if (RT_SUCCESS(rc))
break;
if (rc != VERR_TIMEOUT)
{
LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rc));
return rc;
}
}
if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
{
rc = VMMR3EmtRendezvousFF(pVM, pVCpu);
cPollHack = 1;
}
else if ( VM_FF_ISPENDING(pVM, VM_FF_REQUEST)
|| VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_REQUEST))
{
LogFlow(("dbgfR3VMMWait: Processes requests...\n"));
rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, false /*fPriorityOnly*/);
if (rc == VINF_SUCCESS)
rc = VMR3ReqProcessU(pVM->pUVM, pVCpu->idCpu, false /*fPriorityOnly*/);
LogFlow(("dbgfR3VMMWait: VMR3ReqProcess -> %Rrc rcRet=%Rrc\n", rc, rcRet));
cPollHack = 1;
}
else
{
rc = VINF_SUCCESS;
if (cPollHack < 120)
cPollHack++;
}
if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
{
switch (rc)
{
case VINF_EM_DBG_BREAKPOINT:
case VINF_EM_DBG_STEPPED:
case VINF_EM_DBG_STEP:
case VINF_EM_DBG_STOP:
AssertMsgFailed(("rc=%Rrc\n", rc));
break;
/* return straight away */
case VINF_EM_TERMINATE:
case VINF_EM_OFF:
LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rc));
return rc;
/* remember return code. */
default:
AssertReleaseMsgFailed(("rc=%Rrc is not in the switch!\n", rc));
case VINF_EM_RESET:
case VINF_EM_SUSPEND:
case VINF_EM_HALT:
case VINF_EM_RESUME:
case VINF_EM_RESCHEDULE:
case VINF_EM_RESCHEDULE_REM:
case VINF_EM_RESCHEDULE_RAW:
if (rc < rcRet || rcRet == VINF_SUCCESS)
rcRet = rc;
break;
}
}
else if (RT_FAILURE(rc))
{
LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rc));
return rc;
}
}
/*
* Process the command.
*/
bool fResumeExecution;
DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
DBGFCMD enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_NO_COMMAND);
int rc = dbgfR3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
if (fResumeExecution)
{
if (RT_FAILURE(rc))
rcRet = rc;
else if ( rc >= VINF_EM_FIRST
&& rc <= VINF_EM_LAST
&& (rc < rcRet || rcRet == VINF_SUCCESS))
rcRet = rc;
LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rcRet));
return rcRet;
}
}
}
void UIMachineViewScale::prepareFrameBuffer()
{
/* That method is partial copy-paste of UIMachineView::prepareFrameBuffer()
* and its temporary here just because not all of our frame-buffers are currently supports scale-mode;
* When all of our frame-buffers will be supporting scale-mode, method will be removed!
* Here we are processing only these frame-buffer types, which knows scale-mode! */
/* Prepare frame-buffer depending on render-mode: */
switch (vboxGlobal().vmRenderMode())
{
#ifdef VBOX_GUI_USE_QUARTZ2D
case VBoxDefs::Quartz2DMode:
/* Indicate that we are doing all drawing stuff ourself: */
viewport()->setAttribute(Qt::WA_PaintOnScreen);
m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
break;
#endif /* VBOX_GUI_USE_QUARTZ2D */
default:
#ifdef VBOX_GUI_USE_QIMAGE
case VBoxDefs::QImageMode:
m_pFrameBuffer = new UIFrameBufferQImage(this);
break;
#endif /* VBOX_GUI_USE_QIMAGE */
AssertReleaseMsgFailed(("Scale-mode is currently NOT supporting that render-mode: %d\n", vboxGlobal().vmRenderMode()));
LogRel(("Scale-mode is currently NOT supporting that render-mode: %d\n", vboxGlobal().vmRenderMode()));
qApp->exit(1);
break;
}
/* If frame-buffer was prepared: */
if (m_pFrameBuffer)
{
/* Prepare display: */
CDisplay display = session().GetConsole().GetDisplay();
Assert(!display.isNull());
m_pFrameBuffer->AddRef();
display.SetFramebuffer(m_uScreenId, CFramebuffer(m_pFrameBuffer));
}
QSize size;
#ifdef Q_WS_X11
/* Processing pseudo resize-event to synchronize frame-buffer with stored
* framebuffer size. On X11 this will be additional done when the machine
* state was 'saved'. */
if (session().GetMachine().GetState() == KMachineState_Saved)
size = guestSizeHint();
#endif /* Q_WS_X11 */
/* If there is a preview image saved, we will resize the framebuffer to the
* size of that image. */
ULONG buffer = 0, width = 0, height = 0;
CMachine machine = session().GetMachine();
machine.QuerySavedScreenshotPNGSize(0, buffer, width, height);
if (buffer > 0)
{
/* Init with the screenshot size */
size = QSize(width, height);
/* Try to get the real guest dimensions from the save state */
ULONG guestWidth = 0, guestHeight = 0;
machine.QuerySavedGuestSize(0, guestWidth, guestHeight);
if ( guestWidth > 0
&& guestHeight > 0)
size = QSize(guestWidth, guestHeight);
}
/* If we have a valid size, resize the framebuffer. */
if ( size.width() > 0
&& size.height() > 0)
{
UIResizeEvent event(FramebufferPixelFormat_Opaque, NULL, 0, 0, size.width(), size.height());
frameBuffer()->resizeEvent(&event);
}
}
void UIMachineView::prepareFrameBuffer()
{
/* Prepare frame-buffer depending on render-mode: */
switch (vboxGlobal().vmRenderMode())
{
#ifdef VBOX_GUI_USE_QIMAGE
case VBoxDefs::QImageMode:
# ifdef VBOX_WITH_VIDEOHWACCEL
if (m_fAccelerate2DVideo)
{
UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
if (pFramebuffer)
pFramebuffer->setView(this);
else
{
/* these two additional template args is a workaround to this [VBox|UI] duplication
* @todo: they are to be removed once VBox stuff is gone */
pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferQImage, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
uisession()->setFrameBuffer(screenId(), pFramebuffer);
}
m_pFrameBuffer = pFramebuffer;
}
else
m_pFrameBuffer = new UIFrameBufferQImage(this);
# else /* VBOX_WITH_VIDEOHWACCEL */
m_pFrameBuffer = new UIFrameBufferQImage(this);
# endif /* !VBOX_WITH_VIDEOHWACCEL */
break;
#endif /* VBOX_GUI_USE_QIMAGE */
#ifdef VBOX_GUI_USE_QGLFB
case VBoxDefs::QGLMode:
m_pFrameBuffer = new UIFrameBufferQGL(this);
break;
// case VBoxDefs::QGLOverlayMode:
// m_pFrameBuffer = new UIQGLOverlayFrameBuffer(this);
// break;
#endif /* VBOX_GUI_USE_QGLFB */
#ifdef VBOX_GUI_USE_SDL
case VBoxDefs::SDLMode:
/* Indicate that we are doing all drawing stuff ourself: */
// TODO_NEW_CORE
viewport()->setAttribute(Qt::WA_PaintOnScreen);
# ifdef Q_WS_X11
/* This is somehow necessary to prevent strange X11 warnings on i386 and segfaults on x86_64: */
XFlush(QX11Info::display());
# endif /* Q_WS_X11 */
# if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
if (m_fAccelerate2DVideo)
{
class UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
if (pFramebuffer)
pFramebuffer->setView(this);
else
{
/* these two additional template args is a workaround to this [VBox|UI] duplication
* @todo: they are to be removed once VBox stuff is gone */
pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferSDL, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
uisession()->setFrameBuffer(screenId(), pFramebuffer);
}
m_pFrameBuffer = pFramebuffer;
}
else
m_pFrameBuffer = new UIFrameBufferSDL(this);
# else
m_pFrameBuffer = new UIFrameBufferSDL(this);
# endif
/* Disable scrollbars because we cannot correctly draw in a scrolled window using SDL: */
horizontalScrollBar()->setEnabled(false);
verticalScrollBar()->setEnabled(false);
break;
#endif /* VBOX_GUI_USE_SDL */
#if 0 // TODO: Enable DDraw frame buffer!
#ifdef VBOX_GUI_USE_DDRAW
case VBoxDefs::DDRAWMode:
m_pFrameBuffer = new UIDDRAWFrameBuffer(this);
if (!m_pFrameBuffer || m_pFrameBuffer->address() == NULL)
{
if (m_pFrameBuffer)
delete m_pFrameBuffer;
m_mode = VBoxDefs::QImageMode;
m_pFrameBuffer = new UIFrameBufferQImage(this);
}
break;
#endif /* VBOX_GUI_USE_DDRAW */
#endif
#ifdef VBOX_GUI_USE_QUARTZ2D
case VBoxDefs::Quartz2DMode:
/* Indicate that we are doing all drawing stuff ourself: */
viewport()->setAttribute(Qt::WA_PaintOnScreen);
# ifdef VBOX_WITH_VIDEOHWACCEL
if (m_fAccelerate2DVideo)
{
UIFrameBuffer* pFramebuffer = uisession()->frameBuffer(screenId());
if (pFramebuffer)
pFramebuffer->setView(this);
else
{
/* these two additional template args is a workaround to this [VBox|UI] duplication
* @todo: they are to be removed once VBox stuff is gone */
pFramebuffer = new VBoxOverlayFrameBuffer<UIFrameBufferQuartz2D, UIMachineView, UIResizeEvent>(this, &machineWindowWrapper()->session(), (uint32_t)screenId());
uisession()->setFrameBuffer(screenId(), pFramebuffer);
}
m_pFrameBuffer = pFramebuffer;
}
else
m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
# else /* VBOX_WITH_VIDEOHWACCEL */
m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
# endif /* !VBOX_WITH_VIDEOHWACCEL */
break;
#endif /* VBOX_GUI_USE_QUARTZ2D */
default:
AssertReleaseMsgFailed(("Render mode must be valid: %d\n", vboxGlobal().vmRenderMode()));
LogRel(("Invalid render mode: %d\n", vboxGlobal().vmRenderMode()));
qApp->exit(1);
break;
}
/* If frame-buffer was prepared: */
if (m_pFrameBuffer)
{
/* Prepare display: */
CDisplay display = session().GetConsole().GetDisplay();
Assert(!display.isNull());
#ifdef VBOX_WITH_VIDEOHWACCEL
CFramebuffer fb(NULL);
if (m_fAccelerate2DVideo)
{
LONG XOrigin, YOrigin;
/* Check if the framebuffer is already assigned;
* in this case we do not need to re-assign it neither do we need to AddRef. */
display.GetFramebuffer(m_uScreenId, fb, XOrigin, YOrigin);
}
if (fb.raw() != m_pFrameBuffer) /* <-this will evaluate to true iff m_fAccelerate2DVideo is disabled or iff no framebuffer is yet assigned */
#endif /* VBOX_WITH_VIDEOHWACCEL */
{
m_pFrameBuffer->AddRef();
}
/* Always perform SetFramebuffer to ensure 3D gets notified: */
display.SetFramebuffer(m_uScreenId, CFramebuffer(m_pFrameBuffer));
}
QSize size;
#ifdef Q_WS_X11
/* Processing pseudo resize-event to synchronize frame-buffer with stored
* framebuffer size. On X11 this will be additional done when the machine
* state was 'saved'. */
if (session().GetMachine().GetState() == KMachineState_Saved)
size = guestSizeHint();
#endif /* Q_WS_X11 */
/* If there is a preview image saved, we will resize the framebuffer to the
* size of that image. */
ULONG buffer = 0, width = 0, height = 0;
CMachine machine = session().GetMachine();
machine.QuerySavedScreenshotPNGSize(0, buffer, width, height);
if (buffer > 0)
{
/* Init with the screenshot size */
size = QSize(width, height);
/* Try to get the real guest dimensions from the save state */
ULONG guestWidth = 0, guestHeight = 0;
machine.QuerySavedGuestSize(0, guestWidth, guestHeight);
if ( guestWidth > 0
&& guestHeight > 0)
size = QSize(guestWidth, guestHeight);
}
/* If we have a valid size, resize the framebuffer. */
if ( size.width() > 0
&& size.height() > 0)
{
UIResizeEvent event(FramebufferPixelFormat_Opaque, NULL, 0, 0, size.width(), size.height());
frameBuffer()->resizeEvent(&event);
}
}
/**
* Insert a record into the symbol tree.
*/
static int dbgfR3SymbolInsert(PVM pVM, const char *pszName, RTGCPTR Address, size_t cb, PDBGFMOD pModule)
{
/*
* Make the address space node.
*/
size_t cchName = strlen(pszName) + 1;
PDBGFSYM pSym = (PDBGFSYM)MMR3HeapAlloc(pVM, MM_TAG_DBGF_SYMBOL, RT_OFFSETOF(DBGFSYM, szName[cchName]));
if (pSym)
{
pSym->Core.Key = Address;
pSym->Core.KeyLast = Address + cb;
pSym->pModule = pModule;
memcpy(pSym->szName, pszName, cchName);
PDBGFSYM pOld = (PDBGFSYM)RTAvlrGCPtrRangeGet(&pVM->dbgf.s.SymbolTree, (RTGCPTR)Address);
if (pOld)
{
pSym->Core.KeyLast = pOld->Core.KeyLast;
if (pOld->Core.Key == pSym->Core.Key)
{
pOld = (PDBGFSYM)RTAvlrGCPtrRemove(&pVM->dbgf.s.SymbolTree, (RTGCPTR)Address);
AssertRelease(pOld);
MMR3HeapFree(pOld);
}
else
pOld->Core.KeyLast = Address - 1;
if (RTAvlrGCPtrInsert(&pVM->dbgf.s.SymbolTree, &pSym->Core))
{
/*
* Make the name space node.
*/
PDBGFSYMSPACE pName = (PDBGFSYMSPACE)RTStrSpaceGet(pVM->dbgf.s.pSymbolSpace, pszName);
if (!pName)
{
/* make new symbol space node. */
pName = (PDBGFSYMSPACE)MMR3HeapAlloc(pVM, MM_TAG_DBGF_SYMBOL, sizeof(*pName) + cchName);
if (pName)
{
pName->Core.pszString = (char *)memcpy(pName + 1, pszName, cchName);
pName->pSym = pSym;
if (RTStrSpaceInsert(pVM->dbgf.s.pSymbolSpace, &pName->Core))
return VINF_SUCCESS;
}
else
return VINF_SUCCESS;
}
else
{
/* Add to existing symbol name. */
pSym->pNext = pName->pSym;
pName->pSym = pSym;
return VINF_SUCCESS;
}
}
AssertReleaseMsgFailed(("Failed to insert %RGv-%RGv!\n", pSym->Core.Key, pSym->Core.KeyLast));
}
else
AssertMsgFailed(("pOld! %RGv %s\n", pSym->Core.Key, pszName));
return VERR_INTERNAL_ERROR;
}
return VERR_NO_MEMORY;
}
