本文整理汇总了C++中AssertReturn函数的典型用法代码示例。如果您正苦于以下问题:C++ AssertReturn函数的具体用法?C++ AssertReturn怎么用?C++ AssertReturn使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了AssertReturn函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: Elf64WriteNoteHdr
/**
* Elf function to write 64-bit note header.
*
* @param hFile The file to write to.
* @param Type Type of this section.
* @param pszName Name of this section.
* @param pcv Opaque pointer to the data, if NULL only computes size.
* @param cbData Size of the data.
*
* @return IPRT status code.
*/
static int Elf64WriteNoteHdr(RTFILE hFile, uint16_t Type, const char *pszName, const void *pcvData, uint64_t cbData)
{
AssertReturn(pcvData, VERR_INVALID_POINTER);
AssertReturn(cbData > 0, VERR_NO_DATA);
char szNoteName[s_cbNoteName];
RT_ZERO(szNoteName);
RTStrCopy(szNoteName, sizeof(szNoteName), pszName);
size_t cchName = strlen(szNoteName) + 1;
size_t cchNameAlign = RT_ALIGN_Z(cchName, s_NoteAlign);
uint64_t cbDataAlign = RT_ALIGN_64(cbData, s_NoteAlign);
/*
* Yell loudly and bail if we are going to be writing a core file that is not compatible with
* both Solaris and the 64-bit ELF spec. which dictates 8-byte alignment. See @bugref{5211} comment 3.
*/
if (cchNameAlign - cchName > 3)
{
LogRel((DBGFLOG_NAME ": Elf64WriteNoteHdr pszName=%s cchName=%u cchNameAlign=%u, cchName aligns to 4 not 8-bytes!\n", pszName, cchName,
cchNameAlign));
return VERR_INVALID_PARAMETER;
}
if (cbDataAlign - cbData > 3)
{
LogRel((DBGFLOG_NAME ": Elf64WriteNoteHdr pszName=%s cbData=%u cbDataAlign=%u, cbData aligns to 4 not 8-bytes!\n", pszName, cbData,
cbDataAlign));
return VERR_INVALID_PARAMETER;
}
static const char s_achPad[7] = { 0, 0, 0, 0, 0, 0, 0 };
AssertCompile(sizeof(s_achPad) >= s_NoteAlign - 1);
Elf64_Nhdr ElfNoteHdr;
RT_ZERO(ElfNoteHdr);
ElfNoteHdr.n_namesz = (Elf64_Word)cchName - 1; /* Again a discrepancy between ELF-64 and Solaris (@bugref{5211} comment 3), we will follow ELF-64 */
ElfNoteHdr.n_type = Type;
ElfNoteHdr.n_descsz = (Elf64_Word)cbDataAlign;
/*
* Write note header.
*/
int rc = RTFileWrite(hFile, &ElfNoteHdr, sizeof(ElfNoteHdr), NULL /* all */);
if (RT_SUCCESS(rc))
{
/*
* Write note name.
*/
rc = RTFileWrite(hFile, szNoteName, cchName, NULL /* all */);
if (RT_SUCCESS(rc))
{
/*
* Write note name padding if required.
*/
if (cchNameAlign > cchName)
rc = RTFileWrite(hFile, s_achPad, cchNameAlign - cchName, NULL);
if (RT_SUCCESS(rc))
{
/*
* Write note data.
*/
rc = RTFileWrite(hFile, pcvData, cbData, NULL /* all */);
if (RT_SUCCESS(rc))
{
/*
* Write note data padding if required.
*/
if (cbDataAlign > cbData)
rc = RTFileWrite(hFile, s_achPad, cbDataAlign - cbData, NULL /* all*/);
}
}
}
}
if (RT_FAILURE(rc))
LogRel((DBGFLOG_NAME ": RTFileWrite failed. rc=%Rrc pszName=%s cchName=%u cchNameAlign=%u cbData=%u cbDataAlign=%u\n",
rc, pszName, cchName, cchNameAlign, cbData, cbDataAlign));
return rc;
}
示例2: rtR0SemEventMultiHkuWait
/**
* Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventMultiWaitEx.
* @param uTimeout See RTSemEventMultiWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventMultiHkuWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
status_t status;
int rc;
int32 flags = 0;
bigtime_t timeout; /* in microseconds */
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
timeout = B_INFINITE_TIMEOUT;
else
{
if (fFlags & RTSEMWAIT_FLAGS_NANOSECS)
timeout = uTimeout / 1000;
else if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
timeout = uTimeout * 1000;
else
return VERR_INVALID_PARAMETER;
if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
flags |= B_RELATIVE_TIMEOUT;
else if (fFlags & RTSEMWAIT_FLAGS_ABSOLUTE)
flags |= B_ABSOLUTE_TIMEOUT;
else
return VERR_INVALID_PARAMETER;
}
if (fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE)
flags |= B_CAN_INTERRUPT;
// likely not:
//else
// flags |= B_KILL_CAN_INTERRUPT;
rtR0SemEventMultiHkuRetain(pThis);
status = acquire_sem_etc(pThis->SemId, 1, flags, timeout);
switch (status)
{
case B_OK:
rc = VINF_SUCCESS;
break;
case B_BAD_SEM_ID:
rc = VERR_SEM_DESTROYED;
break;
case B_INTERRUPTED:
rc = VERR_INTERRUPTED;
break;
case B_WOULD_BLOCK:
/* fallthrough? */
case B_TIMED_OUT:
rc = VERR_TIMEOUT;
break;
default:
rc = RTErrConvertFromHaikuKernReturn(status);
break;
}
rtR0SemEventMultiHkuRelease(pThis);
return rc;
}
示例3: foreach
bool UIWizardExportApp::exportVMs(CAppliance &appliance)
{
/* Get the map of the password IDs: */
EncryptedMediumMap encryptedMediums;
foreach (const QString &strPasswordId, appliance.GetPasswordIds())
foreach (const QString &strMediumId, appliance.GetMediumIdsForPasswordId(strPasswordId))
encryptedMediums.insert(strPasswordId, strMediumId);
/* Ask for the disk encryption passwords if necessary: */
if (!encryptedMediums.isEmpty())
{
/* Create corresponding dialog: */
QPointer<UIAddDiskEncryptionPasswordDialog> pDlg =
new UIAddDiskEncryptionPasswordDialog(this,
window()->windowTitle(),
encryptedMediums);
/* Execute the dialog: */
if (pDlg->exec() == QDialog::Accepted)
{
/* Acquire the passwords provided: */
const EncryptionPasswordMap encryptionPasswords = pDlg->encryptionPasswords();
/* Delete the dialog: */
delete pDlg;
/* Make sure the passwords were really provided: */
AssertReturn(!encryptionPasswords.isEmpty(), false);
/* Provide appliance with passwords if possible: */
appliance.AddPasswords(encryptionPasswords.keys().toVector(),
encryptionPasswords.values().toVector());
if (!appliance.isOk())
{
/* Warn the user about failure: */
msgCenter().cannotAddDiskEncryptionPassword(appliance);
return false;
}
}
else
{
/* Any modal dialog can be destroyed in own event-loop
* as a part of application termination procedure..
* We have to check if the dialog still valid. */
if (pDlg)
{
/* Delete the dialog: */
delete pDlg;
}
return false;
}
}
/* Write the appliance: */
QVector<KExportOptions> options;
if (field("manifestSelected").toBool())
options.append(KExportOptions_CreateManifest);
CProgress progress = appliance.Write(field("format").toString(), options, uri());
bool fResult = appliance.isOk();
if (fResult)
{
/* Show some progress, so the user know whats going on: */
msgCenter().showModalProgressDialog(progress, QApplication::translate("UIWizardExportApp", "Exporting Appliance ..."),
":/progress_export_90px.png", this);
if (progress.GetCanceled())
return false;
if (!progress.isOk() || progress.GetResultCode() != 0)
{
msgCenter().cannotExportAppliance(progress, appliance.GetPath(), this);
return false;
}
else
return true;
}
if (!fResult)
msgCenter().cannotExportAppliance(appliance, this);
return false;
}
示例4: rtR0SemEventLnxWait
/**
* Worker for RTSemEventWaitEx and RTSemEventWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventWaitEx.
* @param uTimeout See RTSemEventWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventLnxWait(PRTSEMEVENTINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
int rc;
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
rtR0SemEventLnxRetain(pThis);
/*
* Try grab the event without setting up the wait.
*/
if ( 1 /** @todo check if there are someone waiting already - waitqueue_active, but then what do we do below? */
&& ASMAtomicCmpXchgU32(&pThis->fState, 0, 1))
rc = VINF_SUCCESS;
else
{
/*
* We have to wait.
*/
IPRT_LINUX_SAVE_EFL_AC();
RTR0SEMLNXWAIT Wait;
rc = rtR0SemLnxWaitInit(&Wait, fFlags, uTimeout, &pThis->Head);
if (RT_SUCCESS(rc))
{
IPRT_DEBUG_SEMS_STATE(pThis, 'E');
for (;;)
{
/* The destruction test. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENT_MAGIC))
rc = VERR_SEM_DESTROYED;
else
{
rtR0SemLnxWaitPrepare(&Wait);
/* Check the exit conditions. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENT_MAGIC))
rc = VERR_SEM_DESTROYED;
else if (ASMAtomicCmpXchgU32(&pThis->fState, 0, 1))
rc = VINF_SUCCESS;
else if (rtR0SemLnxWaitHasTimedOut(&Wait))
rc = VERR_TIMEOUT;
else if (rtR0SemLnxWaitWasInterrupted(&Wait))
rc = VERR_INTERRUPTED;
else
{
/* Do the wait and then recheck the conditions. */
rtR0SemLnxWaitDoIt(&Wait);
continue;
}
}
break;
}
rtR0SemLnxWaitDelete(&Wait);
IPRT_DEBUG_SEMS_STATE_RC(pThis, 'E', rc);
}
IPRT_LINUX_RESTORE_EFL_AC();
}
rtR0SemEventLnxRelease(pThis);
return rc;
}
示例5: RTDECL
RTDECL(int) RTPowerNotificationRegister(PFNRTPOWERNOTIFICATION pfnCallback, void *pvUser)
{
PRTPOWERNOTIFYREG pCur;
PRTPOWERNOTIFYREG pNew;
RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
/*
* Validation.
*/
AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
AssertReturn(g_hRTPowerNotifySpinLock != NIL_RTSPINLOCK, VERR_WRONG_ORDER);
RT_ASSERT_PREEMPTIBLE();
RTSpinlockAcquire(g_hRTPowerNotifySpinLock, &Tmp);
for (pCur = g_pRTPowerCallbackHead; pCur; pCur = pCur->pNext)
if ( pCur->pvUser == pvUser
&& pCur->pfnCallback == pfnCallback)
break;
RTSpinlockRelease(g_hRTPowerNotifySpinLock, &Tmp);
AssertMsgReturn(!pCur, ("pCur=%p pfnCallback=%p pvUser=%p\n", pCur, pfnCallback, pvUser), VERR_ALREADY_EXISTS);
/*
* Allocate a new record and attempt to insert it.
*/
pNew = (PRTPOWERNOTIFYREG)RTMemAlloc(sizeof(*pNew));
if (!pNew)
return VERR_NO_MEMORY;
pNew->pNext = NULL;
pNew->pfnCallback = pfnCallback;
pNew->pvUser = pvUser;
memset(&pNew->bmDone[0], 0xff, sizeof(pNew->bmDone));
RTSpinlockAcquire(g_hRTPowerNotifySpinLock, &Tmp);
pCur = g_pRTPowerCallbackHead;
if (!pCur)
g_pRTPowerCallbackHead = pNew;
else
{
for (pCur = g_pRTPowerCallbackHead; ; pCur = pCur->pNext)
if ( pCur->pvUser == pvUser
&& pCur->pfnCallback == pfnCallback)
break;
else if (!pCur->pNext)
{
pCur->pNext = pNew;
pCur = NULL;
break;
}
}
ASMAtomicIncU32(&g_iRTPowerGeneration);
RTSpinlockRelease(g_hRTPowerNotifySpinLock, &Tmp);
/* duplicate? */
if (pCur)
{
RTMemFree(pCur);
AssertMsgFailedReturn(("pCur=%p pfnCallback=%p pvUser=%p\n", pCur, pfnCallback, pvUser), VERR_ALREADY_EXISTS);
}
return VINF_SUCCESS;
}
示例6: DECLCALLBACK
/**
* @callback_method_impl{FNDBGCOPUNARY, Reference register (unary).}
*/
DECLCALLBACK(int) dbgcOpRegister(PDBGC pDbgc, PCDBGCVAR pArg, DBGCVARCAT enmCat, PDBGCVAR pResult)
{
LogFlow(("dbgcOpRegister: %s\n", pArg->u.pszString));
AssertReturn(pArg->enmType == DBGCVAR_TYPE_SYMBOL, VERR_DBGC_PARSE_BUG);
/* Detect references to hypervisor registers. */
const char *pszReg = pArg->u.pszString;
VMCPUID idCpu = pDbgc->idCpu;
if (pszReg[0] == '.')
{
pszReg++;
idCpu |= DBGFREG_HYPER_VMCPUID;
}
/*
* If the desired result is a symbol, pass the argument along unmodified.
* This is a great help for "r @eax" and such, since it will be translated to "r eax".
*/
if (enmCat == DBGCVAR_CAT_SYMBOL)
{
int rc = DBGFR3RegNmValidate(pDbgc->pUVM, idCpu, pszReg);
if (RT_SUCCESS(rc))
DBGCVAR_INIT_STRING(pResult, pArg->u.pszString);
return rc;
}
/*
* Get the register.
*/
DBGFREGVALTYPE enmType;
DBGFREGVAL Value;
int rc = DBGFR3RegNmQuery(pDbgc->pUVM, idCpu, pszReg, &Value, &enmType);
if (RT_SUCCESS(rc))
{
switch (enmType)
{
case DBGFREGVALTYPE_U8:
DBGCVAR_INIT_NUMBER(pResult, Value.u8);
return VINF_SUCCESS;
case DBGFREGVALTYPE_U16:
DBGCVAR_INIT_NUMBER(pResult, Value.u16);
return VINF_SUCCESS;
case DBGFREGVALTYPE_U32:
DBGCVAR_INIT_NUMBER(pResult, Value.u32);
return VINF_SUCCESS;
case DBGFREGVALTYPE_U64:
DBGCVAR_INIT_NUMBER(pResult, Value.u64);
return VINF_SUCCESS;
case DBGFREGVALTYPE_U128:
DBGCVAR_INIT_NUMBER(pResult, Value.u128.s.Lo);
return VINF_SUCCESS;
case DBGFREGVALTYPE_R80:
#ifdef RT_COMPILER_WITH_80BIT_LONG_DOUBLE
DBGCVAR_INIT_NUMBER(pResult, (uint64_t)Value.r80Ex.lrd);
#else
DBGCVAR_INIT_NUMBER(pResult, (uint64_t)Value.r80Ex.sj64.u63Fraction);
#endif
return VINF_SUCCESS;
case DBGFREGVALTYPE_DTR:
DBGCVAR_INIT_NUMBER(pResult, Value.dtr.u64Base);
return VINF_SUCCESS;
case DBGFREGVALTYPE_INVALID:
case DBGFREGVALTYPE_END:
case DBGFREGVALTYPE_32BIT_HACK:
break;
}
rc = VERR_INTERNAL_ERROR_5;
}
return rc;
}
示例7: rtZipGzip_WriteOutputBuffer
/**
* Internal helper for rtZipGzip_Write, rtZipGzip_Flush and rtZipGzip_Close.
*
* @returns IPRT status code.
* @retval VINF_SUCCESS
* @retval VINF_TRY_AGAIN - the only informational status.
* @retval VERR_INTERRUPTED - call again.
*
* @param pThis The gzip I/O stream instance data.
* @param fBlocking Whether to block or not.
*/
static int rtZipGzip_WriteOutputBuffer(PRTZIPGZIPSTREAM pThis, bool fBlocking)
{
/*
* Anything to write? No, then just return immediately.
*/
size_t cbToWrite = sizeof(pThis->abBuffer) - pThis->Zlib.avail_out;
if (cbToWrite == 0)
{
Assert(pThis->Zlib.next_out == &pThis->abBuffer[0]);
return VINF_SUCCESS;
}
Assert(cbToWrite <= sizeof(pThis->abBuffer));
/*
* Loop write on VERR_INTERRUPTED.
*
* Note! Asserting a bit extra here to make sure the
* RTVfsIoStrmSgWrite works correctly.
*/
int rc;
size_t cbWrittenOut;
for (;;)
{
/* Set up the buffer. */
pThis->SgSeg.cbSeg = cbToWrite;
Assert(pThis->SgSeg.pvSeg == &pThis->abBuffer[0]);
RTSgBufReset(&pThis->SgBuf);
cbWrittenOut = ~(size_t)0;
rc = RTVfsIoStrmSgWrite(pThis->hVfsIos, &pThis->SgBuf, fBlocking, &cbWrittenOut);
if (rc != VINF_SUCCESS)
{
AssertMsg(RT_FAILURE(rc) || rc == VINF_TRY_AGAIN, ("%Rrc\n", rc));
if (rc == VERR_INTERRUPTED)
{
Assert(cbWrittenOut == 0);
continue;
}
if (RT_FAILURE(rc) || rc == VINF_TRY_AGAIN || cbWrittenOut == 0)
{
AssertReturn(cbWrittenOut == 0, VERR_INTERNAL_ERROR_3);
AssertReturn(rc != VINF_SUCCESS, VERR_IPE_UNEXPECTED_INFO_STATUS);
return rc;
}
}
break;
}
AssertMsgReturn(cbWrittenOut > 0 && cbWrittenOut <= sizeof(pThis->abBuffer),
("%zu %Rrc\n", cbWrittenOut, rc),
VERR_INTERNAL_ERROR_4);
/*
* Adjust the Zlib output buffer members.
*/
if (cbWrittenOut == pThis->SgBuf.paSegs[0].cbSeg)
{
pThis->Zlib.avail_out = sizeof(pThis->abBuffer);
pThis->Zlib.next_out = &pThis->abBuffer[0];
}
else
{
Assert(cbWrittenOut <= pThis->SgBuf.paSegs[0].cbSeg);
size_t cbLeft = pThis->SgBuf.paSegs[0].cbSeg - cbWrittenOut;
memmove(&pThis->abBuffer[0], &pThis->abBuffer[cbWrittenOut], cbLeft);
pThis->Zlib.avail_out += (uInt)cbWrittenOut;
pThis->Zlib.next_out = &pThis->abBuffer[cbWrittenOut];
}
return VINF_SUCCESS;
}
示例8: RTDECL
RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
{
int rc = VINF_SUCCESS;
/*
* Parameter validation.
*/
PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
RTFILEAIOCTX_VALID_RETURN(pCtxInt);
AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
uint32_t i = cReqs;
PRTFILEAIOREQINTERNAL pReqInt = NULL;
/*
* Validate requests and associate with the context.
*/
while (i-- > 0)
{
pReqInt = pahReqs[i];
if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
{
/* Undo everything and stop submitting. */
size_t iUndo = cReqs;
while (iUndo-- > i)
{
pReqInt = pahReqs[iUndo];
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
pReqInt->pCtxInt = NULL;
}
return VERR_INVALID_HANDLE;
}
pReqInt->AioContext = pCtxInt->AioContext;
pReqInt->pCtxInt = pCtxInt;
RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
}
do
{
/*
* We cast pahReqs to the Linux iocb structure to avoid copying the requests
* into a temporary array. This is possible because the iocb structure is
* the first element in the request structure (see PRTFILEAIOCTXINTERNAL).
*/
int cReqsSubmitted = 0;
rc = rtFileAsyncIoLinuxSubmit(pCtxInt->AioContext, cReqs,
(PLNXKAIOIOCB *)pahReqs,
&cReqsSubmitted);
if (RT_FAILURE(rc))
{
/*
* We encountered an error.
* This means that the first IoCB
* is not correctly initialized
* (invalid buffer alignment or bad file descriptor).
* Revert every request into the prepared state except
* the first one which will switch to completed.
* Another reason could be insufficient resources.
*/
i = cReqs;
while (i-- > 0)
{
/* Already validated. */
pReqInt = pahReqs[i];
pReqInt->pCtxInt = NULL;
pReqInt->AioContext = 0;
RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
}
if (rc == VERR_TRY_AGAIN)
return VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
else
{
/* The first request failed. */
pReqInt = pahReqs[0];
RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
pReqInt->Rc = rc;
pReqInt->cbTransfered = 0;
return rc;
}
}
/* Advance. */
cReqs -= cReqsSubmitted;
pahReqs += cReqsSubmitted;
ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmitted);
} while (cReqs);
return rc;
}
示例9: RTDECL
RTDECL(int) RTCrX509Certificate_VerifySignature(PCRTCRX509CERTIFICATE pThis, PCRTASN1OBJID pAlgorithm,
PCRTASN1DYNTYPE pParameters, PCRTASN1BITSTRING pPublicKey,
PRTERRINFO pErrInfo)
{
/*
* Validate the input a little.
*/
AssertPtrReturn(pThis, VERR_INVALID_POINTER);
AssertReturn(RTCrX509Certificate_IsPresent(pThis), VERR_INVALID_PARAMETER);
AssertPtrReturn(pAlgorithm, VERR_INVALID_POINTER);
AssertReturn(RTAsn1ObjId_IsPresent(pAlgorithm), VERR_INVALID_POINTER);
if (pParameters)
{
AssertPtrReturn(pParameters, VERR_INVALID_POINTER);
if (pParameters->enmType == RTASN1TYPE_NULL)
pParameters = NULL;
}
AssertPtrReturn(pPublicKey, VERR_INVALID_POINTER);
AssertReturn(RTAsn1BitString_IsPresent(pPublicKey), VERR_INVALID_POINTER);
/*
* Check if the algorithm matches.
*/
const char *pszCipherOid = RTCrPkixGetCiperOidFromSignatureAlgorithm(&pThis->SignatureAlgorithm.Algorithm);
if (!pszCipherOid)
return RTErrInfoSetF(pErrInfo, VERR_CR_X509_UNKNOWN_CERT_SIGN_ALGO,
"Certificate signature algorithm not known: %s",
pThis->SignatureAlgorithm.Algorithm.szObjId);
if (RTAsn1ObjId_CompareWithString(pAlgorithm, pszCipherOid) != 0)
return RTErrInfoSetF(pErrInfo, VERR_CR_X509_CERT_SIGN_ALGO_MISMATCH,
"Certificate signature cipher algorithm mismatch: cert uses %s (%s) while key uses %s",
pszCipherOid, pThis->SignatureAlgorithm.Algorithm.szObjId, pAlgorithm->szObjId);
/*
* Wrap up the public key.
*/
RTCRKEY hPubKey;
int rc = RTCrKeyCreateFromPublicAlgorithmAndBits(&hPubKey, pAlgorithm, pPublicKey, pErrInfo, NULL);
if (RT_FAILURE(rc))
return rc;
/*
* Here we should recode the to-be-signed part as DER, but we'll ASSUME
* that it's already in DER encoding and only does this if there the
* encoded bits are missing.
*/
if ( pThis->TbsCertificate.SeqCore.Asn1Core.uData.pu8
&& pThis->TbsCertificate.SeqCore.Asn1Core.cb > 0)
rc = RTCrPkixPubKeyVerifySignature(&pThis->SignatureAlgorithm.Algorithm, hPubKey, pParameters, &pThis->SignatureValue,
RTASN1CORE_GET_RAW_ASN1_PTR(&pThis->TbsCertificate.SeqCore.Asn1Core),
RTASN1CORE_GET_RAW_ASN1_SIZE(&pThis->TbsCertificate.SeqCore.Asn1Core),
pErrInfo);
else
{
uint32_t cbEncoded;
rc = RTAsn1EncodePrepare((PRTASN1CORE)&pThis->TbsCertificate.SeqCore.Asn1Core, RTASN1ENCODE_F_DER, &cbEncoded, pErrInfo);
if (RT_SUCCESS(rc))
{
void *pvTbsBits = RTMemTmpAlloc(cbEncoded);
if (pvTbsBits)
{
rc = RTAsn1EncodeToBuffer(&pThis->TbsCertificate.SeqCore.Asn1Core, RTASN1ENCODE_F_DER,
pvTbsBits, cbEncoded, pErrInfo);
if (RT_SUCCESS(rc))
rc = RTCrPkixPubKeyVerifySignature(&pThis->SignatureAlgorithm.Algorithm, hPubKey, pParameters,
&pThis->SignatureValue, pvTbsBits, cbEncoded, pErrInfo);
else
AssertRC(rc);
RTMemTmpFree(pvTbsBits);
}
else
rc = VERR_NO_TMP_MEMORY;
}
}
/* Free the public key. */
uint32_t cRefs = RTCrKeyRelease(hPubKey);
Assert(cRefs == 0); NOREF(cRefs);
return rc;
}
示例10: rtCrPkcs7VerifySignerInfoAuthAttribs
/**
* Deals with authenticated attributes.
*
* When authenticated attributes are present (checked by caller) we must:
* - fish out the content type and check it against the content inof,
* - fish out the message digest among and check it against *phDigest,
* - compute the message digest of the authenticated attributes and
* replace *phDigest with this for the signature verification.
*
* @returns IPRT status code.
* @param pSignerInfo The signer info being verified.
* @param pSignedData The signed data.
* @param phDigest On input this is the digest of the content. On
* output it will (on success) be a reference to
* the message digest of the authenticated
* attributes. The input reference is consumed.
* The caller shall release the output reference.
* @param fFlags Flags.
* @param pErrInfo Extended error info, optional.
*/
static int rtCrPkcs7VerifySignerInfoAuthAttribs(PCRTCRPKCS7SIGNERINFO pSignerInfo, PCRTCRPKCS7SIGNEDDATA pSignedData,
PRTCRDIGEST phDigest, uint32_t fFlags, PRTERRINFO pErrInfo)
{
/*
* Scan the attributes and validate the two required attributes
* (RFC-2315, chapter 9.2, fourth bullet). Checking that we've got exactly
* one of each of them is checked by the santiy checker function, so we'll
* just assert that it did it's job here.
*/
uint32_t cContentTypes = 0;
uint32_t cMessageDigests = 0;
uint32_t i = pSignerInfo->AuthenticatedAttributes.cItems;
while (i-- > 0)
{
PCRTCRPKCS7ATTRIBUTE pAttrib = &pSignerInfo->AuthenticatedAttributes.paItems[i];
if (RTAsn1ObjId_CompareWithString(&pAttrib->Type, RTCR_PKCS9_ID_CONTENT_TYPE_OID) == 0)
{
AssertReturn(!cContentTypes, VERR_CR_PKCS7_INTERNAL_ERROR);
AssertReturn(pAttrib->enmType == RTCRPKCS7ATTRIBUTETYPE_OBJ_IDS, VERR_CR_PKCS7_INTERNAL_ERROR);
AssertReturn(pAttrib->uValues.pObjIds->cItems == 1, VERR_CR_PKCS7_INTERNAL_ERROR);
if ( !(fFlags & RTCRPKCS7VERIFY_SD_F_COUNTER_SIGNATURE) /* See note about microsoft below. */
&& RTAsn1ObjId_Compare(&pAttrib->uValues.pObjIds->paItems[0], &pSignedData->ContentInfo.ContentType) != 0)
return RTErrInfoSetF(pErrInfo, VERR_CR_PKCS7_CONTENT_TYPE_ATTRIB_MISMATCH,
"Expected content-type %s, found %s",
&pAttrib->uValues.pObjIds->paItems[0], pSignedData->ContentInfo.ContentType.szObjId);
cContentTypes++;
}
else if (RTAsn1ObjId_CompareWithString(&pAttrib->Type, RTCR_PKCS9_ID_MESSAGE_DIGEST_OID) == 0)
{
AssertReturn(!cMessageDigests, VERR_CR_PKCS7_INTERNAL_ERROR);
AssertReturn(pAttrib->enmType == RTCRPKCS7ATTRIBUTETYPE_OCTET_STRINGS, VERR_CR_PKCS7_INTERNAL_ERROR);
AssertReturn(pAttrib->uValues.pOctetStrings->cItems == 1, VERR_CR_PKCS7_INTERNAL_ERROR);
if (!RTCrDigestMatch(*phDigest,
pAttrib->uValues.pOctetStrings->paItems[0].Asn1Core.uData.pv,
pAttrib->uValues.pOctetStrings->paItems[0].Asn1Core.cb))
{
size_t cbHash = RTCrDigestGetHashSize(*phDigest);
if (cbHash != pAttrib->uValues.pOctetStrings->paItems[0].Asn1Core.cb)
return RTErrInfoSetF(pErrInfo, VERR_CR_PKCS7_MESSAGE_DIGEST_ATTRIB_MISMATCH,
"Authenticated message-digest attribute mismatch: cbHash=%#zx cbValue=%#x",
cbHash, pAttrib->uValues.pOctetStrings->paItems[0].Asn1Core.cb);
return RTErrInfoSetF(pErrInfo, VERR_CR_PKCS7_MESSAGE_DIGEST_ATTRIB_MISMATCH,
"Authenticated message-digest attribute mismatch (cbHash=%#zx):\n"
"signed: %.*Rhxs\n"
"our: %.*Rhxs\n",
cbHash,
cbHash, pAttrib->uValues.pOctetStrings->paItems[0].Asn1Core.uData.pv,
cbHash, RTCrDigestGetHash(*phDigest));
}
cMessageDigests++;
}
}
/*
* Full error reporting here as we don't currently extensively santiy check
* counter signatures.
* Note! Microsoft includes content info in their timestamp counter signatures,
* at least for vista, despite the RFC-3852 stating counter signatures
* "MUST NOT contain a content-type".
*/
if (RT_UNLIKELY( cContentTypes != 1
&& !(fFlags & RTCRPKCS7VERIFY_SD_F_COUNTER_SIGNATURE)))
return RTErrInfoSet(pErrInfo, VERR_CR_PKCS7_MISSING_CONTENT_TYPE_ATTRIB,
"Missing authenticated content-type attribute.");
if (RT_UNLIKELY(cMessageDigests != 1))
return RTErrInfoSet(pErrInfo, VERR_CR_PKCS7_MISSING_MESSAGE_DIGEST_ATTRIB,
"Missing authenticated message-digest attribute.");
/*
* Calculate the digest of the the authenticated attributes for use in the
* signature validation.
*/
if ( pSignerInfo->DigestAlgorithm.Parameters.enmType != RTASN1TYPE_NULL
&& pSignerInfo->DigestAlgorithm.Parameters.enmType != RTASN1TYPE_NOT_PRESENT)
return RTErrInfoSet(pErrInfo, VERR_CR_PKCS7_DIGEST_PARAMS_NOT_IMPL, "Digest algorithm has unsupported parameters");
RTCRDIGEST hDigest;
//.........这里部分代码省略.........
示例11: LogFlowThisFunc
/**
* Initializes a file object but does *not* open the file on the guest
* yet. This is done in the dedidcated openFile call.
*
* @return IPRT status code.
* @param pConsole Pointer to console object.
* @param pSession Pointer to session object.
* @param uFileID Host-based file ID (part of the context ID).
* @param openInfo File opening information.
*/
int GuestFile::init(Console *pConsole, GuestSession *pSession,
ULONG uFileID, const GuestFileOpenInfo &openInfo)
{
LogFlowThisFunc(("pConsole=%p, pSession=%p, uFileID=%RU32, strPath=%s\n",
pConsole, pSession, uFileID, openInfo.mFileName.c_str()));
AssertPtrReturn(pConsole, VERR_INVALID_POINTER);
AssertPtrReturn(pSession, VERR_INVALID_POINTER);
/* Enclose the state transition NotReady->InInit->Ready. */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
int vrc = bindToSession(pConsole, pSession, uFileID /* Object ID */);
if (RT_SUCCESS(vrc))
{
mSession = pSession;
mData.mID = uFileID;
mData.mInitialSize = 0;
mData.mStatus = FileStatus_Undefined;
mData.mOpenInfo = openInfo;
unconst(mEventSource).createObject();
HRESULT hr = mEventSource->init();
if (FAILED(hr))
vrc = VERR_COM_UNEXPECTED;
}
if (RT_SUCCESS(vrc))
{
try
{
GuestFileListener *pListener = new GuestFileListener();
ComObjPtr<GuestFileListenerImpl> thisListener;
HRESULT hr = thisListener.createObject();
if (SUCCEEDED(hr))
hr = thisListener->init(pListener, this);
if (SUCCEEDED(hr))
{
com::SafeArray <VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
eventTypes.push_back(VBoxEventType_OnGuestFileOffsetChanged);
eventTypes.push_back(VBoxEventType_OnGuestFileRead);
eventTypes.push_back(VBoxEventType_OnGuestFileWrite);
hr = mEventSource->RegisterListener(thisListener,
ComSafeArrayAsInParam(eventTypes),
TRUE /* Active listener */);
if (SUCCEEDED(hr))
{
vrc = baseInit();
if (RT_SUCCESS(vrc))
{
mLocalListener = thisListener;
}
}
else
vrc = VERR_COM_UNEXPECTED;
}
else
vrc = VERR_COM_UNEXPECTED;
}
catch(std::bad_alloc &)
{
vrc = VERR_NO_MEMORY;
}
}
if (RT_SUCCESS(vrc))
{
/* Confirm a successful initialization when it's the case. */
autoInitSpan.setSucceeded();
}
else
autoInitSpan.setFailed();
LogFlowFuncLeaveRC(vrc);
return vrc;
}
示例12: LogFlowThisFuncEnter
STDMETHODIMP Session::AssignRemoteMachine(IMachine *aMachine, IConsole *aConsole)
{
LogFlowThisFuncEnter();
LogFlowThisFunc(("aMachine=%p, aConsole=%p\n", aMachine, aConsole));
AssertReturn(aMachine && aConsole, E_INVALIDARG);
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
AssertReturn(mState == SessionState_Unlocked ||
mState == SessionState_Spawning, VBOX_E_INVALID_VM_STATE);
HRESULT rc = E_FAIL;
/* query IInternalMachineControl interface */
mControl = aMachine;
AssertReturn(!!mControl, E_FAIL);
/// @todo (dmik)
// currently, the remote session returns the same machine and
// console objects as the direct session, thus giving the
// (remote) client full control over the direct session. For the
// console, it is the desired behavior (the ability to control
// VM execution is a must for the remote session). What about
// the machine object, we may want to prevent the remote client
// from modifying machine data. In this case, we must:
// 1) assign the Machine object (instead of the SessionMachine
// object that is passed to this method) to mRemoteMachine;
// 2) remove GetMachine() property from the IConsole interface
// because it always returns the SessionMachine object
// (alternatively, we can supply a separate IConsole
// implementation that will return the Machine object in
// response to GetMachine()).
mRemoteMachine = aMachine;
mRemoteConsole = aConsole;
/*
* Reference the VirtualBox object to ensure the server is up
* until the session is closed
*/
rc = aMachine->COMGETTER(Parent)(mVirtualBox.asOutParam());
if (SUCCEEDED(rc))
{
/*
* RemoteSession type can be already set by AssignMachine() when its
* argument is NULL (a special case)
*/
if (mType != SessionType_Remote)
mType = SessionType_Shared;
else
Assert(mState == SessionState_Spawning);
mState = SessionState_Locked;
}
else
{
/* some cleanup */
mControl.setNull();
mRemoteMachine.setNull();
mRemoteConsole.setNull();
}
LogFlowThisFunc(("rc=%08X\n", rc));
LogFlowThisFuncLeave();
return rc;
}
示例13: LogFlowThisFuncLeave
/* return a failure if the session already transitioned to Closing
* but the server hasn't processed Machine::OnSessionEnd() yet. */
if (mState != SessionState_Locked)
return VBOX_E_INVALID_VM_STATE;
mConsole.queryInterfaceTo(aConsole);
LogFlowThisFuncLeave();
return S_OK;
#else /* VBOX_COM_INPROC_API_CLIENT */
AssertFailed();
return VBOX_E_INVALID_OBJECT_STATE;
#endif /* VBOX_COM_INPROC_API_CLIENT */
}
#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
STDMETHODIMP Session::AssignMachine(IMachine *aMachine, LockType_T aLockType,
IN_BSTR aTokenId)
#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
STDMETHODIMP Session::AssignMachine(IMachine *aMachine, LockType_T aLockType,
IToken *aToken)
#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
{
LogFlowThisFuncEnter();
LogFlowThisFunc(("aMachine=%p\n", aMachine));
AutoCaller autoCaller(this);
AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
AssertReturn(mState == SessionState_Unlocked, VBOX_E_INVALID_VM_STATE);
if (!aMachine)
{
/*
* A special case: the server informs us that this session has been
* passed to IMachine::launchVMProcess() so this session will become
* remote (but not existing) when AssignRemoteMachine() is called.
*/
AssertReturn(mType == SessionType_Null, VBOX_E_INVALID_OBJECT_STATE);
mType = SessionType_Remote;
mState = SessionState_Spawning;
LogFlowThisFuncLeave();
return S_OK;
}
/* query IInternalMachineControl interface */
mControl = aMachine;
AssertReturn(!!mControl, E_FAIL);
#ifndef VBOX_COM_INPROC_API_CLIENT
HRESULT rc = mConsole.createObject();
AssertComRCReturn(rc, rc);
rc = mConsole->init(aMachine, mControl, aLockType);
AssertComRCReturn(rc, rc);
#else
HRESULT rc = S_OK;
mRemoteMachine = aMachine;
#endif
#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
Utf8Str strTokenId(aTokenId);
Assert(!strTokenId.isEmpty());
#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
AssertPtr(aToken);
#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
/* create the machine client token */
try
{
#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
mClientTokenHolder = new ClientTokenHolder(strTokenId);
#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
mClientTokenHolder = new ClientTokenHolder(aToken);
#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
if (!mClientTokenHolder->isReady())
{
delete mClientTokenHolder;
mClientTokenHolder = NULL;
rc = E_FAIL;
}
}
catch (std::bad_alloc &)
{
rc = E_OUTOFMEMORY;
}
/*
* Reference the VirtualBox object to ensure the server is up
* until the session is closed
*/
if (SUCCEEDED(rc))
rc = aMachine->COMGETTER(Parent)(mVirtualBox.asOutParam());
if (SUCCEEDED(rc))
//.........这里部分代码省略.........
示例14: vbclClipboardGetAvailableFormats
/**
* Walk through pasteboard items and report currently available item types.
*
* @param pPasteboard Reference to guest Pasteboard.
* @returns Available formats bit field.
*/
uint32_t vbclClipboardGetAvailableFormats(PasteboardRef pPasteboard)
{
uint32_t fFormats = 0;
ItemCount cItems = 0;
ItemCount iItem;
OSStatus rc;
#define VBOXCL_ADD_FORMAT_IF_PRESENT(a_kDarwinFmt, a_fVBoxFmt) \
if (PasteboardCopyItemFlavorData(pPasteboard, iItemID, a_kDarwinFmt, &flavorData) == noErr) \
{ \
fFormats |= (uint32_t)a_fVBoxFmt; \
CFRelease(flavorData); \
}
rc = PasteboardGetItemCount(pPasteboard, &cItems);
AssertReturn((rc == noErr) && (cItems > 0), fFormats);
for (iItem = 1; iItem <= cItems; iItem++)
{
PasteboardItemID iItemID;
CFDataRef flavorData;
rc = PasteboardGetItemIdentifier(pPasteboard, iItem, &iItemID);
if (rc == noErr)
{
VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeUTF16PlainText, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeUTF8PlainText, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeBMP, VBOX_SHARED_CLIPBOARD_FMT_BITMAP );
VBOXCL_ADD_FORMAT_IF_PRESENT(kUTTypeHTML, VBOX_SHARED_CLIPBOARD_FMT_HTML );
#ifdef CLIPBOARD_DUMP_CONTENT_FORMATS
CFArrayRef flavorTypeArray;
CFIndex flavorCount;
CFStringRef flavorType;
rc = PasteboardCopyItemFlavors(pPasteboard, iItemID, &flavorTypeArray);
if (rc == noErr)
{
VBoxClientVerbose(3, "SCAN..\n");
flavorCount = CFArrayGetCount(flavorTypeArray);
VBoxClientVerbose(3, "SCAN (%d)..\n", (int)flavorCount);
for(CFIndex flavorIndex = 0; flavorIndex < flavorCount; flavorIndex++)
{
VBoxClientVerbose(3, "SCAN #%d..\n", (int)flavorIndex);
flavorType = (CFStringRef)CFArrayGetValueAtIndex(flavorTypeArray, flavorIndex);
CFDataRef flavorData1;
rc = PasteboardCopyItemFlavorData(pPasteboard, iItemID, flavorType, &flavorData1);
if (rc == noErr)
{
VBoxClientVerbose(3, "Found: %s, size: %d\n", (char *)CFStringGetCStringPtr(flavorType, kCFStringEncodingMacRoman), (int)CFDataGetLength(flavorData1));
CFRelease(flavorData1);
}
}
VBoxClientVerbose(3, "SCAN COMPLETE\n");
CFRelease(flavorTypeArray);
}
#endif /* CLIPBOARD_DUMP_CONTENT_FORMATS */
}
}
#undef VBOXCL_ADD_FORMAT_IF_PRESENT
return fFormats;
}
示例15: RTDECL
RTDECL(int) RTMpOnPair(RTCPUID idCpu1, RTCPUID idCpu2, uint32_t fFlags, PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2)
{
IPRT_LINUX_SAVE_EFL_AC();
int rc;
RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
AssertReturn(idCpu1 != idCpu2, VERR_INVALID_PARAMETER);
AssertReturn(!(fFlags & RTMPON_F_VALID_MASK), VERR_INVALID_FLAGS);
/*
* Check that both CPUs are online before doing the broadcast call.
*/
RTThreadPreemptDisable(&PreemptState);
if ( RTMpIsCpuOnline(idCpu1)
&& RTMpIsCpuOnline(idCpu2))
{
/*
* Use the smp_call_function variant taking a cpu mask where available,
* falling back on broadcast with filter. Slight snag if one of the
* CPUs is the one we're running on, we must do the call and the post
* call wait ourselves.
*/
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
cpumask_t DstCpuMask;
#endif
RTCPUID idCpuSelf = RTMpCpuId();
bool const fCallSelf = idCpuSelf == idCpu1 || idCpuSelf == idCpu2;
RTMPARGS Args;
Args.pfnWorker = pfnWorker;
Args.pvUser1 = pvUser1;
Args.pvUser2 = pvUser2;
Args.idCpu = idCpu1;
Args.idCpu2 = idCpu2;
Args.cHits = 0;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
cpumask_clear(&DstCpuMask);
cpumask_set_cpu(idCpu1, &DstCpuMask);
cpumask_set_cpu(idCpu2, &DstCpuMask);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
cpus_clear(DstCpuMask);
cpu_set(idCpu1, DstCpuMask);
cpu_set(idCpu2, DstCpuMask);
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
smp_call_function_many(&DstCpuMask, rtmpLinuxWrapperPostInc, &Args, !fCallSelf /* wait */);
rc = 0;
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
rc = smp_call_function_mask(DstCpuMask, rtmpLinuxWrapperPostInc, &Args, !fCallSelf /* wait */);
#else /* older kernels */
rc = smp_call_function(rtMpLinuxOnPairWrapper, &Args, 0 /* retry */, !fCallSelf /* wait */);
#endif /* older kernels */
Assert(rc == 0);
/* Call ourselves if necessary and wait for the other party to be done. */
if (fCallSelf)
{
uint32_t cLoops = 0;
rtmpLinuxWrapper(&Args);
while (ASMAtomicReadU32(&Args.cHits) < 2)
{
if ((cLoops & 0x1ff) == 0 && !RTMpIsCpuOnline(idCpuSelf == idCpu1 ? idCpu2 : idCpu1))
break;
cLoops++;
ASMNopPause();
}
}
Assert(Args.cHits <= 2);
if (Args.cHits == 2)
rc = VINF_SUCCESS;
else if (Args.cHits == 1)
rc = VERR_NOT_ALL_CPUS_SHOWED;
else if (Args.cHits == 0)
rc = VERR_CPU_OFFLINE;
else
rc = VERR_CPU_IPE_1;
}
/*
* A CPU must be present to be considered just offline.
*/
else if ( RTMpIsCpuPresent(idCpu1)
&& RTMpIsCpuPresent(idCpu2))
rc = VERR_CPU_OFFLINE;
else
rc = VERR_CPU_NOT_FOUND;
RTThreadPreemptRestore(&PreemptState);;
IPRT_LINUX_RESTORE_EFL_AC();
return rc;
}