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);
}
示例#2
0
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;
}
示例#3
0
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);
}
示例#5
0
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;
	}
}
示例#6
0
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");
	}
}
示例#7
0
文件: Stack.cpp 项目: mmanley/Antares
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);
}
示例#8
0
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;
}
示例#9
0
文件: Threads.c 项目: epa/lrzip
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;
}
示例#10
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);
}
示例#11
0
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();
}
示例#12
0
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);
}
示例#13
0
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);
}
示例#14
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;
}
示例#15
0
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;
}
示例#16
0
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

}
示例#17
0
文件: PrintJob.cpp 项目: mariuz/haiku
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;
}
示例#18
0
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;
}
示例#19
0
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);
}
示例#20
0
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;
}
示例#21
0
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;
}
示例#22
0
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;
}
示例#23
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;
   }
}
示例#24
0
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);
}
示例#25
0
文件: ports.c 项目: Eddy805/HandBrake
/************************************************************************
 * 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;
}
示例#26
0
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
}
示例#27
0
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 */
示例#28
0
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;
}
示例#29
0
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;
	}
示例#30
0
文件: Fifo.c 项目: DonCN/haiku
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]);
}