/**
* Resumes the CPU timestamp counter ticking.
*
* @returns VINF_SUCCESS or VERR_TM_VIRTUAL_TICKING_IPE (asserted).
* @param pVM The cross context VM structure.
* @param pVCpu The cross context virtual CPU structure.
*/
int tmCpuTickResumeLocked(PVM pVM, PVMCPU pVCpu)
{
if (!pVCpu->tm.s.fTSCTicking)
{
/* TSC must be ticking before calling tmCpuTickGetRawVirtual()! */
pVCpu->tm.s.fTSCTicking = true;
uint32_t c = ASMAtomicIncU32(&pVM->tm.s.cTSCsTicking);
AssertMsgReturn(c <= pVM->cCpus, ("%u vs %u\n", c, pVM->cCpus), VERR_TM_VIRTUAL_TICKING_IPE);
if (c == 1)
{
/* The first VCPU to resume. */
uint64_t offTSCRawSrcOld = pVCpu->tm.s.offTSCRawSrc;
STAM_COUNTER_INC(&pVM->tm.s.StatTSCResume);
/* When resuming, use the TSC value of the last stopped VCPU to avoid the TSC going back. */
switch (pVM->tm.s.enmTSCMode)
{
case TMTSCMODE_REAL_TSC_OFFSET:
pVCpu->tm.s.offTSCRawSrc = SUPReadTsc() - pVM->tm.s.u64LastPausedTSC;
break;
case TMTSCMODE_VIRT_TSC_EMULATED:
case TMTSCMODE_DYNAMIC:
pVCpu->tm.s.offTSCRawSrc = tmCpuTickGetRawVirtual(pVM, false /* don't check for pending timers */)
- pVM->tm.s.u64LastPausedTSC;
break;
case TMTSCMODE_NATIVE_API:
{
#ifndef IN_RC
int rc = NEMHCResumeCpuTickOnAll(pVM, pVCpu, pVM->tm.s.u64LastPausedTSC);
AssertRCReturn(rc, rc);
pVCpu->tm.s.offTSCRawSrc = offTSCRawSrcOld = 0;
#else
AssertFailedReturn(VERR_INTERNAL_ERROR_2);
#endif
break;
}
default:
AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
}
/* Calculate the offset addendum for other VCPUs to use. */
pVM->tm.s.offTSCPause = pVCpu->tm.s.offTSCRawSrc - offTSCRawSrcOld;
}
else
{
/* All other VCPUs (if any). */
pVCpu->tm.s.offTSCRawSrc += pVM->tm.s.offTSCPause;
}
}
return VINF_SUCCESS;
}
RTDECL(int) RTAsn1DynType_CheckSanity(PCRTASN1DYNTYPE pThis, uint32_t fFlags, PRTERRINFO pErrInfo, const char *pszErrorTag)
{
if (RT_UNLIKELY(!RTAsn1DynType_IsPresent(pThis)))
return RTErrInfoSetF(pErrInfo, VERR_ASN1_NOT_PRESENT, "%s: Missing (DYNTYPE).", pszErrorTag);
int rc;
switch (pThis->enmType)
{
case RTASN1TYPE_CORE: rc = RTAsn1Core_CheckSanity(&pThis->u.Core, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_NULL: rc = RTAsn1Null_CheckSanity(&pThis->u.Asn1Null, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_INTEGER: rc = RTAsn1Integer_CheckSanity(&pThis->u.Integer, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_BOOLEAN: rc = RTAsn1Boolean_CheckSanity(&pThis->u.Boolean, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_STRING: rc = RTAsn1String_CheckSanity(&pThis->u.String, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_OCTET_STRING: rc = RTAsn1OctetString_CheckSanity(&pThis->u.OctetString, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_BIT_STRING: rc = RTAsn1BitString_CheckSanity(&pThis->u.BitString, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_TIME: rc = RTAsn1Time_CheckSanity(&pThis->u.Time, fFlags, pErrInfo, pszErrorTag); break;
#if 0
case RTASN1TYPE_SEQUENCE_CORE: rc = VINF_SUCCESS; //rc = RTAsn1SequenceCore_CheckSanity(&pThis->u.SeqCore, fFlags, pErrInfo, pszErrorTag); break;
case RTASN1TYPE_SET_CORE: rc = VINF_SUCCESS; //rc = RTAsn1SetCore_CheckSanity(&pThis->u.SetCore, fFlags, pErrInfo, pszErrorTag); break;
#endif
case RTASN1TYPE_OBJID: rc = RTAsn1ObjId_CheckSanity(&pThis->u.ObjId, fFlags, pErrInfo, pszErrorTag); break;
default:
AssertFailedReturn(VERR_ASN1_INTERNAL_ERROR_2);
}
return rc;
}
RTDECL(int) RTPathParse(const char *pszPath, PRTPATHPARSED pParsed, size_t cbParsed, uint32_t fFlags)
{
/*
* Input validation.
*/
AssertReturn(cbParsed >= RT_UOFFSETOF(RTPATHPARSED, aComps), VERR_INVALID_PARAMETER);
AssertPtrReturn(pParsed, VERR_INVALID_POINTER);
AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
AssertReturn(*pszPath, VERR_PATH_ZERO_LENGTH);
AssertReturn(RTPATH_STR_F_IS_VALID(fFlags, 0), VERR_INVALID_FLAGS);
/*
* Invoke the worker for the selected path style.
*/
switch (fFlags & RTPATH_STR_F_STYLE_MASK)
{
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
case RTPATH_STR_F_STYLE_HOST:
#endif
case RTPATH_STR_F_STYLE_DOS:
return rtPathParseStyleDos(pszPath, pParsed, cbParsed, fFlags);
#if !defined(RT_OS_OS2) && !defined(RT_OS_WINDOWS)
case RTPATH_STR_F_STYLE_HOST:
#endif
case RTPATH_STR_F_STYLE_UNIX:
return rtPathParseStyleUnix(pszPath, pParsed, cbParsed, fFlags);
default:
AssertFailedReturn(VERR_INVALID_FLAGS); /* impossible */
}
}
/**
* Resumes the CPU timestamp counter ticking.
*
* @returns VBox status code.
* @param pVM The cross context VM structure.
* @param pVCpu The cross context virtual CPU structure.
* @internal
*/
int tmCpuTickResume(PVM pVM, PVMCPU pVCpu)
{
if (!pVCpu->tm.s.fTSCTicking)
{
pVCpu->tm.s.fTSCTicking = true;
/** @todo Test that pausing and resuming doesn't cause lag! (I.e. that we're
* unpaused before the virtual time and stopped after it. */
switch (pVM->tm.s.enmTSCMode)
{
case TMTSCMODE_REAL_TSC_OFFSET:
pVCpu->tm.s.offTSCRawSrc = SUPReadTsc() - pVCpu->tm.s.u64TSC;
break;
case TMTSCMODE_VIRT_TSC_EMULATED:
case TMTSCMODE_DYNAMIC:
pVCpu->tm.s.offTSCRawSrc = tmCpuTickGetRawVirtual(pVM, false /* don't check for pending timers */)
- pVCpu->tm.s.u64TSC;
break;
case TMTSCMODE_NATIVE_API:
pVCpu->tm.s.offTSCRawSrc = 0; /** @todo ?? */
/* Looks like this is only used by weird modes and MSR TSC writes. We cannot support either on NEM/win. */
break;
default:
AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
}
return VINF_SUCCESS;
}
AssertFailed();
return VERR_TM_TSC_ALREADY_TICKING;
}
/**
* Puts an EOL marker to the stream.
*
* @returns IPRt status code.
* @param pStream The stream. Must be in write mode.
* @param enmEol The end-of-line marker to write.
*/
int ScmStreamPutEol(PSCMSTREAM pStream, SCMEOL enmEol)
{
if (enmEol == SCMEOL_LF)
return ScmStreamWrite(pStream, "\n", 1);
if (enmEol == SCMEOL_CRLF)
return ScmStreamWrite(pStream, "\r\n", 2);
if (enmEol == SCMEOL_NONE)
return VINF_SUCCESS;
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
/* static */
UIActionPool* UIActionPool::create(UIActionPoolType type)
{
UIActionPool *pActionPool = 0;
switch (type)
{
case UIActionPoolType_Selector: pActionPool = new UIActionPoolSelector; break;
case UIActionPoolType_Runtime: pActionPool = new UIActionPoolRuntime; break;
default: AssertFailedReturn(0);
}
AssertPtrReturn(pActionPool, 0);
pActionPool->prepare();
return pActionPool;
}
/**
* Common worker for DBGFR3StackWalkBeginGuestEx, DBGFR3StackWalkBeginHyperEx,
* DBGFR3StackWalkBeginGuest and DBGFR3StackWalkBeginHyper.
*/
static int dbgfR3StackWalkBeginCommon(PUVM pUVM,
VMCPUID idCpu,
DBGFCODETYPE enmCodeType,
PCDBGFADDRESS pAddrFrame,
PCDBGFADDRESS pAddrStack,
PCDBGFADDRESS pAddrPC,
DBGFRETURNTYPE enmReturnType,
PCDBGFSTACKFRAME *ppFirstFrame)
{
/*
* Validate parameters.
*/
*ppFirstFrame = NULL;
UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
PVM pVM = pUVM->pVM;
VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
if (pAddrFrame)
AssertReturn(DBGFR3AddrIsValid(pUVM, pAddrFrame), VERR_INVALID_PARAMETER);
if (pAddrStack)
AssertReturn(DBGFR3AddrIsValid(pUVM, pAddrStack), VERR_INVALID_PARAMETER);
if (pAddrPC)
AssertReturn(DBGFR3AddrIsValid(pUVM, pAddrPC), VERR_INVALID_PARAMETER);
AssertReturn(enmReturnType >= DBGFRETURNTYPE_INVALID && enmReturnType < DBGFRETURNTYPE_END, VERR_INVALID_PARAMETER);
/*
* Get the CPUM context pointer and pass it on the specified EMT.
*/
RTDBGAS hAs;
PCCPUMCTXCORE pCtxCore;
switch (enmCodeType)
{
case DBGFCODETYPE_GUEST:
pCtxCore = CPUMGetGuestCtxCore(VMMGetCpuById(pVM, idCpu));
hAs = DBGF_AS_GLOBAL;
break;
case DBGFCODETYPE_HYPER:
pCtxCore = CPUMGetHyperCtxCore(VMMGetCpuById(pVM, idCpu));
hAs = DBGF_AS_RC_AND_GC_GLOBAL;
break;
case DBGFCODETYPE_RING0:
pCtxCore = NULL; /* No valid context present. */
hAs = DBGF_AS_R0;
break;
default:
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
return VMR3ReqPriorityCallWaitU(pUVM, idCpu, (PFNRT)dbgfR3StackWalkCtxFull, 10,
pUVM, idCpu, pCtxCore, hAs, enmCodeType,
pAddrFrame, pAddrStack, pAddrPC, enmReturnType, ppFirstFrame);
}
/**
* Implements the SVGA_3D_CMD_SURFACE_DESTROY command (fifo).
*
* @returns VBox status code (currently ignored).
* @param pThis The VGA device instance data.
* @param sid The ID of the surface to destroy.
*/
int vmsvga3dSurfaceDestroy(PVGASTATE pThis, uint32_t sid)
{
PVMSVGA3DSTATE pState = pThis->svga.p3dState;
AssertReturn(pState, VERR_NO_MEMORY);
if ( sid < pState->cSurfaces
&& pState->papSurfaces[sid]->id == sid)
{
PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
Log(("vmsvga3dSurfaceDestroy id %x\n", sid));
/* Check all contexts if this surface is used as a render target or active texture. */
for (uint32_t cid = 0; cid < pState->cContexts; cid++)
{
PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
if (pContext->id == cid)
{
for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTexture); i++)
if (pContext->aSidActiveTexture[i] == sid)
pContext->aSidActiveTexture[i] = SVGA3D_INVALID_ID;
if (pContext->sidRenderTarget == sid)
pContext->sidRenderTarget = SVGA3D_INVALID_ID;
}
}
vmsvga3dBackSurfaceDestroy(pState, pSurface);
if (pSurface->pMipmapLevels)
{
for (uint32_t face=0; face < pSurface->cFaces; face++)
{
for (uint32_t i=0; i < pSurface->faces[face].numMipLevels; i++)
{
uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
if (pSurface->pMipmapLevels[idx].pSurfaceData)
RTMemFree(pSurface->pMipmapLevels[idx].pSurfaceData);
}
}
RTMemFree(pSurface->pMipmapLevels);
}
memset(pSurface, 0, sizeof(*pSurface));
pSurface->id = SVGA3D_INVALID_ID;
}
else
AssertFailedReturn(VERR_INVALID_PARAMETER);
return VINF_SUCCESS;
}
/**
* Converts the name of the current record.
*
* @returns IPRT status code.
* @param pThis The directory instance data.
*/
static int rtDirNtConvertCurName(PRTDIR pThis)
{
switch (pThis->enmInfoClass)
{
case FileIdBothDirectoryInformation:
return rtDirNtConvertName(pThis, pThis->uCurData.pBothId->FileNameLength, pThis->uCurData.pBothId->FileName);
case FileBothDirectoryInformation:
return rtDirNtConvertName(pThis, pThis->uCurData.pBoth->FileNameLength, pThis->uCurData.pBoth->FileName);
#ifdef IPRT_WITH_NT_PATH_PASSTHRU
case FileMaximumInformation:
return rtDirNtConvertName(pThis, pThis->uCurData.pObjDir->Name.Length, pThis->uCurData.pObjDir->Name.Buffer);
#endif
default:
AssertFailedReturn(VERR_INTERNAL_ERROR_3);
}
}
/**
* Initializes the VirtualBoxClient object.
*
* @returns COM result indicator
*/
HRESULT VirtualBoxClient::init()
{
LogFlowThisFunc(("\n"));
HRESULT rc;
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
mData.m_ThreadWatcher = NIL_RTTHREAD;
mData.m_SemEvWatcher = NIL_RTSEMEVENT;
if (ASMAtomicIncU32(&g_cInstances) != 1)
AssertFailedReturn(E_FAIL);
rc = mData.m_pVirtualBox.createLocalObject(CLSID_VirtualBox);
AssertComRCReturnRC(rc);
rc = unconst(mData.m_pEventSource).createObject();
AssertComRCReturnRC(rc);
rc = mData.m_pEventSource->init(static_cast<IVirtualBoxClient *>(this));
AssertComRCReturnRC(rc);
/* Setting up the VBoxSVC watcher thread. If anything goes wrong here it
* is not considered important enough to cause any sort of visible
* failure. The monitoring will not be done, but that's all. */
int vrc = RTSemEventCreate(&mData.m_SemEvWatcher);
AssertRC(vrc);
if (RT_SUCCESS(vrc))
{
vrc = RTThreadCreate(&mData.m_ThreadWatcher, SVCWatcherThread,
this, 0, RTTHREADTYPE_INFREQUENT_POLLER,
RTTHREADFLAGS_WAITABLE, "VBoxSVCWatcher");
AssertRC(vrc);
}
else
{
RTSemEventDestroy(mData.m_SemEvWatcher);
mData.m_SemEvWatcher = NIL_RTSEMEVENT;
}
/* Confirm a successful initialization */
autoInitSpan.setSucceeded();
return rc;
}
RTDECL(int) RTCrCipherOpenByType(PRTCRCIPHER phCipher, RTCRCIPHERTYPE enmType, uint32_t fFlags)
{
AssertPtrReturn(phCipher, VERR_INVALID_POINTER);
*phCipher = NIL_RTCRCIPHER;
AssertReturn(!fFlags, VERR_INVALID_FLAGS);
/*
* Translate the IPRT cipher type to EVP cipher.
*/
const EVP_CIPHER *pCipher = NULL;
switch (enmType)
{
case RTCRCIPHERTYPE_XTS_AES_128:
pCipher = EVP_aes_128_xts();
break;
case RTCRCIPHERTYPE_XTS_AES_256:
pCipher = EVP_aes_256_xts();
break;
/* no default! */
case RTCRCIPHERTYPE_INVALID:
case RTCRCIPHERTYPE_END:
case RTCRCIPHERTYPE_32BIT_HACK:
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
AssertReturn(pCipher, VERR_CR_CIPHER_NOT_SUPPORTED);
/*
* Create the instance.
*/
RTCRCIPHERINT *pThis = (RTCRCIPHERINT *)RTMemAllocZ(sizeof(*pThis));
if (pThis)
{
pThis->u32Magic = RTCRCIPHERINT_MAGIC;
pThis->cRefs = 1;
pThis->pCipher = pCipher;
pThis->enmType = enmType;
*phCipher = pThis;
return VINF_SUCCESS;
}
return VERR_NO_MEMORY;
}
RTFILE rtFileGetStandard(RTHANDLESTD enmStdHandle)
{
DWORD dwStdHandle;
switch (enmStdHandle)
{
case RTHANDLESTD_INPUT: dwStdHandle = STD_INPUT_HANDLE; break;
case RTHANDLESTD_OUTPUT: dwStdHandle = STD_OUTPUT_HANDLE; break;
case RTHANDLESTD_ERROR: dwStdHandle = STD_ERROR_HANDLE; break;
break;
default:
AssertFailedReturn(NIL_RTFILE);
}
HANDLE hNative = GetStdHandle(dwStdHandle);
if (hNative == INVALID_HANDLE_VALUE)
return NIL_RTFILE;
RTFILE hFile = (RTFILE)(uintptr_t)hNative;
AssertReturn((HANDLE)(uintptr_t)hFile == hNative, NIL_RTFILE);
return hFile;
}
/**
* Converts a PGM paging mode to a set of DBGFPGDMP_XXX flags.
*
* @returns Flags. UINT32_MAX if the mode is invalid (asserted).
* @param enmMode The mode.
*/
static uint32_t dbgfR3PagingDumpModeToFlags(PGMMODE enmMode)
{
switch (enmMode)
{
case PGMMODE_32_BIT:
return DBGFPGDMP_FLAGS_PSE;
case PGMMODE_PAE:
return DBGFPGDMP_FLAGS_PSE | DBGFPGDMP_FLAGS_PAE;
case PGMMODE_PAE_NX:
return DBGFPGDMP_FLAGS_PSE | DBGFPGDMP_FLAGS_PAE | DBGFPGDMP_FLAGS_NXE;
case PGMMODE_AMD64:
return DBGFPGDMP_FLAGS_PSE | DBGFPGDMP_FLAGS_PAE | DBGFPGDMP_FLAGS_LME;
case PGMMODE_AMD64_NX:
return DBGFPGDMP_FLAGS_PSE | DBGFPGDMP_FLAGS_PAE | DBGFPGDMP_FLAGS_LME | DBGFPGDMP_FLAGS_NXE;
case PGMMODE_NESTED:
return DBGFPGDMP_FLAGS_NP;
case PGMMODE_EPT:
return DBGFPGDMP_FLAGS_EPT;
default:
AssertFailedReturn(UINT32_MAX);
}
}
RTDECL(int) RTAsn1DynType_Clone(PRTASN1DYNTYPE pThis, PCRTASN1DYNTYPE pSrc, PCRTASN1ALLOCATORVTABLE pAllocator)
{
AssertPtr(pSrc); AssertPtr(pThis); AssertPtr(pAllocator);
RT_ZERO(*pThis);
if (RTAsn1DynType_IsPresent(pSrc))
{
int rc;
switch (pSrc->enmType)
{
case RTASN1TYPE_CORE: rc = RTAsn1Core_Clone(&pThis->u.Core, &pSrc->u.Core, pAllocator); break;
case RTASN1TYPE_NULL: rc = RTAsn1Null_Clone(&pThis->u.Asn1Null, &pSrc->u.Asn1Null, pAllocator); break;
case RTASN1TYPE_INTEGER: rc = RTAsn1Integer_Clone(&pThis->u.Integer, &pSrc->u.Integer, pAllocator); break;
case RTASN1TYPE_BOOLEAN: rc = RTAsn1Boolean_Clone(&pThis->u.Boolean, &pSrc->u.Boolean, pAllocator); break;
case RTASN1TYPE_STRING: rc = RTAsn1String_Clone(&pThis->u.String, &pSrc->u.String, pAllocator); break;
case RTASN1TYPE_OCTET_STRING: rc = RTAsn1OctetString_Clone(&pThis->u.OctetString, &pSrc->u.OctetString, pAllocator); break;
case RTASN1TYPE_BIT_STRING: rc = RTAsn1BitString_Clone(&pThis->u.BitString, &pSrc->u.BitString, pAllocator); break;
case RTASN1TYPE_TIME: rc = RTAsn1Time_Clone(&pThis->u.Time, &pSrc->u.Time, pAllocator); break;
#if 0
case RTASN1TYPE_SEQUENCE_CORE: rc = VERR_NOT_SUPPORTED; //rc = RTAsn1SequenceCore_Clone(&pThis->u.SeqCore, &pSrc->u.SeqCore, pAllocator); break;
case RTASN1TYPE_SET_CORE: rc = VERR_NOT_SUPPORTED; //rc = RTAsn1SetCore_Clone(&pThis->u.SetCore, &pSrc->u.SetCore, pAllocator); break;
#endif
case RTASN1TYPE_OBJID: rc = RTAsn1ObjId_Clone(&pThis->u.ObjId, &pSrc->u.ObjId, pAllocator); break;
default:
AssertFailedReturn(VERR_ASN1_INTERNAL_ERROR_2);
}
if (RT_FAILURE(rc))
{
RT_ZERO(*pThis);
return rc;
}
pThis->enmType = pSrc->enmType;
}
else
pThis->enmType = RTASN1TYPE_NOT_PRESENT;
return VINF_SUCCESS;
}
RTDECL(int) RTAsn1DynType_Compare(PCRTASN1DYNTYPE pLeft, PCRTASN1DYNTYPE pRight)
{
if (RTAsn1DynType_IsPresent(pLeft) && RTAsn1DynType_IsPresent(pRight))
{
if (pLeft->enmType != pRight->enmType)
return pLeft->enmType < pRight->enmType ? -1 : 1;
switch (pLeft->enmType)
{
case RTASN1TYPE_CORE: return RTAsn1Core_Compare(&pLeft->u.Core, &pRight->u.Core); break;
case RTASN1TYPE_NULL: return RTAsn1Null_Compare(&pLeft->u.Asn1Null, &pRight->u.Asn1Null);
case RTASN1TYPE_INTEGER: return RTAsn1Integer_Compare(&pLeft->u.Integer, &pRight->u.Integer);
case RTASN1TYPE_BOOLEAN: return RTAsn1Boolean_Compare(&pLeft->u.Boolean, &pRight->u.Boolean);
case RTASN1TYPE_STRING: return RTAsn1String_Compare(&pLeft->u.String, &pRight->u.String);
case RTASN1TYPE_OCTET_STRING: return RTAsn1OctetString_Compare(&pLeft->u.OctetString, &pRight->u.OctetString);
case RTASN1TYPE_BIT_STRING: return RTAsn1BitString_Compare(&pLeft->u.BitString, &pRight->u.BitString);
case RTASN1TYPE_TIME: return RTAsn1Time_Compare(&pLeft->u.Time, &pRight->u.Time);
case RTASN1TYPE_OBJID: return RTAsn1ObjId_Compare(&pLeft->u.ObjId, &pRight->u.ObjId);
default: AssertFailedReturn(-1);
}
}
else
return (int)RTAsn1DynType_IsPresent(pLeft) - (int)RTAsn1DynType_IsPresent(pRight);
}
RTDECL(int) RTPathSplitReassemble(PRTPATHSPLIT pSplit, uint32_t fFlags, char *pszDstPath, size_t cbDstPath)
{
/*
* Input validation.
*/
AssertPtrReturn(pSplit, VERR_INVALID_POINTER);
AssertReturn(pSplit->cComps > 0, VERR_INVALID_PARAMETER);
AssertReturn(RTPATH_STR_F_IS_VALID(fFlags, 0) && !(fFlags & RTPATH_STR_F_MIDDLE), VERR_INVALID_FLAGS);
AssertPtrReturn(pszDstPath, VERR_INVALID_POINTER);
AssertReturn(cbDstPath > pSplit->cchPath, VERR_BUFFER_OVERFLOW);
/*
* Figure which slash to use.
*/
char chSlash;
switch (fFlags & RTPATH_STR_F_STYLE_MASK)
{
case RTPATH_STR_F_STYLE_HOST:
chSlash = RTPATH_SLASH;
break;
case RTPATH_STR_F_STYLE_DOS:
chSlash = '\\';
break;
case RTPATH_STR_F_STYLE_UNIX:
chSlash = '/';
break;
default:
AssertFailedReturn(VERR_INVALID_FLAGS); /* impossible */
}
/*
* Do the joining.
*/
uint32_t const cchOrgPath = pSplit->cchPath;
size_t cchDstPath = 0;
uint32_t const cComps = pSplit->cComps;
uint32_t idxComp = 0;
char *pszDst = pszDstPath;
size_t cchComp;
if (RTPATH_PROP_HAS_ROOT_SPEC(pSplit->fProps))
{
cchComp = strlen(pSplit->apszComps[0]);
cchDstPath += cchComp;
AssertReturn(cchDstPath <= cchOrgPath, VERR_INVALID_PARAMETER);
memcpy(pszDst, pSplit->apszComps[0], cchComp);
/* fix the slashes */
char chOtherSlash = chSlash == '\\' ? '/' : '\\';
while (cchComp-- > 0)
{
if (*pszDst == chOtherSlash)
*pszDst = chSlash;
pszDst++;
}
idxComp = 1;
}
while (idxComp < cComps)
{
cchComp = strlen(pSplit->apszComps[idxComp]);
cchDstPath += cchComp;
AssertReturn(cchDstPath <= cchOrgPath, VERR_INVALID_PARAMETER);
memcpy(pszDst, pSplit->apszComps[idxComp], cchComp);
pszDst += cchComp;
idxComp++;
if (idxComp != cComps || (pSplit->fProps & RTPATH_PROP_DIR_SLASH))
{
cchDstPath++;
AssertReturn(cchDstPath <= cchOrgPath, VERR_INVALID_PARAMETER);
*pszDst++ = chSlash;
}
}
*pszDst = '\0';
return VINF_SUCCESS;
}
/**
* Handles the log sub-command.
*
* @returns Suitable exit code.
* @param pArgs The handler arguments.
* @param pDebugger Pointer to the debugger interface.
* @param pszSubCmd The sub command.
*/
static RTEXITCODE handleDebugVM_LogXXXX(HandlerArg *pArgs, IMachineDebugger *pDebugger, const char *pszSubCmd)
{
/*
* Parse arguments.
*/
bool fRelease = false;
com::Utf8Str strSettings;
RTGETOPTSTATE GetState;
RTGETOPTUNION ValueUnion;
/*
* NB: don't use short options to prevent log specifications like
* "-drv_foo" from being interpreted as options.
*/
# define DEBUGVM_LOG_DEBUG (VINF_GETOPT_NOT_OPTION + 'd')
# define DEBUGVM_LOG_RELEASE (VINF_GETOPT_NOT_OPTION + 'r')
static const RTGETOPTDEF s_aOptions[] =
{
{ "--debug", DEBUGVM_LOG_DEBUG, RTGETOPT_REQ_NOTHING },
{ "--release", DEBUGVM_LOG_RELEASE, RTGETOPT_REQ_NOTHING }
};
int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST);
AssertRCReturn(rc, RTEXITCODE_FAILURE);
while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
{
switch (rc)
{
case DEBUGVM_LOG_RELEASE:
fRelease = true;
break;
case DEBUGVM_LOG_DEBUG:
fRelease = false;
break;
/* Because log strings can start with "-" (like "-all+dev_foo")
* we have to take everything we got as a setting and apply it.
* IPRT will take care of the validation afterwards. */
default:
if (strSettings.length() == 0)
strSettings = ValueUnion.psz;
else
{
strSettings.append(' ');
strSettings.append(ValueUnion.psz);
}
break;
}
}
if (fRelease)
{
com::Utf8Str strTmp(strSettings);
strSettings = "release: ";
strSettings.append(strTmp);
}
com::Bstr bstrSettings(strSettings);
if (!strcmp(pszSubCmd, "log"))
CHECK_ERROR2I_RET(pDebugger, ModifyLogGroups(bstrSettings.raw()), RTEXITCODE_FAILURE);
else if (!strcmp(pszSubCmd, "logdest"))
CHECK_ERROR2I_RET(pDebugger, ModifyLogDestinations(bstrSettings.raw()), RTEXITCODE_FAILURE);
else if (!strcmp(pszSubCmd, "logflags"))
CHECK_ERROR2I_RET(pDebugger, ModifyLogFlags(bstrSettings.raw()), RTEXITCODE_FAILURE);
else
AssertFailedReturn(RTEXITCODE_FAILURE);
return RTEXITCODE_SUCCESS;
}
int vmsvga3dSaveExec(PVGASTATE pThis, PSSMHANDLE pSSM)
{
PVMSVGA3DSTATE pState = pThis->svga.p3dState;
AssertReturn(pState, VERR_NO_MEMORY);
int rc;
/* Save a copy of the generic 3d state first. */
rc = SSMR3PutStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);
AssertRCReturn(rc, rc);
#ifdef VMSVGA3D_OPENGL
/* Save the shared context. */
if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
{
rc = vmsvga3dSaveContext(pThis, pSSM, &pState->SharedCtx);
AssertRCReturn(rc, rc);
}
#endif
/* Save all active contexts. */
for (uint32_t i = 0; i < pState->cContexts; i++)
{
rc = vmsvga3dSaveContext(pThis, pSSM, pState->papContexts[i]);
AssertRCReturn(rc, rc);
}
/* Save all active surfaces. */
for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
{
PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
/* Save the id first. */
rc = SSMR3PutU32(pSSM, pSurface->id);
AssertRCReturn(rc, rc);
if (pSurface->id != SVGA3D_INVALID_ID)
{
/* Save a copy of the surface structure first. */
rc = SSMR3PutStructEx(pSSM, pSurface, sizeof(*pSurface), 0, g_aVMSVGA3DSURFACEFields, NULL);
AssertRCReturn(rc, rc);
/* Save the mip map level info. */
for (uint32_t face=0; face < pSurface->cFaces; face++)
{
for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
{
uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[idx];
/* Save a copy of the mip map level struct. */
rc = SSMR3PutStructEx(pSSM, pMipmapLevel, sizeof(*pMipmapLevel), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);
AssertRCReturn(rc, rc);
}
}
/* Save the mip map level data. */
for (uint32_t face=0; face < pSurface->cFaces; face++)
{
for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
{
uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[idx];
Log(("Surface sid=%d: save mipmap level %d with %x bytes data.\n", sid, i, pMipmapLevel->cbSurface));
if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
{
if (pMipmapLevel->fDirty)
{
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
Assert(pMipmapLevel->cbSurface);
rc = SSMR3PutMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
}
else
{
/* No data follows */
rc = SSMR3PutBool(pSSM, false);
AssertRCReturn(rc, rc);
}
}
else
{
#ifdef VMSVGA3D_DIRECT3D
void *pData;
bool fRenderTargetTexture = false;
bool fTexture = false;
bool fSkipSave = false;
HRESULT hr;
Assert(pMipmapLevel->cbSurface);
pData = RTMemAllocZ(pMipmapLevel->cbSurface);
AssertReturn(pData, VERR_NO_MEMORY);
switch (pSurface->enmD3DResType)
{
case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
AssertFailed(); /// @todo
fSkipSave = true;
break;
case VMSVGA3D_D3DRESTYPE_SURFACE:
case VMSVGA3D_D3DRESTYPE_TEXTURE:
{
if (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
{
/** @todo unable to easily fetch depth surface data in d3d 9 */
fSkipSave = true;
break;
}
fTexture = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE);
fRenderTargetTexture = fTexture && (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET);
D3DLOCKED_RECT LockedRect;
if (fTexture)
{
if (pSurface->bounce.pTexture)
{
if ( !pSurface->fDirty
&& fRenderTargetTexture
&& i == 0 /* only the first time */)
{
IDirect3DSurface9 *pSrc, *pDest;
/** @todo stricter checks for associated context */
uint32_t cid = pSurface->idAssociatedContext;
if ( cid >= pState->cContexts
|| pState->papContexts[cid]->id != cid)
{
Log(("vmsvga3dSaveExec invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->papContexts[cid]->id));
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
hr = pSurface->bounce.pTexture->GetSurfaceLevel(i, &pDest);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
hr = pSurface->u.pTexture->GetSurfaceLevel(i, &pSrc);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
pSrc->Release();
pDest->Release();
}
hr = pSurface->bounce.pTexture->LockRect(i, /* texture level */
&LockedRect,
NULL,
D3DLOCK_READONLY);
}
else
hr = pSurface->u.pTexture->LockRect(i, /* texture level */
&LockedRect,
NULL,
D3DLOCK_READONLY);
}
else
hr = pSurface->u.pSurface->LockRect(&LockedRect,
NULL,
D3DLOCK_READONLY);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
/* Copy the data one line at a time in case the internal pitch is different. */
for (uint32_t j = 0; j < pMipmapLevel->cBlocksY; ++j)
{
uint8_t *pu8Dst = (uint8_t *)pData + j * pMipmapLevel->cbSurfacePitch;
const uint8_t *pu8Src = (uint8_t *)LockedRect.pBits + j * LockedRect.Pitch;
memcpy(pu8Dst, pu8Src, pMipmapLevel->cbSurfacePitch);
}
if (fTexture)
{
if (pSurface->bounce.pTexture)
{
hr = pSurface->bounce.pTexture->UnlockRect(i);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
}
else
hr = pSurface->u.pTexture->UnlockRect(i);
}
else
hr = pSurface->u.pSurface->UnlockRect();
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
break;
}
case VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER:
case VMSVGA3D_D3DRESTYPE_INDEX_BUFFER:
{
/* Current type of the buffer. */
const bool fVertex = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER);
uint8_t *pD3DData;
if (fVertex)
hr = pSurface->u.pVertexBuffer->Lock(0, 0, (void **)&pD3DData, D3DLOCK_READONLY);
else
hr = pSurface->u.pIndexBuffer->Lock(0, 0, (void **)&pD3DData, D3DLOCK_READONLY);
AssertMsg(hr == D3D_OK, ("vmsvga3dSaveExec: Lock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
memcpy(pData, pD3DData, pMipmapLevel->cbSurface);
if (fVertex)
hr = pSurface->u.pVertexBuffer->Unlock();
else
hr = pSurface->u.pIndexBuffer->Unlock();
AssertMsg(hr == D3D_OK, ("vmsvga3dSaveExec: Unlock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
break;
}
default:
AssertFailed();
break;
}
if (!fSkipSave)
{
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
/* And write the surface data. */
rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
}
else
{
/* No data follows */
rc = SSMR3PutBool(pSSM, false);
AssertRCReturn(rc, rc);
}
RTMemFree(pData);
#elif defined(VMSVGA3D_OPENGL)
void *pData = NULL;
PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
Assert(pMipmapLevel->cbSurface);
switch (pSurface->enmOGLResType)
{
default:
AssertFailed();
RT_FALL_THRU();
case VMSVGA3D_OGLRESTYPE_RENDERBUFFER:
/** @todo fetch data from the renderbuffer. Not used currently. */
/* No data follows */
rc = SSMR3PutBool(pSSM, false);
AssertRCReturn(rc, rc);
break;
case VMSVGA3D_OGLRESTYPE_TEXTURE:
{
GLint activeTexture;
pData = RTMemAllocZ(pMipmapLevel->cbSurface);
AssertReturn(pData, VERR_NO_MEMORY);
glGetIntegerv(GL_TEXTURE_BINDING_2D, &activeTexture);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
glBindTexture(GL_TEXTURE_2D, pSurface->oglId.texture);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
/* Set row length and alignment of the output data. */
VMSVGAPACKPARAMS SavedParams;
vmsvga3dOglSetPackParams(pState, pContext, pSurface, &SavedParams);
glGetTexImage(GL_TEXTURE_2D,
i,
pSurface->formatGL,
pSurface->typeGL,
pData);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
vmsvga3dOglRestorePackParams(pState, pContext, pSurface, &SavedParams);
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
/* And write the surface data. */
rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
/* Restore the old active texture. */
glBindTexture(GL_TEXTURE_2D, activeTexture);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
break;
}
case VMSVGA3D_OGLRESTYPE_BUFFER:
{
uint8_t *pBufferData;
pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pSurface->oglId.buffer);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
pBufferData = (uint8_t *)pState->ext.glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
Assert(pBufferData);
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
/* And write the surface data. */
rc = SSMR3PutMem(pSSM, pBufferData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
pState->ext.glUnmapBuffer(GL_ARRAY_BUFFER);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
}
}
if (pData)
RTMemFree(pData);
#else
#error "Unexpected 3d backend"
#endif
}
}
}
}
}
return VINF_SUCCESS;
}
RTDECL(int) RTHandleGetStandard(RTHANDLESTD enmStdHandle, PRTHANDLE ph)
{
/*
* Validate and convert input.
*/
AssertPtrReturn(ph, VERR_INVALID_POINTER);
int fd;
switch (enmStdHandle)
{
case RTHANDLESTD_INPUT: fd = 0; break;
case RTHANDLESTD_OUTPUT: fd = 1; break;
case RTHANDLESTD_ERROR: fd = 2; break;
default:
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
/*
* Is the requested descriptor valid and which IPRT handle type does it
* best map on to?
*/
struct stat st;
int rc = fstat(fd, &st);
if (rc == -1)
return RTErrConvertFromErrno(errno);
rc = fcntl(fd, F_GETFD, 0);
if (rc == -1)
return RTErrConvertFromErrno(errno);
bool const fInherit = !(rc & FD_CLOEXEC);
RTHANDLE h;
if (S_ISREG(st.st_mode))
h.enmType = RTHANDLETYPE_FILE;
else if ( S_ISFIFO(st.st_mode)
|| (st.st_mode == 0 && st.st_nlink == 0 /*see bugs on bsd manpage*/))
h.enmType = RTHANDLETYPE_PIPE;
else if (S_ISSOCK(st.st_mode))
{
/** @todo check if it's really a socket... IIRC some OSes reports
* anonymouse pips as sockets. */
h.enmType = RTHANDLETYPE_SOCKET;
}
#if 0 /** @todo re-enable this when the VFS pipe has been coded up. */
else if (isatty(fd))
h.enmType = RTHANDLETYPE_PIPE;
#endif
else
h.enmType = RTHANDLETYPE_FILE;
/*
* Create the IPRT handle.
*/
switch (h.enmType)
{
case RTHANDLETYPE_FILE:
rc = RTFileFromNative(&h.u.hFile, fd);
break;
case RTHANDLETYPE_PIPE:
rc = RTPipeFromNative(&h.u.hPipe, fd,
(enmStdHandle == RTHANDLESTD_INPUT ? RTPIPE_N_READ : RTPIPE_N_WRITE)
| (fInherit ? RTPIPE_N_INHERIT : 0));
break;
case RTHANDLETYPE_SOCKET:
rc = rtSocketCreateForNative(&h.u.hSocket, fd);
break;
default: /* shut up gcc */
return VERR_INTERNAL_ERROR;
}
if (RT_SUCCESS(rc))
*ph = h;
return rc;
}
/**
* Implements the SVGA_3D_CMD_SURFACE_STRETCHBLT command (fifo).
*
* @returns VBox status code (currently ignored).
* @param pThis The VGA device instance data.
* @param sid The ID of the surface to destroy.
*/
int vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, SVGA3dSurfaceImageId const *pDstSfcImg, SVGA3dBox const *pDstBox,
SVGA3dSurfaceImageId const *pSrcSfcImg, SVGA3dBox const *pSrcBox, SVGA3dStretchBltMode enmMode)
{
PVMSVGA3DSTATE pState = pThis->svga.p3dState;
AssertReturn(pState, VERR_NO_MEMORY);
uint32_t const sidSrc = pSrcSfcImg->sid;
Assert(sidSrc < SVGA3D_MAX_SURFACE_IDS);
AssertReturn(sidSrc < pState->cSurfaces, VERR_INVALID_PARAMETER);
PVMSVGA3DSURFACE pSrcSurface = pState->papSurfaces[sidSrc];
AssertReturn(pSrcSurface && pSrcSurface->id == sidSrc, VERR_INVALID_PARAMETER);
uint32_t const sidDst = pDstSfcImg->sid;
Assert(sidDst < SVGA3D_MAX_SURFACE_IDS);
AssertReturn(sidDst < pState->cSurfaces, VERR_INVALID_PARAMETER);
PVMSVGA3DSURFACE pDstSurface = pState->papSurfaces[sidDst];
AssertReturn(pDstSurface && pDstSurface->id == sidDst, VERR_INVALID_PARAMETER);
Assert(pSrcSfcImg->face == 0);
AssertReturn(pSrcSfcImg->mipmap < pSrcSurface->faces[0].numMipLevels, VERR_INVALID_PARAMETER);
Assert(pDstSfcImg->face == 0);
AssertReturn(pDstSfcImg->mipmap < pDstSurface->faces[0].numMipLevels, VERR_INVALID_PARAMETER);
PVMSVGA3DCONTEXT pContext;
#ifdef VMSVGA3D_OPENGL
Log(("vmsvga3dSurfaceStretchBlt: src sid=%x (%d,%d)(%d,%d) dest sid=%x (%d,%d)(%d,%d) mode=%x\n",
sidSrc, pSrcBox->x, pSrcBox->y, pSrcBox->x + pSrcBox->w, pSrcBox->y + pSrcBox->h,
sidDst, pDstBox->x, pDstBox->y, pDstBox->x + pDstBox->w, pDstBox->y + pDstBox->h, enmMode));
pContext = &pState->SharedCtx;
VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
#else
Log(("vmsvga3dSurfaceStretchBlt: src sid=%x cid=%x (%d,%d)(%d,%d) dest sid=%x cid=%x (%d,%d)(%d,%d) mode=%x\n",
sidSrc, pSrcSurface->idAssociatedContext, pSrcBox->x, pSrcBox->y, pSrcBox->x + pSrcBox->w, pSrcBox->y + pSrcBox->h,
sidDst, pDstSurface->idAssociatedContext, pDstBox->x, pDstBox->y, pDstBox->x + pDstBox->w, pDstBox->y + pDstBox->h, enmMode));
/** @todo stricter checks for associated context */
uint32_t cid = pDstSurface->idAssociatedContext;
if (cid == SVGA3D_INVALID_ID)
cid = pSrcSurface->idAssociatedContext;
if ( cid >= pState->cContexts
|| pState->papContexts[cid]->id != cid)
{
Log(("vmsvga3dSurfaceStretchBlt invalid context id!\n"));
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
pContext = pState->papContexts[cid];
#endif
int rc;
if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSrcSurface))
{
/* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
Log(("vmsvga3dSurfaceStretchBlt: unknown src surface id=%x type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->flags, pSrcSurface->format));
rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pSrcSurface);
AssertRCReturn(rc, rc);
}
if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pDstSurface))
{
/* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
Log(("vmsvga3dSurfaceStretchBlt: unknown dest surface id=%x type=%d format=%d -> create texture\n", sidDst, pDstSurface->flags, pDstSurface->format));
rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pDstSurface);
AssertRCReturn(rc, rc);
}
return vmsvga3dBackSurfaceStretchBlt(pThis, pState,
pDstSurface, pDstSfcImg->mipmap, pDstBox,
pSrcSurface, pSrcSfcImg->mipmap, pSrcBox,
enmMode, pContext);
}
/**
* Checks if two DBGC variables are identical
*
* @returns
* @param pVar1 .
* @param pVar2 .
*/
bool DBGCVarAreIdentical(PCDBGCVAR pVar1, PCDBGCVAR pVar2)
{
if (!pVar1)
return false;
if (pVar1 == pVar2)
return true;
if (pVar1->enmType != pVar2->enmType)
return false;
switch (pVar1->enmType)
{
case DBGCVAR_TYPE_GC_FLAT:
if (pVar1->u.GCFlat != pVar2->u.GCFlat)
return false;
break;
case DBGCVAR_TYPE_GC_FAR:
if (pVar1->u.GCFar.off != pVar2->u.GCFar.off)
return false;
if (pVar1->u.GCFar.sel != pVar2->u.GCFar.sel)
return false;
break;
case DBGCVAR_TYPE_GC_PHYS:
if (pVar1->u.GCPhys != pVar2->u.GCPhys)
return false;
break;
case DBGCVAR_TYPE_HC_FLAT:
if (pVar1->u.pvHCFlat != pVar2->u.pvHCFlat)
return false;
break;
case DBGCVAR_TYPE_HC_PHYS:
if (pVar1->u.HCPhys != pVar2->u.HCPhys)
return false;
break;
case DBGCVAR_TYPE_NUMBER:
if (pVar1->u.u64Number != pVar2->u.u64Number)
return false;
break;
case DBGCVAR_TYPE_STRING:
case DBGCVAR_TYPE_SYMBOL:
if (RTStrCmp(pVar1->u.pszString, pVar2->u.pszString) != 0)
return false;
break;
default:
AssertFailedReturn(false);
}
if (pVar1->enmRangeType != pVar2->enmRangeType)
return false;
switch (pVar1->enmRangeType)
{
case DBGCVAR_RANGE_NONE:
break;
case DBGCVAR_RANGE_ELEMENTS:
case DBGCVAR_RANGE_BYTES:
if (pVar1->u64Range != pVar2->u64Range)
return false;
break;
default:
AssertFailedReturn(false);
}
return true;
}
int UIChooserNodeGlobal::positionOf(UIChooserNode *pNode)
{
Q_UNUSED(pNode);
AssertFailedReturn(0);
}
/**
* @callback_method_impl{dtrace_pops_t,dtps_getargval}
*
*
* We just cook our own stuff here, using a stack marker for finding the
* required information. That's more reliable than subjecting oneself to the
* solaris bugs and 32-bit apple peculiarities.
*
*
* @remarks Solaris Bug
*
* dtrace_getarg on AMD64 has a different opinion about how to use the cFrames
* argument than dtrace_caller() and/or dtrace_getpcstack(), at least when the
* probe is fired by dtrace_probe() the way we do.
*
* Setting aframes to 1 when calling dtrace_probe_create gives me the right
* arguments, but the wrong 'caller'. Since I cannot do anything about
* 'caller', the only solution is this hack.
*
* Not sure why the Solaris guys hasn't seen this issue before, but maybe there
* isn't anyone using the default argument getter path for ring-0 dtrace_probe()
* calls, SDT surely isn't.
*
* @todo File a solaris bug on dtrace_probe() + dtrace_getarg().
*
*
* @remarks 32-bit XNU (Apple)
*
* The dtrace_probe arguments are 64-bit unsigned integers instead of uintptr_t,
* so we need to make an extra call.
*
*/
static uint64_t vboxDtPOps_GetArgVal(void *pvProv, dtrace_id_t idProbe, void *pvProbe,
int iArg, int cFrames)
{
PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
AssertPtrReturn(pProv, UINT64_MAX);
LOG_DTRACE(("%s: %p / %p - %#x / %p iArg=%d cFrames=%u\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe, iArg, cFrames));
AssertReturn(iArg >= 5, UINT64_MAX);
if (pProv->TracerData.DTrace.fZombie)
return UINT64_MAX;
uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
PCVTGDESCARGLIST pArgList = (PCVTGDESCARGLIST)( (uintptr_t)pProv->pHdr
+ pProv->pHdr->offArgLists
+ pProbeDesc->offArgList);
AssertReturn(pProbeDesc->offArgList < pProv->pHdr->cbArgLists, UINT64_MAX);
PVBDTSTACKDATA pData = vboxDtGetStackData();
/*
* Get the stack data. This is a wee bit complicated on 32-bit systems
* since we want to support 64-bit integer arguments.
*/
uint64_t u64Ret;
if (iArg >= 20)
u64Ret = UINT64_MAX;
else if (pData->enmCaller == kVBoxDtCaller_ProbeFireKernel)
{
#if ARCH_BITS == 64
u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
#else
if ( !pArgList->fHaveLargeArgs
|| iArg >= pArgList->cArgs)
u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
else
{
/* Similar to what we did for mac in when calling dtrace_probe(). */
uint32_t offArg = 0;
for (int i = 5; i < iArg; i++)
if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
offArg++;
u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg];
if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
u64Ret |= (uint64_t)pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg + 1] << 32;
}
#endif
}
else if (pData->enmCaller == kVBoxDtCaller_ProbeFireUser)
{
int offArg = pData->u.ProbeFireUser.offArg;
PCSUPDRVTRACERUSRCTX pCtx = pData->u.ProbeFireUser.pCtx;
AssertPtrReturn(pCtx, UINT64_MAX);
if (pCtx->cBits == 32)
{
if ( !pArgList->fHaveLargeArgs
|| iArg >= pArgList->cArgs)
{
if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
u64Ret = pCtx->u.X86.aArgs[iArg + offArg];
else
u64Ret = UINT64_MAX;
}
else
{
int i;
for (i = 5; i < iArg; i++)
if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
offArg++;
if (offArg + iArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
{
u64Ret = pCtx->u.X86.aArgs[iArg + offArg];
if ( VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType)
&& offArg + iArg + 1 < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
u64Ret |= (uint64_t)pCtx->u.X86.aArgs[iArg + offArg + 1] << 32;
}
else
u64Ret = UINT64_MAX;
}
}
else
{
if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.Amd64.aArgs))
u64Ret = pCtx->u.Amd64.aArgs[iArg + offArg];
else
u64Ret = UINT64_MAX;
}
}
else
AssertFailedReturn(UINT64_MAX);
LOG_DTRACE(("%s: returns %#llx\n", __FUNCTION__, u64Ret));
return u64Ret;
}
/**
* Disassembles a block of memory.
*
* @returns VBox status code.
* @param argv0 Program name (for errors and warnings).
* @param enmCpuMode The cpu mode to disassemble in.
* @param uAddress The address we're starting to disassemble at.
* @param uHighlightAddr The address of the instruction that should be
* highlighted. Pass UINT64_MAX to keep quiet.
* @param pbFile Where to start disassemble.
* @param cbFile How much to disassemble.
* @param enmStyle The assembly output style.
* @param fListing Whether to print in a listing like mode.
* @param enmUndefOp How to deal with undefined opcodes.
*/
static int MyDisasmBlock(const char *argv0, DISCPUMODE enmCpuMode, uint64_t uAddress,
uint64_t uHighlightAddr, uint8_t *pbFile, size_t cbFile,
ASMSTYLE enmStyle, bool fListing, UNDEFOPHANDLING enmUndefOp)
{
/*
* Initialize the CPU context.
*/
MYDISSTATE State;
State.uAddress = uAddress;
State.pbInstr = pbFile;
State.cbInstr = 0;
State.enmUndefOp = enmUndefOp;
State.rc = VINF_SUCCESS;
State.cbLeft = cbFile;
State.pbNext = pbFile;
State.uNextAddr = uAddress;
void (*pfnFormatter)(PMYDISSTATE pState);
switch (enmStyle)
{
case kAsmStyle_Default:
pfnFormatter = MyDisasDefaultFormatter;
break;
case kAsmStyle_yasm:
RTPrintf(" BITS %d\n", enmCpuMode == DISCPUMODE_16BIT ? 16 : enmCpuMode == DISCPUMODE_32BIT ? 32 : 64);
pfnFormatter = MyDisasYasmFormatter;
break;
case kAsmStyle_masm:
pfnFormatter = MyDisasMasmFormatter;
break;
default:
AssertFailedReturn(VERR_INTERNAL_ERROR);
}
/*
* The loop.
*/
int rcRet = VINF_SUCCESS;
while (State.cbLeft > 0)
{
/*
* Disassemble it.
*/
State.cbInstr = 0;
State.cbLeft += State.pbNext - State.pbInstr;
State.uNextAddr = State.uAddress;
State.pbNext = State.pbInstr;
int rc = DISInstrToStrWithReader(State.uAddress, enmCpuMode, MyDisasInstrRead, &State,
&State.Dis, &State.cbInstr, State.szLine, sizeof(State.szLine));
if ( RT_SUCCESS(rc)
|| ( ( rc == VERR_DIS_INVALID_OPCODE
|| rc == VERR_DIS_GEN_FAILURE)
&& State.enmUndefOp == kUndefOp_DefineByte))
{
State.fUndefOp = rc == VERR_DIS_INVALID_OPCODE
|| rc == VERR_DIS_GEN_FAILURE
|| State.Dis.pCurInstr->uOpcode == OP_INVALID
|| State.Dis.pCurInstr->uOpcode == OP_ILLUD2
|| ( State.enmUndefOp == kUndefOp_DefineByte
&& !MyDisasIsValidInstruction(&State.Dis));
if (State.fUndefOp && State.enmUndefOp == kUndefOp_DefineByte)
{
if (!State.cbInstr)
{
State.Dis.abInstr[0] = 0;
State.Dis.pfnReadBytes(&State.Dis, 0, 1, 1);
State.cbInstr = 1;
}
RTPrintf(" db");
for (unsigned off = 0; off < State.cbInstr; off++)
RTPrintf(off ? ", %03xh" : " %03xh", State.Dis.abInstr[off]);
RTPrintf(" ; %s\n", State.szLine);
}
else if (!State.fUndefOp && State.enmUndefOp == kUndefOp_All)
{
RTPrintf("%s: error at %#RX64: unexpected valid instruction (op=%d)\n", argv0, State.uAddress, State.Dis.pCurInstr->uOpcode);
pfnFormatter(&State);
rcRet = VERR_GENERAL_FAILURE;
}
else if (State.fUndefOp && State.enmUndefOp == kUndefOp_Fail)
{
RTPrintf("%s: error at %#RX64: undefined opcode (op=%d)\n", argv0, State.uAddress, State.Dis.pCurInstr->uOpcode);
pfnFormatter(&State);
rcRet = VERR_GENERAL_FAILURE;
}
else
{
/* Use db for odd encodings that we can't make the assembler use. */
if ( State.enmUndefOp == kUndefOp_DefineByte
&& DISFormatYasmIsOddEncoding(&State.Dis))
{
RTPrintf(" db");
for (unsigned off = 0; off < State.cbInstr; off++)
RTPrintf(off ? ", %03xh" : " %03xh", State.Dis.abInstr[off]);
RTPrintf(" ; ");
}
pfnFormatter(&State);
}
}
else
{
State.cbInstr = State.pbNext - State.pbInstr;
if (!State.cbLeft)
RTPrintf("%s: error at %#RX64: read beyond the end (%Rrc)\n", argv0, State.uAddress, rc);
else if (State.cbInstr)
RTPrintf("%s: error at %#RX64: %Rrc cbInstr=%d\n", argv0, State.uAddress, rc, State.cbInstr);
else
{
RTPrintf("%s: error at %#RX64: %Rrc cbInstr=%d!\n", argv0, State.uAddress, rc, State.cbInstr);
if (rcRet == VINF_SUCCESS)
rcRet = rc;
break;
}
}
/* Highlight this instruction? */
if (uHighlightAddr - State.uAddress < State.cbInstr)
RTPrintf("; ^^^^^^^^^^^^^^^^^^^^^\n");
/* Check that the size-only mode returns the smae size on success. */
if (RT_SUCCESS(rc))
{
uint32_t cbInstrOnly = 32;
uint8_t abInstr[sizeof(State.Dis.abInstr)];
memcpy(abInstr, State.Dis.abInstr, sizeof(State.Dis.abInstr));
int rcOnly = DISInstrWithPrefetchedBytes(State.uAddress, enmCpuMode, 0 /*fFilter - none */,
abInstr, State.Dis.cbCachedInstr, MyDisasInstrRead, &State,
&State.Dis, &cbInstrOnly);
if ( rcOnly != rc
|| cbInstrOnly != State.cbInstr)
{
RTPrintf("; Instruction size only check failed rc=%Rrc cbInstrOnly=%#x exepcted %Rrc and %#x\n",
rcOnly, cbInstrOnly, rc, State.cbInstr);
rcRet = VERR_GENERAL_FAILURE;
break;
}
}
/* next */
State.uAddress += State.cbInstr;
State.pbInstr += State.cbInstr;
}
return rcRet;
}
bool UIChooserNodeGlobal::hasNodes(UIChooserItemType enmType /* = UIChooserItemType_Any */) const
{
Q_UNUSED(enmType);
AssertFailedReturn(false);
}
/**
* Validates the TAR header.
*
* @returns VINF_SUCCESS if valid, VERR_TAR_ZERO_HEADER if all zeros, and
* the appropriate VERR_TAR_XXX otherwise.
* @param pTar The TAR header.
* @param penmType Where to return the type of header on success.
*/
static int rtZipTarHdrValidate(PCRTZIPTARHDR pTar, PRTZIPTARTYPE penmType)
{
/*
* Calc the checksum first since this enables us to detect zero headers.
*/
int32_t i32ChkSum;
int32_t i32ChkSumSignedAlt;
if (rtZipTarCalcChkSum(pTar, &i32ChkSum, &i32ChkSumSignedAlt))
return VERR_TAR_ZERO_HEADER;
/*
* Read the checksum field and match the checksums.
*/
int64_t i64HdrChkSum;
int rc = rtZipTarHdrFieldToNum(pTar->Common.chksum, sizeof(pTar->Common.chksum), true /*fOctalOnly*/, &i64HdrChkSum);
if (RT_FAILURE(rc))
return VERR_TAR_BAD_CHKSUM_FIELD;
if ( i32ChkSum != i64HdrChkSum
&& i32ChkSumSignedAlt != i64HdrChkSum) /** @todo test this */
return VERR_TAR_CHKSUM_MISMATCH;
/*
* Detect the TAR type.
*/
RTZIPTARTYPE enmType;
if ( pTar->Common.magic[0] == 'u'
&& pTar->Common.magic[1] == 's'
&& pTar->Common.magic[2] == 't'
&& pTar->Common.magic[3] == 'a'
&& pTar->Common.magic[4] == 'r')
{
/** @todo detect star headers */
if ( pTar->Common.magic[5] == '\0'
&& pTar->Common.version[0] == '0'
&& pTar->Common.version[1] == '0')
enmType = RTZIPTARTYPE_POSIX;
else if ( pTar->Common.magic[5] == ' '
&& pTar->Common.version[0] == ' '
&& pTar->Common.version[1] == '\0')
enmType = RTZIPTARTYPE_GNU;
else
return VERR_TAR_NOT_USTAR_V00;
}
else
enmType = RTZIPTARTYPE_ANCIENT;
*penmType = enmType;
/*
* Perform some basic checks.
*/
switch (enmType)
{
case RTZIPTARTYPE_POSIX:
if ( !RT_C_IS_ALNUM(pTar->Common.typeflag)
&& !pTar->Common.typeflag == '\0')
return VERR_TAR_UNKNOWN_TYPE_FLAG;
break;
case RTZIPTARTYPE_GNU:
switch (pTar->Common.typeflag)
{
case RTZIPTAR_TF_OLDNORMAL:
case RTZIPTAR_TF_NORMAL:
case RTZIPTAR_TF_CONTIG:
case RTZIPTAR_TF_DIR:
case RTZIPTAR_TF_CHR:
case RTZIPTAR_TF_BLK:
case RTZIPTAR_TF_LINK:
case RTZIPTAR_TF_SYMLINK:
case RTZIPTAR_TF_FIFO:
break;
case RTZIPTAR_TF_GNU_LONGLINK:
case RTZIPTAR_TF_GNU_LONGNAME:
break;
case RTZIPTAR_TF_GNU_DUMPDIR:
case RTZIPTAR_TF_GNU_MULTIVOL:
case RTZIPTAR_TF_GNU_SPARSE:
case RTZIPTAR_TF_GNU_VOLDHR:
/** @todo Implement full GNU TAR support. .*/
return VERR_TAR_UNSUPPORTED_GNU_HDR_TYPE;
default:
return VERR_TAR_UNKNOWN_TYPE_FLAG;
}
break;
case RTZIPTARTYPE_ANCIENT:
switch (pTar->Common.typeflag)
{
case RTZIPTAR_TF_OLDNORMAL:
case RTZIPTAR_TF_NORMAL:
case RTZIPTAR_TF_CONTIG:
case RTZIPTAR_TF_DIR:
case RTZIPTAR_TF_LINK:
case RTZIPTAR_TF_SYMLINK:
case RTZIPTAR_TF_FIFO:
break;
default:
return VERR_TAR_UNKNOWN_TYPE_FLAG;
}
break;
default: /* shut up gcc */
AssertFailedReturn(VERR_INTERNAL_ERROR_3);
}
return VINF_SUCCESS;
}
/**
* @interface_method_impl{PDMIMOUSEPORT, pfnPutEventMultiTouch}
*/
static DECLCALLBACK(int) ps2mPutEventMT(PPDMIMOUSEPORT pInterface, uint8_t cContacts,
const uint64_t *pau64Contacts, uint32_t u32ScanTime)
{
AssertFailedReturn(VERR_NOT_SUPPORTED);
NOREF(pInterface); NOREF(cContacts); NOREF(pau64Contacts); NOREF(u32ScanTime);
}
/**
* @interface_method_impl{PDMIMOUSEPORT, pfnPutEventAbs}
*/
static DECLCALLBACK(int) ps2mPutEventAbs(PPDMIMOUSEPORT pInterface, uint32_t x, uint32_t y,
int32_t dz, int32_t dw, uint32_t fButtons)
{
AssertFailedReturn(VERR_NOT_SUPPORTED);
NOREF(pInterface); NOREF(x); NOREF(y); NOREF(dz); NOREF(dw); NOREF(fButtons);
}
/**
* Calculate the size of one pixel
*/
uint32_t vmsvga3dSurfaceFormatSize(SVGA3dSurfaceFormat format)
{
switch (format)
{
case SVGA3D_X8R8G8B8:
case SVGA3D_A8R8G8B8:
return 4;
case SVGA3D_R5G6B5:
case SVGA3D_X1R5G5B5:
case SVGA3D_A1R5G5B5:
case SVGA3D_A4R4G4B4:
return 2;
case SVGA3D_Z_D32:
case SVGA3D_Z_D24S8:
case SVGA3D_Z_D24X8:
case SVGA3D_Z_DF24:
case SVGA3D_Z_D24S8_INT:
return 4;
case SVGA3D_Z_D16:
case SVGA3D_Z_DF16:
case SVGA3D_Z_D15S1:
return 2;
case SVGA3D_LUMINANCE8:
case SVGA3D_LUMINANCE4_ALPHA4:
return 1;
case SVGA3D_LUMINANCE16:
case SVGA3D_LUMINANCE8_ALPHA8:
return 2;
case SVGA3D_DXT1:
case SVGA3D_DXT2:
return 8;
case SVGA3D_DXT3:
case SVGA3D_DXT4:
case SVGA3D_DXT5:
return 16;
case SVGA3D_BUMPU8V8:
case SVGA3D_BUMPL6V5U5:
return 2;
case SVGA3D_BUMPX8L8V8U8:
case SVGA3D_Q8W8V8U8:
return 4;
case SVGA3D_V8U8:
case SVGA3D_CxV8U8:
return 2;
case SVGA3D_X8L8V8U8:
case SVGA3D_A2W10V10U10:
return 4;
case SVGA3D_ARGB_S10E5: /* 16-bit floating-point ARGB */
return 2;
case SVGA3D_ARGB_S23E8: /* 32-bit floating-point ARGB */
return 4;
case SVGA3D_A2R10G10B10:
return 4;
case SVGA3D_ALPHA8:
return 1;
case SVGA3D_R_S10E5:
return 2;
case SVGA3D_R_S23E8:
case SVGA3D_RG_S10E5:
return 4;
case SVGA3D_RG_S23E8:
return 8;
/*
* Any surface can be used as a buffer object, but SVGA3D_BUFFER is
* the most efficient format to use when creating new surfaces
* expressly for index or vertex data.
*/
case SVGA3D_BUFFER:
return 1;
case SVGA3D_NV12:
return 1;
case SVGA3D_V16U16:
return 4;
case SVGA3D_G16R16:
return 32;
case SVGA3D_A16B16G16R16:
return 8;
default:
AssertFailedReturn(4);
}
}
QList<UIChooserNode*> UIChooserNodeGlobal::nodes(UIChooserItemType enmType /* = UIChooserItemType_Any */) const
{
Q_UNUSED(enmType);
AssertFailedReturn(QList<UIChooserNode*>());
}
