/**
* Duplicates a line number structure.
*
* @returns Pointer to duplicate on success, NULL on failure.
*
* @param pLine The line number to duplicate.
*/
RTDECL(PRTDBGLINE) RTDbgLineDup(PCRTDBGLINE pLine)
{
return (PRTDBGLINE)RTMemDup(pLine, sizeof(*pLine));
}
STDMETHODIMP VBoxDnDDropTarget::Drop(IDataObject *pDataObject, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
RT_NOREF(pt);
AssertPtrReturn(pDataObject, E_INVALIDARG);
AssertPtrReturn(pdwEffect, E_INVALIDARG);
LogFlowFunc(("mFormatEtc.cfFormat=%RI16 (%s), pDataObject=0x%p, grfKeyState=0x%x, x=%ld, y=%ld\n",
mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat),
pDataObject, grfKeyState, pt.x, pt.y));
HRESULT hr = S_OK;
if (mFormatEtc.cfFormat) /* Did we get a supported format yet? */
{
/* Make sure the data object's data format is still valid. */
hr = pDataObject->QueryGetData(&mFormatEtc);
AssertMsg(SUCCEEDED(hr),
("Data format changed to invalid between DragEnter() and Drop(), cfFormat=%RI16 (%s), hr=%Rhrc\n",
mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat), hr));
}
int rc = VINF_SUCCESS;
if (SUCCEEDED(hr))
{
STGMEDIUM stgMed;
hr = pDataObject->GetData(&mFormatEtc, &stgMed);
if (SUCCEEDED(hr))
{
/*
* First stage: Prepare the access to the storage medium.
* For now we only support HGLOBAL stuff.
*/
PVOID pvData = NULL; /** @todo Put this in an own union? */
switch (mFormatEtc.tymed)
{
case TYMED_HGLOBAL:
pvData = GlobalLock(stgMed.hGlobal);
if (!pvData)
{
LogFlowFunc(("Locking HGLOBAL storage failed with %Rrc\n",
RTErrConvertFromWin32(GetLastError())));
rc = VERR_INVALID_HANDLE;
hr = E_INVALIDARG; /* Set special hr for OLE. */
}
break;
default:
AssertMsgFailed(("Storage medium type %RI32 supported\n",
mFormatEtc.tymed));
rc = VERR_NOT_SUPPORTED;
hr = DV_E_TYMED; /* Set special hr for OLE. */
break;
}
if (RT_SUCCESS(rc))
{
/*
* Second stage: Do the actual copying of the data object's data,
* based on the storage medium type.
*/
switch (mFormatEtc.cfFormat)
{
case CF_TEXT:
/* Fall through is intentional. */
case CF_UNICODETEXT:
{
AssertPtr(pvData);
size_t cbSize = GlobalSize(pvData);
LogFlowFunc(("CF_TEXT/CF_UNICODETEXT 0x%p got %zu bytes\n", pvData, cbSize));
if (cbSize)
{
char *pszText = NULL;
rc = mFormatEtc.cfFormat == CF_TEXT
/* ANSI codepage -> UTF-8 */
? RTStrCurrentCPToUtf8(&pszText, (char *)pvData)
/* Unicode -> UTF-8 */
: RTUtf16ToUtf8((PCRTUTF16)pvData, &pszText);
if (RT_SUCCESS(rc))
{
AssertPtr(pszText);
size_t cbText = strlen(pszText) + 1; /* Include termination. */
mpvData = RTMemDup((void *)pszText, cbText);
mcbData = cbText;
RTStrFree(pszText);
pszText = NULL;
}
}
break;
}
case CF_HDROP:
{
AssertPtr(pvData);
/* Convert to a string list, separated by \r\n. */
DROPFILES *pDropFiles = (DROPFILES *)pvData;
AssertPtr(pDropFiles);
bool fUnicode = RT_BOOL(pDropFiles->fWide);
/* Get the offset of the file list. */
Assert(pDropFiles->pFiles >= sizeof(DROPFILES));
/* Note: This is *not* pDropFiles->pFiles! DragQueryFile only
* will work with the plain storage medium pointer! */
HDROP hDrop = (HDROP)(pvData);
/* First, get the file count. */
/** @todo Does this work on Windows 2000 / NT4? */
char *pszFiles = NULL;
uint32_t cchFiles = 0;
UINT cFiles = DragQueryFile(hDrop, UINT32_MAX /* iFile */,
NULL /* lpszFile */, 0 /* cchFile */);
LogFlowFunc(("CF_HDROP got %RU16 file(s)\n", cFiles));
for (UINT i = 0; i < cFiles; i++)
{
UINT cch = DragQueryFile(hDrop, i /* File index */,
NULL /* Query size first */,
0 /* cchFile */);
Assert(cch);
if (RT_FAILURE(rc))
break;
char *pszFile = NULL; /* UTF-8 version. */
UINT cchFile = 0;
if (fUnicode)
{
/* Allocate enough space (including terminator). */
WCHAR *pwszFile = (WCHAR *)RTMemAlloc((cch + 1) * sizeof(WCHAR));
if (pwszFile)
{
cchFile = DragQueryFileW(hDrop, i /* File index */,
pwszFile, cch + 1 /* Include terminator */);
AssertMsg(cchFile == cch, ("cchCopied (%RU16) does not match cchFile (%RU16)\n",
cchFile, cch));
rc = RTUtf16ToUtf8(pwszFile, &pszFile);
AssertRC(rc);
RTMemFree(pwszFile);
}
else
rc = VERR_NO_MEMORY;
}
else /* ANSI */
{
/* Allocate enough space (including terminator). */
pszFile = (char *)RTMemAlloc((cch + 1) * sizeof(char));
if (pszFile)
{
cchFile = DragQueryFileA(hDrop, i /* File index */,
pszFile, cchFile + 1 /* Include terminator */);
AssertMsg(cchFile == cch, ("cchCopied (%RU16) does not match cchFile (%RU16)\n",
cchFile, cch));
}
else
rc = VERR_NO_MEMORY;
}
if (RT_SUCCESS(rc))
{
LogFlowFunc(("\tFile: %s (cchFile=%RU32)\n", pszFile, cchFile));
rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */,
pszFile, cchFile);
if (RT_SUCCESS(rc))
cchFiles += cchFile;
}
if (pszFile)
RTStrFree(pszFile);
if (RT_FAILURE(rc))
break;
/* Add separation between filenames.
* Note: Also do this for the last element of the list. */
rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */,
"\r\n", 2 /* Bytes */);
if (RT_SUCCESS(rc))
cchFiles += 2; /* Include \r\n */
}
if (RT_SUCCESS(rc))
{
cchFiles += 1; /* Add string termination. */
uint32_t cbFiles = cchFiles * sizeof(char);
LogFlowFunc(("cFiles=%u, cchFiles=%RU32, cbFiles=%RU32, pszFiles=0x%p\n",
cFiles, cchFiles, cbFiles, pszFiles));
/* Translate the list into URI elements. */
DnDURIList lstURI;
rc = lstURI.AppendNativePathsFromList(pszFiles, cbFiles,
DNDURILIST_FLAGS_ABSOLUTE_PATHS);
if (RT_SUCCESS(rc))
{
RTCString strRoot = lstURI.RootToString();
size_t cbRoot = strRoot.length() + 1; /* Include termination */
mpvData = RTMemAlloc(cbRoot);
if (mpvData)
{
memcpy(mpvData, strRoot.c_str(), cbRoot);
mcbData = cbRoot;
}
else
rc = VERR_NO_MEMORY;
}
}
LogFlowFunc(("Building CF_HDROP list rc=%Rrc, pszFiles=0x%p, cFiles=%RU16, cchFiles=%RU32\n",
rc, pszFiles, cFiles, cchFiles));
if (pszFiles)
RTStrFree(pszFiles);
break;
}
default:
/* Note: Should not happen due to the checks done in DragEnter(). */
AssertMsgFailed(("Format of type %RI16 (%s) not supported\n",
mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat)));
hr = DV_E_CLIPFORMAT; /* Set special hr for OLE. */
break;
}
/*
* Third stage: Unlock + release access to the storage medium again.
*/
switch (mFormatEtc.tymed)
{
case TYMED_HGLOBAL:
GlobalUnlock(stgMed.hGlobal);
break;
default:
AssertMsgFailed(("Really should not happen -- see init stage!\n"));
break;
}
}
/* Release storage medium again. */
ReleaseStgMedium(&stgMed);
/* Signal waiters. */
mDroppedRc = rc;
RTSemEventSignal(hEventDrop);
}
}
if (RT_SUCCESS(rc))
{
/* Note: pt is not used since we don't need to differentiate within our
* proxy window. */
*pdwEffect = VBoxDnDDropTarget::GetDropEffect(grfKeyState, *pdwEffect);
}
else
*pdwEffect = DROPEFFECT_NONE;
if (mpWndParent)
mpWndParent->hide();
LogFlowFunc(("Returning with hr=%Rhrc (%Rrc), mFormatEtc.cfFormat=%RI16 (%s), *pdwEffect=%RI32\n",
hr, rc, mFormatEtc.cfFormat, VBoxDnDDataObject::ClipboardFormatToString(mFormatEtc.cfFormat),
*pdwEffect));
return hr;
}
/**
* Duplicates a symbol structure.
*
* @returns Pointer to duplicate on success, NULL on failure.
*
* @param pSymInfo The symbol info to duplicate.
*/
RTDECL(PRTDBGSYMBOL) RTDbgSymbolDup(PCRTDBGSYMBOL pSymInfo)
{
return (PRTDBGSYMBOL)RTMemDup(pSymInfo, sizeof(*pSymInfo));
}
/**
* Registers a new shared module for the VM
*
* @returns VBox status code.
* @param pVM Pointer to the VM.
* @param enmGuestOS Guest OS type.
* @param pszModuleName Module name.
* @param pszVersion Module version.
* @param GCBaseAddr Module base address.
* @param cbModule Module size.
* @param cRegions Number of shared region descriptors.
* @param paRegions Shared region(s).
*
* @todo This should be a GMMR3 call. No need to involve GMM here.
*/
VMMR3DECL(int) PGMR3SharedModuleRegister(PVM pVM, VBOXOSFAMILY enmGuestOS, char *pszModuleName, char *pszVersion,
RTGCPTR GCBaseAddr, uint32_t cbModule, uint32_t cRegions,
VMMDEVSHAREDREGIONDESC const *paRegions)
{
Log(("PGMR3SharedModuleRegister family=%d name=%s version=%s base=%RGv size=%x cRegions=%d\n",
enmGuestOS, pszModuleName, pszVersion, GCBaseAddr, cbModule, cRegions));
/*
* Sanity check.
*/
AssertReturn(cRegions <= VMMDEVSHAREDREGIONDESC_MAX, VERR_INVALID_PARAMETER);
/*
* Allocate and initialize a GMM request.
*/
PGMMREGISTERSHAREDMODULEREQ pReq;
pReq = (PGMMREGISTERSHAREDMODULEREQ)RTMemAllocZ(RT_OFFSETOF(GMMREGISTERSHAREDMODULEREQ, aRegions[cRegions]));
AssertReturn(pReq, VERR_NO_MEMORY);
pReq->enmGuestOS = enmGuestOS;
pReq->GCBaseAddr = GCBaseAddr;
pReq->cbModule = cbModule;
pReq->cRegions = cRegions;
for (uint32_t i = 0; i < cRegions; i++)
pReq->aRegions[i] = paRegions[i];
int rc = RTStrCopy(pReq->szName, sizeof(pReq->szName), pszModuleName);
if (RT_SUCCESS(rc))
{
rc = RTStrCopy(pReq->szVersion, sizeof(pReq->szVersion), pszVersion);
if (RT_SUCCESS(rc))
{
/*
* Issue the request. In strict builds, do some local tracking.
*/
pgmR3PhysAssertSharedPageChecksums(pVM);
rc = GMMR3RegisterSharedModule(pVM, pReq);
if (RT_SUCCESS(rc))
rc = pReq->rc;
AssertMsg(rc == VINF_SUCCESS || rc == VINF_GMM_SHARED_MODULE_ALREADY_REGISTERED, ("%Rrc\n", rc));
# ifdef VBOX_STRICT
if ( rc == VINF_SUCCESS
&& g_cSharedModules < RT_ELEMENTS(g_apSharedModules))
{
unsigned i;
for (i = 0; i < RT_ELEMENTS(g_apSharedModules); i++)
if (g_apSharedModules[i] == NULL)
{
size_t const cbSharedModule = RT_OFFSETOF(GMMREGISTERSHAREDMODULEREQ, aRegions[cRegions]);
g_apSharedModules[i] = (PGMMREGISTERSHAREDMODULEREQ)RTMemDup(pReq, cbSharedModule);
g_cSharedModules++;
break;
}
Assert(i < RT_ELEMENTS(g_apSharedModules));
}
# endif /* VBOX_STRICT */
if (RT_SUCCESS(rc))
rc = VINF_SUCCESS;
}
}
RTMemFree(pReq);
return rc;
}
/* Synchronously obtain a standard USB descriptor for a device, used in order
* to grab configuration descriptors when we first add the device
*/
static void *GetStdDescSync(PUSBPROXYDEV pProxyDev, uint8_t iDescType, uint8_t iIdx, uint16_t LangId, uint16_t cbHint)
{
LogFlow(("GetStdDescSync: pProxyDev=%s\n", pProxyDev->pUsbIns->pszName));
for (;;)
{
/*
* Setup a MSG URB, queue and reap it.
*/
int rc = VINF_SUCCESS;
VUSBURB Urb;
AssertCompile(RT_SIZEOFMEMB(VUSBURB, abData) >= _4K);
Urb.u32Magic = VUSBURB_MAGIC;
Urb.enmState = VUSBURBSTATE_IN_FLIGHT;
Urb.pszDesc = (char*)"URB sync";
memset(&Urb.VUsb, 0, sizeof(Urb.VUsb));
memset(&Urb.Hci, 0, sizeof(Urb.Hci));
Urb.Dev.pvPrivate = NULL;
Urb.Dev.pNext = NULL;
Urb.pUsbIns = pProxyDev->pUsbIns;
Urb.DstAddress = 0;
Urb.EndPt = 0;
Urb.enmType = VUSBXFERTYPE_MSG;
Urb.enmDir = VUSBDIRECTION_IN;
Urb.fShortNotOk = false;
Urb.enmStatus = VUSBSTATUS_INVALID;
cbHint = RT_MIN(cbHint, sizeof(Urb.abData) - sizeof(VUSBSETUP));
Urb.cbData = cbHint + sizeof(VUSBSETUP);
PVUSBSETUP pSetup = (PVUSBSETUP)Urb.abData;
pSetup->bmRequestType = VUSB_DIR_TO_HOST | VUSB_REQ_STANDARD | VUSB_TO_DEVICE;
pSetup->bRequest = VUSB_REQ_GET_DESCRIPTOR;
pSetup->wValue = (iDescType << 8) | iIdx;
pSetup->wIndex = LangId;
pSetup->wLength = cbHint;
rc = pProxyDev->pOps->pfnUrbQueue(pProxyDev, &Urb);
if (RT_FAILURE(rc))
break;
/* Don't wait forever, it's just a simple request that should
return immediately. Since we're executing in the EMT thread
it's important not to get stuck here. (Some of the builtin
iMac devices may not refuse respond for instance.) */
PVUSBURB pUrbReaped = pProxyDev->pOps->pfnUrbReap(pProxyDev, 10000 /* ms */);
if (!pUrbReaped)
{
rc = pProxyDev->pOps->pfnUrbCancel(pProxyDev, &Urb);
AssertRC(rc);
/** @todo: This breaks the comment above... */
pUrbReaped = pProxyDev->pOps->pfnUrbReap(pProxyDev, RT_INDEFINITE_WAIT);
}
if (pUrbReaped != &Urb)
{
Log(("GetStdDescSync: pfnUrbReap failed, pUrbReaped=%p\n", pUrbReaped));
break;
}
if (Urb.enmStatus != VUSBSTATUS_OK)
{
Log(("GetStdDescSync: Urb.enmStatus=%d\n", Urb.enmStatus));
break;
}
/*
* Check the length, config descriptors have total_length field
*/
uint8_t *pbDesc = (uint8_t *)(pSetup + 1);
uint32_t cbDesc;
if (iDescType == VUSB_DT_CONFIG)
{
if (Urb.cbData < sizeof(VUSBSETUP) + 4)
{
Log(("GetStdDescSync: Urb.cbData=%#x (min 4)\n", Urb.cbData));
break;
}
cbDesc = RT_LE2H_U16(((uint16_t *)pbDesc)[1]);
}
else
{
if (Urb.cbData < sizeof(VUSBSETUP) + 1)
{
Log(("GetStdDescSync: Urb.cbData=%#x (min 1)\n", Urb.cbData));
break;
}
cbDesc = ((uint8_t *)pbDesc)[0];
}
Log(("GetStdDescSync: got Urb.cbData=%u, cbDesc=%u cbHint=%u\n", Urb.cbData, cbDesc, cbHint));
if ( Urb.cbData == cbHint + sizeof(VUSBSETUP)
&& cbDesc > Urb.cbData - sizeof(VUSBSETUP))
{
cbHint = cbDesc;
if (cbHint > sizeof(Urb.abData))
{
AssertMsgFailed(("cbHint=%u\n", cbHint));
break;
}
continue;
}
Assert(cbDesc <= Urb.cbData - sizeof(VUSBSETUP));
#ifdef LOG_ENABLED
vusbUrbTrace(&Urb, "GetStdDescSync", true);
#endif
/*
* Fine, we got everything return a heap duplicate of the descriptor.
*/
return RTMemDup(pbDesc, cbDesc);
}
return NULL;
}
RTDECL(int) RTEnvUnsetEx(RTENV Env, const char *pszVar)
{
AssertPtrReturn(pszVar, VERR_INVALID_POINTER);
AssertReturn(*pszVar, VERR_INVALID_PARAMETER);
AssertReturn(strchr(pszVar, '=') == NULL, VERR_ENV_INVALID_VAR_NAME);
int rc;
if (Env == RTENV_DEFAULT)
{
#ifdef RTENV_IMPLEMENTS_UTF8_DEFAULT_ENV_API
rc = RTEnvUnsetUtf8(pszVar);
#else
/*
* Since RTEnvUnset isn't UTF-8 clean and actually expects the strings
* to be in the current code page (codeset), we'll do the necessary
* conversions here.
*/
char *pszVarOtherCP;
rc = RTStrUtf8ToCurrentCP(&pszVarOtherCP, pszVar);
if (RT_SUCCESS(rc))
{
rc = RTEnvUnset(pszVarOtherCP);
RTStrFree(pszVarOtherCP);
}
#endif
}
else
{
PRTENVINTERNAL pIntEnv = Env;
AssertPtrReturn(pIntEnv, VERR_INVALID_HANDLE);
AssertReturn(pIntEnv->u32Magic == RTENV_MAGIC, VERR_INVALID_HANDLE);
RTENV_LOCK(pIntEnv);
/*
* Remove all variable by the given name.
*/
rc = VINF_ENV_VAR_NOT_FOUND;
const size_t cchVar = strlen(pszVar);
size_t iVar;
for (iVar = 0; iVar < pIntEnv->cVars; iVar++)
if ( !pIntEnv->pfnCompare(pIntEnv->papszEnv[iVar], pszVar, cchVar)
&& ( pIntEnv->papszEnv[iVar][cchVar] == '='
|| pIntEnv->papszEnv[iVar][cchVar] == '\0') )
{
if (!pIntEnv->fPutEnvBlock)
{
RTMemFree(pIntEnv->papszEnv[iVar]);
pIntEnv->cVars--;
if (pIntEnv->cVars > 0)
pIntEnv->papszEnv[iVar] = pIntEnv->papszEnv[pIntEnv->cVars];
pIntEnv->papszEnv[pIntEnv->cVars] = NULL;
}
else
{
/* Record this unset by keeping the variable without any equal sign. */
pIntEnv->papszEnv[iVar][cchVar] = '\0';
}
rc = VINF_SUCCESS;
/* no break, there could be more. */
}
/*
* If this is a change record, we may need to add it.
*/
if (rc == VINF_ENV_VAR_NOT_FOUND && pIntEnv->fPutEnvBlock)
{
char *pszEntry = (char *)RTMemDup(pszVar, cchVar + 1);
if (pszEntry)
{
rc = rtEnvIntAppend(pIntEnv, pszEntry);
if (RT_SUCCESS(rc))
rc = VINF_ENV_VAR_NOT_FOUND;
else
RTMemFree(pszEntry);
}
else
rc = VERR_NO_MEMORY;
}
RTENV_UNLOCK(pIntEnv);
}
return rc;
}
int cpumR3DbGetCpuInfo(const char *pszName, PCPUMINFO pInfo)
{
CPUMDBENTRY const *pEntry = NULL;
int rc;
if (!strcmp(pszName, "host"))
{
/*
* Create a CPU database entry for the host CPU. This means getting
* the CPUID bits from the real CPU and grabbing the closest matching
* database entry for MSRs.
*/
rc = CPUMR3CpuIdDetectUnknownLeafMethod(&pInfo->enmUnknownCpuIdMethod, &pInfo->DefCpuId);
if (RT_FAILURE(rc))
return rc;
rc = CPUMR3CpuIdCollectLeaves(&pInfo->paCpuIdLeavesR3, &pInfo->cCpuIdLeaves);
if (RT_FAILURE(rc))
return rc;
/* Lookup database entry for MSRs. */
CPUMCPUVENDOR const enmVendor = CPUMR3CpuIdDetectVendorEx(pInfo->paCpuIdLeavesR3[0].uEax,
pInfo->paCpuIdLeavesR3[0].uEbx,
pInfo->paCpuIdLeavesR3[0].uEcx,
pInfo->paCpuIdLeavesR3[0].uEdx);
uint32_t const uStd1Eax = pInfo->paCpuIdLeavesR3[1].uEax;
uint8_t const uFamily = ASMGetCpuFamily(uStd1Eax);
uint8_t const uModel = ASMGetCpuModel(uStd1Eax, enmVendor == CPUMCPUVENDOR_INTEL);
uint8_t const uStepping = ASMGetCpuStepping(uStd1Eax);
CPUMMICROARCH const enmMicroarch = CPUMR3CpuIdDetermineMicroarchEx(enmVendor, uFamily, uModel, uStepping);
for (unsigned i = 0; i < RT_ELEMENTS(g_apCpumDbEntries); i++)
{
CPUMDBENTRY const *pCur = g_apCpumDbEntries[i];
if ((CPUMCPUVENDOR)pCur->enmVendor == enmVendor)
{
/* Match against Family, Microarch, model and stepping. Except
for family, always match the closer with preference given to
the later/older ones. */
if (pCur->uFamily == uFamily)
{
if (pCur->enmMicroarch == enmMicroarch)
{
if (pCur->uModel == uModel)
{
if (pCur->uStepping == uStepping)
{
/* Perfect match. */
pEntry = pCur;
break;
}
if ( !pEntry
|| pEntry->uModel != uModel
|| pEntry->enmMicroarch != enmMicroarch
|| pEntry->uFamily != uFamily)
pEntry = pCur;
else if ( pCur->uStepping >= uStepping
? pCur->uStepping < pEntry->uStepping || pEntry->uStepping < uStepping
: pCur->uStepping > pEntry->uStepping)
pEntry = pCur;
}
else if ( !pEntry
|| pEntry->enmMicroarch != enmMicroarch
|| pEntry->uFamily != uFamily)
pEntry = pCur;
else if ( pCur->uModel >= uModel
? pCur->uModel < pEntry->uModel || pEntry->uModel < uModel
: pCur->uModel > pEntry->uModel)
pEntry = pCur;
}
else if ( !pEntry
|| pEntry->uFamily != uFamily)
pEntry = pCur;
/* Special march matching rules applies to intel family 06h. */
else if ( enmVendor == CPUMCPUVENDOR_INTEL
&& uFamily == 6
? cpumR3DbIsBetterIntelFam06Match(pCur->enmMicroarch, enmMicroarch, pEntry->enmMicroarch)
: cpumR3DbIsBetterMarchMatch(pCur->enmMicroarch, enmMicroarch, pEntry->enmMicroarch))
pEntry = pCur;
}
/* We don't do closeness matching on family, we use the first
entry for the CPU vendor instead. (P4 workaround.) */
else if (!pEntry)
pEntry = pCur;
}
}
if (pEntry)
LogRel(("CPUM: Matched host CPU %s %#x/%#x/%#x %s with CPU DB entry '%s' (%s %#x/%#x/%#x %s)\n",
CPUMR3CpuVendorName(enmVendor), uFamily, uModel, uStepping, CPUMR3MicroarchName(enmMicroarch),
pEntry->pszName, CPUMR3CpuVendorName((CPUMCPUVENDOR)pEntry->enmVendor), pEntry->uFamily, pEntry->uModel,
pEntry->uStepping, CPUMR3MicroarchName(pEntry->enmMicroarch) ));
else
{
pEntry = g_apCpumDbEntries[0];
LogRel(("CPUM: No matching processor database entry %s %#x/%#x/%#x %s, falling back on '%s'\n",
CPUMR3CpuVendorName(enmVendor), uFamily, uModel, uStepping, CPUMR3MicroarchName(enmMicroarch),
pEntry->pszName));
}
}
else
{
/*
* We're supposed to be emulating a specific CPU that is included in
* our CPU database. The CPUID tables needs to be copied onto the
* heap so the caller can modify them and so they can be freed like
* in the host case above.
*/
for (unsigned i = 0; i < RT_ELEMENTS(g_apCpumDbEntries); i++)
if (!strcmp(pszName, g_apCpumDbEntries[i]->pszName))
{
pEntry = g_apCpumDbEntries[i];
break;
}
if (!pEntry)
{
LogRel(("CPUM: Cannot locate any CPU by the name '%s'\n", pszName));
return VERR_CPUM_DB_CPU_NOT_FOUND;
}
pInfo->cCpuIdLeaves = pEntry->cCpuIdLeaves;
if (pEntry->cCpuIdLeaves)
{
pInfo->paCpuIdLeavesR3 = (PCPUMCPUIDLEAF)RTMemDup(pEntry->paCpuIdLeaves,
sizeof(pEntry->paCpuIdLeaves[0]) * pEntry->cCpuIdLeaves);
if (!pInfo->paCpuIdLeavesR3)
return VERR_NO_MEMORY;
}
else
pInfo->paCpuIdLeavesR3 = NULL;
pInfo->enmUnknownCpuIdMethod = pEntry->enmUnknownCpuId;
pInfo->DefCpuId = pEntry->DefUnknownCpuId;
LogRel(("CPUM: Using CPU DB entry '%s' (%s %#x/%#x/%#x %s)\n",
pEntry->pszName, CPUMR3CpuVendorName((CPUMCPUVENDOR)pEntry->enmVendor),
pEntry->uFamily, pEntry->uModel, pEntry->uStepping, CPUMR3MicroarchName(pEntry->enmMicroarch) ));
}
pInfo->fMsrMask = pEntry->fMsrMask;
pInfo->iFirstExtCpuIdLeaf = 0; /* Set by caller. */
pInfo->uPadding = 0;
pInfo->uScalableBusFreq = pEntry->uScalableBusFreq;
pInfo->paCpuIdLeavesR0 = NIL_RTR0PTR;
pInfo->paMsrRangesR0 = NIL_RTR0PTR;
pInfo->paCpuIdLeavesRC = NIL_RTRCPTR;
pInfo->paMsrRangesRC = NIL_RTRCPTR;
/*
* Copy the MSR range.
*/
uint32_t cMsrs = 0;
PCPUMMSRRANGE paMsrs = NULL;
PCCPUMMSRRANGE pCurMsr = pEntry->paMsrRanges;
uint32_t cLeft = pEntry->cMsrRanges;
while (cLeft-- > 0)
{
rc = cpumR3MsrRangesInsert(NULL /* pVM */, &paMsrs, &cMsrs, pCurMsr);
if (RT_FAILURE(rc))
{
Assert(!paMsrs); /* The above function frees this. */
RTMemFree(pInfo->paCpuIdLeavesR3);
pInfo->paCpuIdLeavesR3 = NULL;
return rc;
}
pCurMsr++;
}
pInfo->paMsrRangesR3 = paMsrs;
pInfo->cMsrRanges = cMsrs;
return VINF_SUCCESS;
}