VirtualBox::ClientWatcher::ClientWatcher(const ComObjPtr<VirtualBox> &pVirtualBox) :
mVirtualBox(pVirtualBox),
mThread(NIL_RTTHREAD),
mUpdateReq(CWUPDATEREQARG),
mLock(LOCKCLASS_OBJECTSTATE)
{
#if defined(RT_OS_WINDOWS)
mUpdateReq = ::CreateEvent(NULL, FALSE, FALSE, NULL);
#elif defined(RT_OS_OS2)
RTSemEventCreate(&mUpdateReq);
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER) || defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
RTSemEventCreate(&mUpdateReq);
/* start with high timeouts, nothing to do */
ASMAtomicUoWriteU8(&mUpdateAdaptCtr, 0);
#else
# error "Port me!"
#endif
int vrc = RTThreadCreate(&mThread,
worker,
(void *)this,
0,
RTTHREADTYPE_MAIN_WORKER,
RTTHREADFLAGS_WAITABLE,
"Watcher");
AssertRC(vrc);
}
/**
* Initializes the object (called right after construction).
*
* @returns VBox status code.
*/
int USBProxyBackendSolaris::init(USBProxyService *aUsbProxyService, const com::Utf8Str &strId, const com::Utf8Str &strAddress)
{
USBProxyBackend::init(aUsbProxyService, strId, strAddress);
unconst(m_strBackend) = Utf8Str("host");
/*
* Create semaphore.
*/
int rc = RTSemEventCreate(&mNotifyEventSem);
if (RT_FAILURE(rc))
return rc;
/*
* Initialize the USB library.
*/
rc = USBLibInit();
if (RT_FAILURE(rc))
{
/* mNotifyEventSem will be destroyed in uninit */
return rc;
}
mUSBLibInitialized = true;
/*
* Start the poller thread.
*/
start();
return VINF_SUCCESS;
}
/**
* Initializes the object (called right after construction).
*
* @returns S_OK on success and non-fatal failures, some COM error otherwise.
*/
HRESULT USBProxyServiceSolaris::init(void)
{
/*
* Create semaphore.
*/
int rc = RTSemEventCreate(&mNotifyEventSem);
if (RT_FAILURE(rc))
{
mLastError = rc;
return E_FAIL;
}
/*
* Initialize the USB library.
*/
rc = USBLibInit();
if (RT_FAILURE(rc))
{
mLastError = rc;
return S_OK;
}
mUSBLibInitialized = true;
/*
* Start the poller thread.
*/
start();
return S_OK;
}
/**
* Initializes the object (called right after construction).
*
* @returns VBox status code.
*/
int USBProxyBackendSolaris::init(void)
{
/*
* Create semaphore.
*/
int rc = RTSemEventCreate(&mNotifyEventSem);
if (RT_FAILURE(rc))
return rc;
/*
* Initialize the USB library.
*/
rc = USBLibInit();
if (RT_FAILURE(rc))
{
RTSemEventDestroy(mNotifyEventSem);
return rc;
}
mUSBLibInitialized = true;
/*
* Start the poller thread.
*/
start();
return VINF_SUCCESS;
}
SUPDECL(int) SUPSemEventCreate(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent)
{
int rc;
RTSEMEVENT hEventReal;
/*
* Input validation.
*/
AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
AssertPtrReturn(phEvent, VERR_INVALID_POINTER);
/*
* Create the event semaphore object.
*/
rc = RTSemEventCreate(&hEventReal);
if (RT_SUCCESS(rc))
{
void *pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_SEM_EVENT, supR0SemEventDestructor, hEventReal, NULL);
if (pvObj)
{
uint32_t h32;
rc = RTHandleTableAllocWithCtx(pSession->hHandleTable, pvObj, SUPDRV_HANDLE_CTX_EVENT, &h32);
if (RT_SUCCESS(rc))
{
*phEvent = (SUPSEMEVENT)(uintptr_t)h32;
return VINF_SUCCESS;
}
SUPR0ObjRelease(pvObj, pSession);
}
else
RTSemEventDestroy(hEventReal);
}
return rc;
}
/**
* Allocate a new request from the heap.
*
* @returns IPRT status code.
* @param enmType The reques type.
* @param fPoolOrQueue The owner type.
* @param pvOwner The owner.
* @param phReq Where to return the request handle.
*/
DECLHIDDEN(int) rtReqAlloc(RTREQTYPE enmType, bool fPoolOrQueue, void *pvOwner, PRTREQ *phReq)
{
PRTREQ pReq = (PRTREQ)RTMemAllocZ(sizeof(*pReq));
if (RT_UNLIKELY(!pReq))
return VERR_NO_MEMORY;
/*
* Create the semaphore used for waiting.
*/
int rc = RTSemEventCreate(&pReq->EventSem);
AssertRCReturnStmt(rc, RTMemFree(pReq), rc);
/*
* Initialize the packet and return it.
*/
pReq->u32Magic = RTREQ_MAGIC;
pReq->fEventSemClear = true;
pReq->fSignalPushBack = true;
pReq->fPoolOrQueue = fPoolOrQueue;
pReq->iStatusX = VERR_RT_REQUEST_STATUS_STILL_PENDING;
pReq->enmState = RTREQSTATE_ALLOCATED;
pReq->pNext = NULL;
pReq->uOwner.pv = pvOwner;
pReq->fFlags = RTREQFLAGS_IPRT_STATUS;
pReq->enmType = enmType;
pReq->cRefs = 1;
*phReq = pReq;
return VINF_SUCCESS;
}
HRESULT HostDnsServiceDarwin::init()
{
SCDynamicStoreContext ctx;
RT_ZERO(ctx);
ctx.info = this;
m->m_store = SCDynamicStoreCreate(NULL, CFSTR("org.virtualbox.VBoxSVC"),
(SCDynamicStoreCallBack)HostDnsServiceDarwin::hostDnsServiceStoreCallback,
&ctx);
AssertReturn(m->m_store, E_FAIL);
m->m_DnsWatcher = SCDynamicStoreCreateRunLoopSource(NULL, m->m_store, 0);
if (!m->m_DnsWatcher)
return E_OUTOFMEMORY;
int rc = RTSemEventCreate(&m->m_evtStop);
AssertRCReturn(rc, E_FAIL);
CFRunLoopSourceContext sctx;
RT_ZERO(sctx);
sctx.perform = HostDnsServiceDarwin::Data::performShutdownCallback;
m->m_Stopper = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &sctx);
AssertReturn(m->m_Stopper, E_FAIL);
HRESULT hrc = HostDnsMonitor::init();
AssertComRCReturn(hrc, hrc);
return updateInfo();
}
RTDECL(int) RTFileAioCtxCreate(PRTFILEAIOCTX phAioCtx, uint32_t cAioReqsMax,
uint32_t fFlags)
{
PRTFILEAIOCTXINTERNAL pCtxInt;
unsigned cReqsWaitMax;
AssertPtrReturn(phAioCtx, VERR_INVALID_POINTER);
AssertReturn(!(fFlags & ~RTFILEAIOCTX_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
if (cAioReqsMax == RTFILEAIO_UNLIMITED_REQS)
return VERR_OUT_OF_RANGE;
cReqsWaitMax = RT_MIN(cAioReqsMax, AIO_LISTIO_MAX);
pCtxInt = (PRTFILEAIOCTXINTERNAL)RTMemAllocZ( sizeof(RTFILEAIOCTXINTERNAL)
+ cReqsWaitMax * sizeof(PRTFILEAIOREQINTERNAL));
if (RT_UNLIKELY(!pCtxInt))
return VERR_NO_MEMORY;
/* Create event semaphore. */
int rc = RTSemEventCreate(&pCtxInt->SemEventCancel);
if (RT_FAILURE(rc))
{
RTMemFree(pCtxInt);
return rc;
}
pCtxInt->u32Magic = RTFILEAIOCTX_MAGIC;
pCtxInt->cMaxRequests = cAioReqsMax;
pCtxInt->cReqsWaitMax = cReqsWaitMax;
pCtxInt->fFlags = fFlags;
*phAioCtx = (RTFILEAIOCTX)pCtxInt;
return VINF_SUCCESS;
}
int main( int argc, char **argv)
{
int rc = VINF_SUCCESS;
char ach[2];
RTR3InitExe(argc, &argv, 0);
RTPrintf("VirtualBox guest additions X11 seamless mode testcase\n");
if (0 == XInitThreads())
{
RTPrintf("Failed to initialise X11 threading, exiting.\n");
exit(1);
}
/* Set an X11 error handler, so that we don't die when we get unavoidable errors. */
XSetErrorHandler(vboxClientXLibErrorHandler);
RTPrintf("\nPress <Enter> to exit...\n");
RTSemEventCreate(&eventSem);
/** Our instance of the seamless class. */
VBoxGuestSeamless seamless;
LogRel(("Starting seamless Guest Additions...\n"));
rc = seamless.init();
if (rc != VINF_SUCCESS)
{
RTPrintf("Failed to initialise seamless Additions, rc = %d\n", rc);
}
RTStrmGetLine(g_pStdIn, ach, sizeof(ach));
seamless.uninit();
return rc;
}
/**
* Init a Ping-Pong construct.
*
* @returns iprt status code.
* @param pPP Pointer to the ping-pong structure which needs initialization.
*/
RTDECL(int) RTSemPingPongInit(PRTPINGPONG pPP)
{
/*
* Init the structure.
*/
pPP->enmSpeaker = RTPINGPONGSPEAKER_PING;
int rc = RTSemEventCreate(&pPP->Ping);
if (RT_SUCCESS(rc))
{
rc = RTSemEventCreate(&pPP->Pong);
if (RT_SUCCESS(rc))
return VINF_SUCCESS;
RTSemEventDestroy(pPP->Ping);
}
return rc;
}
VirtualBox::ClientWatcher::ClientWatcher(const ComObjPtr<VirtualBox> &pVirtualBox) :
mVirtualBox(pVirtualBox),
mThread(NIL_RTTHREAD),
mUpdateReq(CWUPDATEREQARG),
mLock(LOCKCLASS_OBJECTSTATE)
{
#if defined(RT_OS_WINDOWS)
/* Misc state. */
mfTerminate = false;
mcMsWait = INFINITE;
mcActiveSubworkers = 0;
/* Update request. The UpdateReq event is also used to wake up subthreads. */
mfUpdateReq = false;
mUpdateReq = ::CreateEvent(NULL /*pSecAttr*/, TRUE /*fManualReset*/, FALSE /*fInitialState*/, NULL /*pszName*/);
AssertRelease(mUpdateReq != NULL);
/* Initialize the handle array. */
for (uint32_t i = 0; i < RT_ELEMENTS(mahWaitHandles); i++)
mahWaitHandles[i] = NULL;
for (uint32_t i = 0; i < RT_ELEMENTS(mahWaitHandles); i += CW_MAX_HANDLES_PER_THREAD)
mahWaitHandles[i] = mUpdateReq;
mcWaitHandles = 1;
#elif defined(RT_OS_OS2)
RTSemEventCreate(&mUpdateReq);
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER) || defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
RTSemEventCreate(&mUpdateReq);
/* start with high timeouts, nothing to do */
ASMAtomicUoWriteU8(&mUpdateAdaptCtr, 0);
#else
# error "Port me!"
#endif
int vrc = RTThreadCreate(&mThread,
worker,
(void *)this,
0,
RTTHREADTYPE_MAIN_WORKER,
RTTHREADFLAGS_WAITABLE,
"Watcher");
AssertRC(vrc);
}
int GuestDnDCallbackEvent::Reset(void)
{
int rc = VINF_SUCCESS;
if (NIL_RTSEMEVENT == mSemEvent)
rc = RTSemEventCreate(&mSemEvent);
mRc = VINF_SUCCESS;
return rc;
}
GuestDnDResponse::GuestDnDResponse(const ComObjPtr<Guest>& pGuest)
: m_EventSem(NIL_RTSEMEVENT)
, m_defAction(0)
, m_allActions(0)
, m_parent(pGuest)
{
int rc = RTSemEventCreate(&m_EventSem);
if (RT_FAILURE(rc))
throw rc;
}
EventQueue::EventQueue(void)
: mUserCnt(0),
mShutdown(false)
{
int rc = RTCritSectInit(&mCritSect);
AssertRC(rc);
rc = RTSemEventCreate(&mSemEvent);
AssertRC(rc);
}
GuestWaitEvent::GuestWaitEvent(uint32_t uCID,
const std::list<VBoxEventType_T> &lstEvents)
: mCID(uCID),
mEventTypes(lstEvents),
mEventSem(NIL_RTSEMEVENT)
{
int rc = RTSemEventCreate(&mEventSem);
AssertRC(rc);
/** @todo Throw an exception on failure! */
}
RTDECL(int) RTSemRWCreateEx(PRTSEMRW phRWSem, uint32_t fFlags,
RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
{
AssertReturn(!(fFlags & ~RTSEMRW_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
RTSEMRWINTERNAL *pThis = (RTSEMRWINTERNAL *)RTMemAlloc(sizeof(*pThis));
if (!pThis)
return VERR_NO_MEMORY;
int rc = RTSemEventMultiCreate(&pThis->hEvtRead);
if (RT_SUCCESS(rc))
{
rc = RTSemEventCreate(&pThis->hEvtWrite);
if (RT_SUCCESS(rc))
{
pThis->u32Magic = RTSEMRW_MAGIC;
pThis->u32Padding = 0;
pThis->u64State = 0;
pThis->hNativeWriter = NIL_RTNATIVETHREAD;
pThis->cWriterReads = 0;
pThis->cWriteRecursions = 0;
pThis->fNeedReset = false;
#ifdef RTSEMRW_STRICT
bool const fLVEnabled = !(fFlags & RTSEMRW_FLAGS_NO_LOCK_VAL);
if (!pszNameFmt)
{
static uint32_t volatile s_iSemRWAnon = 0;
uint32_t i = ASMAtomicIncU32(&s_iSemRWAnon) - 1;
RTLockValidatorRecExclInit(&pThis->ValidatorWrite, hClass, uSubClass, pThis,
fLVEnabled, "RTSemRW-%u", i);
RTLockValidatorRecSharedInit(&pThis->ValidatorRead, hClass, uSubClass, pThis,
false /*fSignaller*/, fLVEnabled, "RTSemRW-%u", i);
}
else
{
va_list va;
va_start(va, pszNameFmt);
RTLockValidatorRecExclInitV(&pThis->ValidatorWrite, hClass, uSubClass, pThis,
fLVEnabled, pszNameFmt, va);
va_end(va);
va_start(va, pszNameFmt);
RTLockValidatorRecSharedInitV(&pThis->ValidatorRead, hClass, uSubClass, pThis,
false /*fSignaller*/, fLVEnabled, pszNameFmt, va);
va_end(va);
}
RTLockValidatorRecMakeSiblings(&pThis->ValidatorWrite.Core, &pThis->ValidatorRead.Core);
#endif
*phRWSem = pThis;
return VINF_SUCCESS;
}
RTSemEventMultiDestroy(pThis->hEvtRead);
}
return rc;
}
VBoxDnDDropTarget::VBoxDnDDropTarget(VBoxDnDWnd *pParent)
: mRefCount(1),
mpWndParent(pParent),
mdwCurEffect(0),
mpvData(NULL),
mcbData(0),
hEventDrop(NIL_RTSEMEVENT)
{
int rc = RTSemEventCreate(&hEventDrop);
LogFlowFunc(("rc=%Rrc\n", rc)); NOREF(rc);
}
/**
* Creates the XPCOM event thread
*
* @returns VBOX status code
* @param eqFD XPCOM event queue file descriptor
*/
int startXPCOMEventQueueThread(int eqFD)
{
int rc = RTSemEventCreate(&g_EventSemXPCOMQueueThread);
if (RT_SUCCESS(rc))
{
RTTHREAD Thread;
rc = RTThreadCreate(&Thread, xpcomEventThread, (void *)(intptr_t)eqFD,
0, RTTHREADTYPE_MSG_PUMP, 0, "XPCOMEvent");
}
AssertRC(rc);
return rc;
}
/**
* Block the main thread until the service shuts down.
*/
void VBoxServiceMainWait(void)
{
int rc;
VBoxServiceReportStatus(VBoxGuestFacilityStatus_Active);
#ifdef RT_OS_WINDOWS
/*
* Wait for the semaphore to be signalled.
*/
VBoxServiceVerbose(1, "Waiting in main thread\n");
rc = RTSemEventCreate(&g_hEvtWindowsService);
AssertRC(rc);
while (!ASMAtomicReadBool(&g_fWindowsServiceShutdown))
{
rc = RTSemEventWait(g_hEvtWindowsService, RT_INDEFINITE_WAIT);
AssertRC(rc);
}
RTSemEventDestroy(g_hEvtWindowsService);
g_hEvtWindowsService = NIL_RTSEMEVENT;
#else
/*
* Wait explicitly for a HUP, INT, QUIT, ABRT or TERM signal, blocking
* all important signals.
*
* The annoying EINTR/ERESTART loop is for the benefit of Solaris where
* sigwait returns when we receive a SIGCHLD. Kind of makes sense since
*/
sigset_t signalMask;
sigemptyset(&signalMask);
sigaddset(&signalMask, SIGHUP);
sigaddset(&signalMask, SIGINT);
sigaddset(&signalMask, SIGQUIT);
sigaddset(&signalMask, SIGABRT);
sigaddset(&signalMask, SIGTERM);
pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
int iSignal;
do
{
iSignal = -1;
rc = sigwait(&signalMask, &iSignal);
}
while ( rc == EINTR
# ifdef ERESTART
|| rc == ERESTART
# endif
);
VBoxServiceVerbose(3, "VBoxServiceMainWait: Received signal %d (rc=%d)\n", iSignal, rc);
#endif /* !RT_OS_WINDOWS */
}
//
// constructor / destructor
//
VMMDev::VMMDev(Console *console)
: mpDrv(NULL),
mParent(console)
{
int rc = RTSemEventCreate(&mCredentialsEvent);
AssertRC(rc);
#ifdef VBOX_WITH_HGCM
rc = HGCMHostInit ();
AssertRC(rc);
m_fHGCMActive = true;
#endif /* VBOX_WITH_HGCM */
mu32CredentialsFlags = 0;
}
VBoxDnDDropTarget::VBoxDnDDropTarget(VBoxDnDWnd *pParent)
: mRefCount(1),
mpWndParent(pParent),
mdwCurEffect(0),
mpvData(NULL),
mcbData(0),
hEventDrop(NIL_RTSEMEVENT)
{
int rc = VbglR3DnDConnect(&mDnDCtx);
if (RT_SUCCESS(rc))
rc = RTSemEventCreate(&hEventDrop);
LogFlowFunc(("clientID=%RU32, rc=%Rrc\n", mDnDCtx.uClientID, rc));
}
/**
* Create a new (binary) semaphore.
*/
sys_sem_t sys_sem_new(u8_t count)
{
int rc;
RTSEMEVENT sem;
Assert(count <= 1);
rc = RTSemEventCreate(&sem);
AssertRC(rc);
if (count == 1)
{
rc = RTSemEventSignal(sem);
AssertRC(rc);
}
return sem;
}
/**
* Initializes the object (called right after construction).
*
* @returns S_OK on success and non-fatal failures, some COM error otherwise.
*/
int USBProxyBackendFreeBSD::init(void)
{
/*
* Create semaphore.
*/
int rc = RTSemEventCreate(&mNotifyEventSem);
if (RT_FAILURE(rc))
return rc;
/*
* Start the poller thread.
*/
start();
return VINF_SUCCESS;
}
int vboxVhwaCommandSubmit(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd)
{
#ifdef VBOXVHWA_WITH_SHGSMI
const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
Assert(pHdr);
int rc = VERR_GENERAL_FAILURE;
if (pHdr)
{
do
{
HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
Assert(offCmd != HGSMIOFFSET_VOID);
if (offCmd != HGSMIOFFSET_VOID)
{
rc = vboxVhwaCommandSubmitHgsmi(pDevExt, offCmd);
AssertRC(rc);
if (RT_SUCCESS(rc))
{
VBoxSHGSMICommandDoneSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
AssertRC(rc);
break;
}
}
else
rc = VERR_INVALID_PARAMETER;
/* fail to submit, cancel it */
VBoxSHGSMICommandCancelSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
} while (0);
}
else
rc = VERR_INVALID_PARAMETER;
return rc;
#else
RTSEMEVENT hEvent;
int rc = RTSemEventCreate(&hEvent);
AssertRC(rc);
if (RT_SUCCESS(rc))
{
pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ;
vboxVhwaCommandSubmitAsynchByEvent(pDevExt, pCmd, hEvent);
rc = RTSemEventWait(hEvent, RT_INDEFINITE_WAIT);
AssertRC(rc);
if (RT_SUCCESS(rc))
RTSemEventDestroy(hEvent);
}
return rc;
#endif
}
/**
* Initialize the port to IPRT.
*/
void sys_init(void)
{
int rc;
unsigned i;
#if SYS_LIGHTWEIGHT_PROT
rc = RTCritSectInit(&g_ProtCritSect);
AssertRC(rc);
#else
rc = RTSemEventCreate(&g_ThreadSem);
AssertRC(rc);
rc = RTSemEventSignal(g_ThreadSem);
AssertRC(rc);
#endif
for (i = 0; i < THREADS_MAX; i++)
g_aTLS[i].tid = NIL_RTTHREAD;
}
/**
* Re-initializes a request when it's being recycled.
*
* @returns IRPT status code, the request is freed on failure.
* @param pReq The request.
* @param enmType The request type.
*/
DECLHIDDEN(int) rtReqReInit(PRTREQINT pReq, RTREQTYPE enmType)
{
Assert(pReq->u32Magic == RTREQ_MAGIC);
Assert(pReq->enmType == RTREQTYPE_INVALID);
Assert(pReq->enmState == RTREQSTATE_FREE);
Assert(pReq->cRefs == 0);
/*
* Make sure the event sem is not signaled.
*/
if (!pReq->fEventSemClear)
{
int rc = RTSemEventWait(pReq->EventSem, 0);
if (rc != VINF_SUCCESS && rc != VERR_TIMEOUT)
{
/*
* This shall not happen, but if it does we'll just destroy
* the semaphore and create a new one.
*/
AssertMsgFailed(("rc=%Rrc from RTSemEventWait(%#x).\n", rc, pReq->EventSem));
RTSemEventDestroy(pReq->EventSem);
rc = RTSemEventCreate(&pReq->EventSem);
if (RT_FAILURE(rc))
{
AssertRC(rc);
pReq->EventSem = NIL_RTSEMEVENT;
rtReqFreeIt(pReq);
return rc;
}
}
pReq->fEventSemClear = true;
}
else
Assert(RTSemEventWait(pReq->EventSem, 0) == VERR_TIMEOUT);
/*
* Initialize the packet and return it.
*/
ASMAtomicWriteNullPtr(&pReq->pNext);
pReq->iStatusX = VERR_RT_REQUEST_STATUS_STILL_PENDING;
pReq->enmState = RTREQSTATE_ALLOCATED;
pReq->fFlags = RTREQFLAGS_IPRT_STATUS;
pReq->enmType = enmType;
pReq->cRefs = 1;
return VINF_SUCCESS;
}
/**
* 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) RTReqQueueCreate(RTREQQUEUE *phQueue)
{
PRTREQQUEUEINT pQueue = (PRTREQQUEUEINT)RTMemAllocZ(sizeof(RTREQQUEUEINT));
if (!pQueue)
return VERR_NO_MEMORY;
int rc = RTSemEventCreate(&pQueue->EventSem);
if (RT_SUCCESS(rc))
{
pQueue->u32Magic = RTREQQUEUE_MAGIC;
*phQueue = pQueue;
return VINF_SUCCESS;
}
RTMemFree(pQueue);
return rc;
}
/**
* Create a new (binary) semaphore.
*/
err_t sys_sem_new(sys_sem_t *pSem, u8_t count)
{
int rc;
err_t rcLwip = ERR_ARG;
if (!pSem)
return ERR_ARG;
Assert(count <= 1);
rc = RTSemEventCreate(pSem);
AssertRCReturn(rc, ERR_ARG);
rcLwip = ERR_OK;
if (count == 1)
{
rc = RTSemEventSignal(*pSem);
AssertRCReturn(rc, ERR_VAL);
}
return rcLwip;
}
/**
* Initializes the object (called right after construction).
*
* @returns S_OK on success and non-fatal failures, some COM error otherwise.
*/
HRESULT USBProxyServiceFreeBSD::init(void)
{
/*
* Create semaphore.
*/
int rc = RTSemEventCreate(&mNotifyEventSem);
if (RT_FAILURE(rc))
{
mLastError = rc;
return E_FAIL;
}
/*
* Start the poller thread.
*/
start();
return S_OK;
}