status_t LocalePreflet::_RestartApp(const char* signature) const { app_info info; status_t status = be_roster->GetAppInfo(signature, &info); if (status != B_OK) return status; BMessenger application(signature); status = application.SendMessage(B_QUIT_REQUESTED); if (status != B_OK) return status; status_t exit; wait_for_thread(info.thread, &exit); return be_roster->Launch(signature); }
status_t ESDEndpoint::Connect(const char *host, uint16 port) { status_t err; // set up connection asynchronously fHost = host; fPort = port; err = fConnectThread = spawn_thread(_ConnectThread, "ESDEndpoint Connection", B_LOW_PRIORITY, this); if (err < B_OK) return err; err = resume_thread(fConnectThread); // TODO: return now instead and move Connect() call wait_for_thread(fConnectThread, &err); return err; }
void SnowView::DetachedFromWindow() { fAttached = false; /* if (Parent()) { Parent()->Invalidate(Parent()->Bounds()); } */ if (fMsgRunner) delete fMsgRunner; fMsgRunner = NULL; status_t err; fCachedParent = NULL; if (fInvalidator > B_OK) wait_for_thread(fInvalidator, &err); fInvalidator = -1; if (fFallenReg) delete fFallenReg; }
RemoteView::~RemoteView() { fStopThread = true; delete fReceiver; delete fReceiveBuffer; delete fSendBuffer; delete fSender; delete fReceiveEndpoint; delete fSendEndpoint; delete fOffscreenBitmap; delete fCursorBitmap; int32 result; wait_for_thread(fDrawThread, &result); }
static status_t ethernet_std_ops(int32 op, ...) { switch (op) { case B_MODULE_INIT: { status_t status = get_module(NET_STACK_MODULE_NAME, (module_info **)&sStackModule); if (status < B_OK) return status; new (&sCheckList) DoublyLinkedList<ethernet_device>; // static C++ objects are not initialized in the module startup sLinkCheckerThread = -1; sLinkChangeSemaphore = create_sem(0, "ethernet link change"); if (sLinkChangeSemaphore < B_OK) { put_module(NET_STACK_MODULE_NAME); return sLinkChangeSemaphore; } mutex_init(&sListLock, "ethernet devices"); return B_OK; } case B_MODULE_UNINIT: { delete_sem(sLinkChangeSemaphore); status_t status; wait_for_thread(sLinkCheckerThread, &status); mutex_destroy(&sListLock); put_module(NET_STACK_MODULE_NAME); return B_OK; } default: return B_ERROR; } }
ServerApp::~ServerApp() { TRACE("ServerApp::~ServerApp()\n"); delete_port(fControlPort); wait_for_thread(fControlThread, NULL); delete gNotificationManager; delete gBufferManager; delete gAppManager; delete gNodeManager; delete gMediaFilesManager; BMediaRoster* roster = BMediaRoster::CurrentRoster(); if (roster->StopWatching(BMessenger(this, this), B_MEDIA_SERVER_QUIT) != B_OK) { TRACE("ServerApp: can't unwatch for B_MEDIA_SERVER_QUIT"); } }
Stack::~Stack() { int32 result; fStopThreads = true; wait_for_thread(fExploreThread, &result); mutex_lock(&fStackLock); mutex_destroy(&fStackLock); mutex_lock(&fExploreLock); mutex_destroy(&fExploreLock); // Release the bus modules for (Vector<BusManager *>::Iterator i = fBusManagers.Begin(); i != fBusManagers.End(); i++) { delete (*i); } delete fAllocator; free(fObjectArray); }
bool BeHappy::QuitRequested() { // on demande au moniteur de se charger des fenêtres, et on attend leur fermeture thread_id l_Thread = m_Monitor->Thread(); m_Monitor->CloseAll(); if (l_Thread > 0) { status_t l_Dummy; wait_for_thread(l_Thread,&l_Dummy); } // et on finit le ménage RemoveHandler(m_LanguageHandler); delete m_LanguageHandler; eraser->PostMessage(B_QUIT_REQUESTED); return true; }
WRes Thread_Wait(CThread *thread) { int ret; if (thread->_created == 0) return EINVAL; if (thread->_tid >= B_OK) { status_t exit_value; wait_for_thread(thread->_tid, &exit_value); thread->_tid = B_BAD_THREAD_ID; } else { return EINVAL; } thread->_created = 0; return 0; }
int pthread_join(pthread_t thread, void** _value) { status_t dummy; status_t error; do { error = wait_for_thread(thread->id, &dummy); } while (error == B_INTERRUPTED); if (error == B_BAD_THREAD_ID) RETURN_AND_TEST_CANCEL(ESRCH); if (_value != NULL) *_value = thread->exit_value; if ((atomic_or(&thread->flags, THREAD_DETACHED) & THREAD_DEAD) != 0) free(thread); RETURN_AND_TEST_CANCEL(error); }
void ObjectView::DetachedFromWindow() { BGLView::DetachedFromWindow(); status_t dummy; long locks = 0; while (Window()->IsLocked()) { locks++; Window()->Unlock(); } acquire_sem(quittingSem); release_sem(drawEvent); wait_for_thread(fDrawThread, &dummy); release_sem(quittingSem); while (locks--) Window()->Lock(); }
void TExpandoMenuBar::DetachedFromWindow() { BMenuBar::DetachedFromWindow(); if (sMonThread != B_ERROR) { sDoMonitor = false; status_t returnCode; wait_for_thread(sMonThread, &returnCode); sMonThread = B_ERROR; } BMessenger self(this); BMessage message(kUnsubscribe); message.AddMessenger("messenger", self); be_app->PostMessage(&message); RemoveItems(0, CountItems(), true); }
int main(int argc, char **argv) { thread_id t[THREADS]; int i; status_t retval; for (i=0; i<THREADS; i++) { t[i] = spawn_thread(test_thread, "socket test thread", B_NORMAL_PRIORITY, &i); if (t[i] >= 0) resume_thread(t[i]); } for (i=0; i<THREADS; i++) { wait_for_thread(t[i], &retval); } printf("Test complete.\n"); return (0); }
void SaturationManipulator::start_threads() { system_info info; get_system_info(&info); number_of_threads = info.cpu_count; thread_id *threads = new thread_id[number_of_threads]; for (int32 i=0;i<number_of_threads;i++) { threads[i] = spawn_thread(thread_entry,"saturation_thread",B_NORMAL_PRIORITY,this); resume_thread(threads[i]); send_data(threads[i],i,NULL,0); } for (int32 i=0;i<number_of_threads;i++) { int32 return_value; wait_for_thread(threads[i],&return_value); } delete[] threads; }
status_t VBoxMouse::Stop(const char *device, void *cookie) { status_t status; int rc; uint32_t fFeatures = 0; Log(("VBoxMouse::%s()\n", __FUNCTION__)); fExiting = true; vboxMouseRelease(); close(fDriverFD); fDriverFD = -1; //XXX WTF ? suspend_thread(fServiceThreadID); resume_thread(fServiceThreadID); wait_for_thread(fServiceThreadID, &status); fServiceThreadID = -1; fExiting = false; return B_OK; }
bool AppServer::QuitRequested() { #if TEST_MODE while (fDesktops.CountItems() > 0) { Desktop *desktop = fDesktops.RemoveItemAt(0); thread_id thread = desktop->Thread(); desktop->PostMessage(B_QUIT_REQUESTED); // we just wait for the desktop to kill itself status_t status; wait_for_thread(thread, &status); } return BServer::QuitRequested(); #else return false; #endif }
status_t PrintServerMessenger::SendRequest() { fThreadCompleted = create_sem(0, "print_server_messenger_sem"); if (fThreadCompleted < B_OK) return B_ERROR; thread_id id = spawn_thread(MessengerThread, "async_request", B_NORMAL_PRIORITY, this); if (id <= 0 || resume_thread(id) != B_OK) return B_ERROR; // Get the originating window, if it exists BWindow* window = dynamic_cast<BWindow*>( BLooper::LooperForThread(find_thread(NULL))); if (window != NULL) { status_t err; while (true) { do { err = acquire_sem_etc(fThreadCompleted, 1, B_RELATIVE_TIMEOUT, 50000); // We've (probably) had our time slice taken away from us } while (err == B_INTERRUPTED); // Semaphore was finally nuked in SetResult(BMessage *) if (err == B_BAD_SEM_ID) break; window->UpdateIfNeeded(); } } else { // No window to update, so just hang out until we're done. while (acquire_sem(fThreadCompleted) == B_INTERRUPTED); } status_t status; wait_for_thread(id, &status); return Result() != NULL ? B_OK : B_ERROR; }
MacWindow::~MacWindow() { // Restore cursor mouse_in_view = false; be_app->SetCursor(B_HAND_CURSOR); // Hide window Hide(); Sync(); // Stop 60Hz interrupt status_t l; tick_thread_active = false; delete_sem(drawing_sem); wait_for_thread(tick_thread, &l); // Free bitmap and frame buffer delete the_bitmap; // Tell emulator that we're done the_window = NULL; }
void DPCQueue::Close(bool cancelPending) { InterruptsSpinLocker locker(fLock); if (_IsClosed()) return; // If requested, dequeue all pending callbacks if (cancelPending) fCallbacks.MakeEmpty(); // mark the queue closed thread_id thread = fThreadID; fThreadID = -1; locker.Unlock(); // wake up the thread and wait for it fPendingCallbacksCondition.NotifyAll(); wait_for_thread(thread, NULL); }
void TExpandoMenuBar::DetachedFromWindow() { BMenuBar::DetachedFromWindow(); if (sMonThread != B_ERROR) { status_t err = B_OK; sDoMonitor = false; wait_for_thread(sMonThread, &err); sMonThread = B_ERROR; } BMessenger self(this); BMessage message(msg_Unsubscribe); message.AddMessenger("messenger", self); be_app->PostMessage(&message); BMenuItem *item = NULL; while ((item = RemoveItem((int32)0)) != NULL) delete item; }
static int test_once(void) { if (g_once_init_called != 0) { fprintf(stderr, "g_once_init_called was non-zero at start.\n"); return 0; } thread_t thread; if (!run_thread(&thread, call_once_thread) || !wait_for_thread(thread)) { fprintf(stderr, "thread failed.\n"); return 0; } CRYPTO_once(&g_test_once, once_init); if (g_once_init_called != 1) { fprintf(stderr, "Expected init function to be called once, but found %u.\n", g_once_init_called); return 0; } return 1; }
int threads ( char *args[] ) { thread_t thread[THR_NUM]; int i; sleep.sec = 1; sleep.nsec = 0; for ( i = 0; i < THR_NUM; i++ ) create_thread ( simple_thread, (void *) i, SCHED_FIFO, THR_DEFAULT_PRIO - 1, &thread[i] ); delay ( &sleep ); delay ( &sleep ); cancel_thread ( &thread[0] ); print ( "Thread 0 canceled!\n" ); for ( i = 0; i < THR_NUM; i++ ) wait_for_thread ( &thread[i], IPC_WAIT ); return 0; }
extern "C" void be_mouse_exit(void) { be_mickey_x = 0; be_mickey_y = 0; be_mouse_x = 0; be_mouse_y = 0; be_mouse_b = 0; limit_up = 0; limit_down = 0; limit_left = 0; limit_right = 0; mouse_thread_running = false; if (mouse_thread_id > 0) { release_sem(_be_mouse_view_attached); wait_for_thread(mouse_thread_id, &ignore_result); acquire_sem(_be_mouse_view_attached); mouse_thread_id = -1; } }
void SerialDevice::Removed() { if (fDeviceRemoved) return; // notifies us that the device was removed fDeviceRemoved = true; // we need to ensure that we do not use the device anymore fStopDeviceThread = true; fInputStopped = false; gUSBModule->cancel_queued_transfers(fReadPipe); gUSBModule->cancel_queued_transfers(fWritePipe); gUSBModule->cancel_queued_transfers(fControlPipe); int32 result = B_OK; wait_for_thread(fDeviceThread, &result); fDeviceThread = -1; mutex_lock(&fWriteLock); mutex_unlock(&fWriteLock); }
/************************************************************************ * hb_thread_close() ************************************************************************ * Joins the thread and frees memory. ***********************************************************************/ void hb_thread_close( hb_thread_t ** _t ) { hb_thread_t * t = *_t; /* Join the thread */ #if defined( SYS_BEOS ) long exit_value; wait_for_thread( t->thread, &exit_value ); #elif USE_PTHREAD pthread_join( t->thread, NULL ); //#elif defined( SYS_CYGWIN ) // WaitForSingleObject( t->thread, INFINITE ); #endif hb_deep_log( 2, "thread %"PRIx64" joined (\"%s\")", hb_thread_to_integer( t ), t->name ); hb_lock_close( &t->lock ); free( t->name ); free( t ); *_t = NULL; }
void TimerExit(void) { #if PRECISE_TIMING // Quit timer thread if (timer_thread > 0) { #ifdef PRECISE_TIMING_BEOS status_t l; thread_active = false; suspend_thread(timer_thread); resume_thread(timer_thread); wait_for_thread(timer_thread, &l); delete_sem(wakeup_time_sem); #endif #ifdef PRECISE_TIMING_MACH timer_thread_active = false; semaphore_destroy(mach_task_self(), wakeup_time_sem); #endif #ifdef PRECISE_TIMING_POSIX timer_thread_kill(); #endif } #endif }
bool PApp::QuitRequested() { BWindow *doc; fIsQuitting = true; while ((doc = dynamic_cast<BWindow*>(CDoc::FirstDoc())) != NULL) { doc->Lock(); if (doc->QuitRequested()) doc->Quit(); else { doc->Unlock(); fIsQuitting = false; return false; } } if (fFindDialog) { fFindDialog->Lock(); (void)fFindDialog->QuitRequested(); fFindDialog->Quit(); } long l; if (fPrefOpener) wait_for_thread(fPrefOpener, &l); if (fPrefsDialog) { fPrefsDialog->Lock(); fPrefsDialog->Quit(); } return true; } /* PApp::QuitRequested */
int32 CommandThread::_Thread(void* data) { on_exit_thread(CommandThread::_ThreadExit, data); CommandThread* commandThread = static_cast<CommandThread*>(data); if (commandThread == NULL) return B_ERROR; // TODO acquire autolock BCommandPipe pipe; BObjectList<BString>* args = commandThread->Arguments(); for (int32 x = 0; x < args->CountItems(); x++) pipe << *args->ItemAt(x); FILE* stdOutAndErrPipe = NULL; thread_id pipeThread = pipe.PipeInto(&stdOutAndErrPipe); if (pipeThread < B_OK) return B_ERROR; BPrivate::BCommandPipe::LineReader* reader = new CommandReader(commandThread->Invoker()); if (pipe.ReadLines(stdOutAndErrPipe, reader) != B_OK) { kill_thread(pipeThread); status_t exitval; wait_for_thread(pipeThread, &exitval); return B_ERROR; } return B_OK; }
int main() { void* client; int err; test_Title("Directory Handling"); allTests(); test_Next("Do it again using the CPosixServer (for them, not me)"); close_console=1; start_posix_server(); /* calls SpawnPosixServer from C++ code */ client=create_thread(allTests, "TDIRS tests"); test(client!=0); start_thread(client); err=wait_for_thread(client); test(err==0); CloseSTDLIB(); test_Close(); return 0; }
void FifoInit(void) { uint32 *fifo = gSi->fifo; /* Stop update thread, if any */ if (gUpdateThread > B_OK) { status_t exitValue; gUpdateThreadDie = 1; wait_for_thread(gUpdateThread, &exitValue); } gSi->fifoCapabilities = 0; gSi->fifoFlags = 0; if (gSi->capabilities & SVGA_CAP_EXTENDED_FIFO) { gSi->fifoCapabilities = fifo[SVGA_FIFO_CAPABILITIES]; gSi->fifoFlags = fifo[SVGA_FIFO_FLAGS]; FifoPrintCapabilities(gSi->fifoCapabilities); } fifo[SVGA_FIFO_MIN] = gSi->fifoMin * 4; fifo[SVGA_FIFO_MAX] = gSi->fifoSize; fifo[SVGA_FIFO_NEXT_CMD] = fifo[SVGA_FIFO_MIN]; fifo[SVGA_FIFO_STOP] = fifo[SVGA_FIFO_MIN]; gSi->fifoNext = fifo[SVGA_FIFO_NEXT_CMD]; /* Launch a new update thread */ gUpdateThreadDie = 0; gUpdateThread = spawn_thread(UpdateThread, "VMware", B_REAL_TIME_DISPLAY_PRIORITY, NULL); resume_thread(gUpdateThread); TRACE("init fifo: %ld -> %ld\n", fifo[SVGA_FIFO_MIN], fifo[SVGA_FIFO_MAX]); }