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; }