status_t device_close(void *data) { struct sis_info *info; if (checkDeviceInfo(info = data) != B_OK) return EINVAL; info->cookieMagic = SiS_FREE_COOKIE_MAGIC; // cancel timer cancel_timer(&info->timer); // remove & disable interrupt sis900_disableInterrupts(info); remove_io_interrupt_handler(info->pciInfo->u.h0.interrupt_line, sis900_interrupt, info); // disable the transmitter's and receiver's state machine write32(info->registers + SiS900_MAC_COMMAND, SiS900_MAC_CMD_Rx_DISABLE | SiS900_MAC_CMD_Tx_DISABLE); delete_sem(info->rxSem); delete_sem(info->txSem); #ifdef EXCESSIVE_DEBUG delete_sem(gIOLock); #endif return B_OK; }
static apr_status_t _thread_rw_cleanup(void * data) { apr_thread_rwlock_t *mutex = (apr_thread_rwlock_t*)data; if (mutex->ReadCount != 0) { while (atomic_add(&mutex->ReadCount , -1) > 1){ release_sem (mutex->Read); } } if (mutex->WriteCount != 0) { while (atomic_add(&mutex->WriteCount , -1) > 1){ release_sem (mutex->Write); } } if (mutex->LockCount != 0) { while (atomic_add(&mutex->LockCount , -1) > 1){ release_sem (mutex->Lock); } } delete_sem(mutex->Read); delete_sem(mutex->Write); delete_sem(mutex->Lock); return APR_SUCCESS; }
void MediaView::Reset() { delete_sem(fPlaySem); fPlaySem = B_ERROR; delete_sem(fScrubSem); fScrubSem = B_ERROR; status_t result = B_NO_ERROR; wait_for_thread(fPlayerThread, &result); fPlayerThread = B_ERROR; fVideoTrack = NULL; fAudioTrack = NULL; delete (fAudioOutput); fAudioOutput = NULL; delete (fBitmap); fBitmap = NULL; delete (fMediaFile); fMediaFile = NULL; free(fAudioDumpingBuffer); fAudioDumpingBuffer = NULL; }
void BDirectWindow::_DisposeData() { // wait until the connection terminates: we can't destroy // the object until the client receives the B_DIRECT_STOP // notification, or bad things will happen while (fConnectionEnable) snooze(50000); _LockDirect(); if (fInitStatus & DW_STATUS_THREAD_STARTED) { fDaemonKiller = true; // delete this sem, otherwise the Direct daemon thread // will wait forever on it delete_sem(fDisableSem); status_t retVal; wait_for_thread(fDirectDaemonId, &retVal); } #if DW_NEEDS_LOCKING if (fInitStatus & DW_STATUS_SEM_CREATED) delete_sem(fDirectSem); #endif if (fInitStatus & DW_STATUS_AREA_CLONED) delete_area(fClonedClippingArea); }
// destructor NetFSServer::~NetFSServer() { fTerminating = true; // stop the connection listener if (fConnectionListener) fConnectionListener->StopListening(); if (fConnectionListenerThread >= 0) { int32 result; wait_for_thread(fConnectionListenerThread, &result); } delete fConnectionListener; // delete the broadcaster semaphore if (fBroadcasterSemaphore >= 0) delete_sem(fBroadcasterSemaphore); // terminate the broadcaster if (fBroadcaster >= 0) { safe_closesocket(fBroadcastingSocket); // interrupt the thread in case it is currently snoozing suspend_thread(fBroadcaster); int32 result; wait_for_thread(fBroadcaster, &result); } // terminate the server info connection listener _ExitServerInfoConnectionListener(); // terminate the connection deleter if (fClosedConnectionsSemaphore >= 0) delete_sem(fClosedConnectionsSemaphore); if (fConnectionDeleter >= 0) { int32 result; wait_for_thread(fConnectionDeleter, &result); } // blow away all remaining connections AutoLocker<Locker> _(fLock); // open connections for (int32 i = 0; ClientConnection* connection = (ClientConnection*)fClientConnections.ItemAt(i); i++) { connection->Close(); delete connection; } // closed connections for (int32 i = 0; ClientConnection* connection = (ClientConnection*)fClosedConnections.ItemAt(i); i++) { delete connection; } VolumeManager::DeleteDefault(); FDManager::DeleteDefault(); delete fSecurityContext; }
// destructor RWLocker::~RWLocker() { fLock.Lock(); delete_sem(fMutex.semaphore); delete_sem(fQueue.semaphore); for (int32 i = 0; ReadLockInfo* info = _ReadLockInfoAt(i); i++) delete info; }
void LegacyAudioConsumer::HandleStart( bigtime_t performance_time ) { if ( mRunning ) { return; } mPerformanceTimeBase = performance_time; //allocate buffer available semaphore mBuffer_avail = create_sem( 0, "legacy audio out buffer avail" ); if ( mBuffer_avail < B_OK ) { goto init_err1; } //allocate buffer free semaphore mBuffer_free = create_sem( 1, "legacy audio out buffer free" ); if ( mBuffer_free < B_OK ) { goto init_err2; } //allocate output completion semaphore mBuffer_waitIO = create_sem( 1, "legacy audio out waitIO" ); if ( mBuffer_waitIO < B_OK ) { goto init_err3; } //tell the driver about the playback completion semaphore DRIVER_SET_PLAYBACK_COMPLETION_SEM( &mBuffer_waitIO, 0 ); mThread = spawn_thread( _run_thread_, "legacy audio output", B_REAL_TIME_PRIORITY, this ); if ( mThread < B_OK ) { goto init_err4; } io_buf = io_buf1; resume_thread( mThread ); mRunning = true; return; init_err4: delete_sem( mBuffer_waitIO ); init_err3: delete_sem( mBuffer_free ); init_err2: delete_sem( mBuffer_avail ); init_err1: return; }
DirectWindowInfo::~DirectWindowInfo() { // this should make the client die in case it's still running fBufferInfo->bits = NULL; fBufferInfo->bytes_per_row = 0; delete_area(fBufferArea); delete_sem(fSem); delete_sem(fAcknowledgeSem); }
void closeManagedData(bt_managed_data *data) { data->readCount = data->writeCount = 0; delete_sem(data->writer); delete_sem(data->reader); delete_sem(data->readerQueue); delete_sem(data->writeCountSem); delete_sem(data->readCountSem); }
WorkQueue::~WorkQueue() { release_sem(fThreadCancel); status_t result; wait_for_thread(fThread, &result); mutex_destroy(&fQueueLock); delete_sem(fThreadCancel); delete_sem(fQueueSemaphore); }
void usb_disk_free_device_and_luns(disk_device *device) { mutex_lock(&device->lock); mutex_destroy(&device->lock); delete_sem(device->notify); delete_sem(device->interruptLock); for (uint8 i = 0; i < device->lun_count; i++) free(device->luns[i]); free(device->luns); free(device); }
SerialDevice::~SerialDevice() { Removed(); if (fDoneRead >= 0) delete_sem(fDoneRead); if (fDoneWrite >= 0) delete_sem(fDoneWrite); if (fBufferArea >= 0) delete_area(fBufferArea); }
status_t hpet_open(const char* name, uint32 flags, void** cookie) { *cookie = NULL; if (sHPETRegs == NULL) return B_NO_INIT; if (atomic_add(&sOpenCount, 1) != 0) { atomic_add(&sOpenCount, -1); return B_BUSY; } int timerNumber = 2; // TODO char semName[B_OS_NAME_LENGTH]; snprintf(semName, B_OS_NAME_LENGTH, "hpet_timer %d sem", timerNumber); sem_id sem = create_sem(0, semName); if (sem < 0) { atomic_add(&sOpenCount, -1); return sem; } hpet_timer_cookie* hpetCookie = (hpet_timer_cookie*)malloc(sizeof(hpet_timer_cookie)); if (hpetCookie == NULL) { delete_sem(sem); atomic_add(&sOpenCount, -1); return B_NO_MEMORY; } hpetCookie->number = timerNumber; hpetCookie->timer = &sHPETRegs->timer[timerNumber]; hpetCookie->sem = sem; set_sem_owner(hpetCookie->sem, B_SYSTEM_TEAM); hpet_set_enabled(false); status_t status = hpet_init_timer(hpetCookie); if (status != B_OK) dprintf("hpet_open: initializing timer failed: %s\n", strerror(status)); hpet_set_enabled(true); *cookie = hpetCookie; if (status != B_OK) { delete_sem(sem); free(hpetCookie); atomic_add(&sOpenCount, -1); } return status; }
DavicomDevice::~DavicomDevice() { if (fNotifyReadSem >= B_OK) delete_sem(fNotifyReadSem); if (fNotifyWriteSem >= B_OK) delete_sem(fNotifyWriteSem); if (!fRemoved) //??? gUSBModule->cancel_queued_transfers(fNotifyEndpoint); if(fNotifyBuffer) free(fNotifyBuffer); }
PR_DestroyCondVar (PRCondVar *cvar) { status_t result = delete_sem( cvar->sem ); PR_ASSERT( result == B_NO_ERROR ); result = delete_sem( cvar->handshakeSem ); PR_ASSERT( result == B_NO_ERROR ); result = delete_sem( cvar->signalSem ); PR_ASSERT( result == B_NO_ERROR ); PR_DELETE( cvar ); }
void remove_device(pegasus_dev *device) { ASSERT(device != NULL); delete_sem(device->rx_sem); delete_sem(device->tx_sem); delete_sem(device->rx_sem_cb); delete_sem(device->tx_sem_cb); delete_sem(device->sem_lock); free(device); }
void LegacyAudioConsumer::HandleStop() { if ( ! mRunning ) { return; } delete_sem( mBuffer_avail ); delete_sem( mBuffer_free ); delete_sem( mBuffer_waitIO ); wait_for_thread( mThread, &mThread ); mRunning = false; }
SerialDevice::~SerialDevice() { Removed(); if (fDoneRead >= B_OK) delete_sem(fDoneRead); if (fDoneWrite >= B_OK) delete_sem(fDoneWrite); if (fBufferArea >= B_OK) delete_area(fBufferArea); mutex_destroy(&fReadLock); mutex_destroy(&fWriteLock); }
extern "C" int be_mouse_init(void) { sem_id mouse_started; int32 num_buttons; mouse_started = create_sem(0, "starting mouse driver..."); if (mouse_started < 0) { goto cleanup; } mouse_thread_id = spawn_thread(mouse_thread, MOUSE_THREAD_NAME, MOUSE_THREAD_PRIORITY, &mouse_started); if (mouse_thread_id < 0) { goto cleanup; } mouse_thread_running = true; resume_thread(mouse_thread_id); acquire_sem(mouse_started); delete_sem(mouse_started); 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; get_mouse_type(&num_buttons); return num_buttons; cleanup: { if (mouse_started > 0) { delete_sem(mouse_started); } be_mouse_exit(); return 0; } }
CreateParamsPanel::~CreateParamsPanel() { RemoveCommonFilter(fEscapeFilter); delete fEscapeFilter; delete_sem(fExitSemaphore); }
// _HandleStart void VideoProducer::_HandleStart(bigtime_t performance_time) { // Start producing frames, even if the output hasn't been connected yet. PRINTF(1, ("_HandleStart(%Ld)\n", performance_time)); if (fRunning) { PRINTF(-1, ("_HandleStart: Node already started\n")); return; } fFrame = 0; fFrameBase = 0; fPerformanceTimeBase = performance_time; fFrameSync = create_sem(0, "frame synchronization"); if (fFrameSync < B_OK) goto err1; fThread = spawn_thread(_frame_generator_, "frame generator", B_NORMAL_PRIORITY, this); if (fThread < B_OK) goto err2; resume_thread(fThread); fRunning = true; return; err2: delete_sem(fFrameSync); err1: return; }
static status_t std_ops(int32 op, ...) { if (op == B_MODULE_INIT) { sRequestSem = create_sem(0, "run_on_exit_request"); if (sRequestSem < B_OK) return sRequestSem; thread_id thread = spawn_kernel_thread(&run_on_exit_loop, "run_on_exit_loop", B_NORMAL_PRIORITY, NULL); if (thread < B_OK) return thread; send_signal_etc(thread, SIGCONT, B_DO_NOT_RESCHEDULE); add_debugger_command_etc("on_exit", &add_run_on_exit_command, "Adds a command to be run when leaving the kernel debugger", "<command> [<arguments>]\n" "Adds a command to be run when leaving the kernel debugger.\n", 0); return B_OK; } else if (op == B_MODULE_UNINIT) { remove_debugger_command("on_exit", &add_run_on_exit_command); // deleting the sem will also cause the thread to exit delete_sem(sRequestSem); sRequestSem = -1; return B_OK; } return B_BAD_VALUE; }
QueueActions::~QueueActions(){ if(Lock()){ suspend_thread(fID); exit_thread(fID); delete_sem(fLock); } }
static status_t createSemaphores(struct sis_info *info) { if ((info->rxSem = create_sem(0, "sis900 receive")) < B_OK) return info->rxSem; set_sem_owner(info->rxSem, B_SYSTEM_TEAM); if ((info->txSem = create_sem(NUM_Tx_DESCR, "sis900 transmit")) < B_OK) { delete_sem(info->rxSem); return info->txSem; } set_sem_owner(info->txSem, B_SYSTEM_TEAM); #ifdef EXCESSIVE_DEBUG if ((gIOLock = create_sem(1, "sis900 debug i/o lock")) < B_OK) return gIOLock; set_sem_owner(gIOLock, B_SYSTEM_TEAM); #endif info->rxLock = info->txLock = 0; return B_OK; }
/* be_time_init: */ extern "C" int be_time_init(void) { sem_id timer_started; timer_started = create_sem(0, "starting timer driver..."); if(timer_started < 0) { goto cleanup; } timer_thread_id = spawn_thread(timer_thread, "timer driver", TIMER_THREAD_PRIORITY, &timer_started); if(timer_thread_id < 0) { goto cleanup; } timer_thread_running = true; resume_thread(timer_thread_id); return 0; cleanup: { if (timer_started > 0) { delete_sem(timer_started); } be_time_exit(); return 1; } }
void BAlert::MessageReceived(BMessage* msg) { if (msg->what != kAlertButtonMsg) return BWindow::MessageReceived(msg); int32 which; if (msg->FindInt32("which", &which) == B_OK) { if (fAlertSem < B_OK) { // Semaphore hasn't been created; we're running asynchronous if (fInvoker) { BMessage* out = fInvoker->Message(); if (out && (out->ReplaceInt32("which", which) == B_OK || out->AddInt32("which", which) == B_OK)) fInvoker->Invoke(); } PostMessage(B_QUIT_REQUESTED); } else { // Created semaphore means were running synchronously fAlertValue = which; // TextAlertVar does release_sem() below, and then sets the // member var. That doesn't make much sense to me, since we // want to be able to clean up at some point. Better to just // nuke the semaphore now; we don't need it any more and this // lets synchronous Go() continue just as well. delete_sem(fAlertSem); fAlertSem = -1; } } }
/* Free a mutex */ TSRM_API void tsrm_mutex_free(MUTEX_T mutexp) { if (mutexp) { #ifdef TSRM_WIN32 DeleteCriticalSection(mutexp); free(mutexp); #elif defined(GNUPTH) free(mutexp); #elif defined(PTHREADS) pthread_mutex_destroy(mutexp); free(mutexp); #elif defined(NSAPI) crit_terminate(mutexp); #elif defined(PI3WEB) PISync_delete(mutexp); #elif defined(TSRM_ST) st_mutex_destroy(mutexp); #elif defined(BETHREADS) delete_sem(mutexp->sem); free(mutexp); #endif } #ifdef THR_DEBUG printf("Mutex freed thread: %d\n",mythreadid()); #endif }
AppRunner::AppRunner() { if (be_app) return; sem_id initsem = create_sem(0, "Cairo BApplication init"); if (initsem < B_OK) { fprintf (stderr, "Error creating BeOS initialization semaphore\n"); return; } thread_id tid = spawn_thread(nsBeOSApp::Main, "Cairo/BeOS test", B_NORMAL_PRIORITY, (void *)initsem); if (tid < B_OK || B_OK != resume_thread(tid)) { fprintf (stderr, "Error spawning thread\n"); return; } if (B_OK != acquire_sem(initsem)) { fprintf (stderr, "Error acquiring semaphore\n"); return; } delete_sem(initsem); return; }
status_t init_driver(void) { int i = 0, j = 0, is_detected; pci_info dev_info; //debug_fd = open("/tmp/broadcom_traffic_log",O_RDWR | B_CREATE_FILE); if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci) != B_OK) return B_ERROR; while (pci->get_nth_pci_info(i++, &dev_info) == 0) { is_detected = 0; if ((dev_info.class_base == PCI_network) && (dev_info.class_sub == PCI_ethernet)) { for (j = 0; bcm5700_pci_tbl[j].vendor != 0; j++) { if ((dev_info.vendor_id == bcm5700_pci_tbl[j].vendor) && (dev_info.device_id == bcm5700_pci_tbl[j].device)) { is_detected = 1; break; } } } if (!is_detected) continue; if (cards_found >= 10) break; dev_list[cards_found] = (char *)malloc(16 /* net/bcm570x/xx */); sprintf(dev_list[cards_found],"net/bcm570x/%d",cards_found); be_b57_dev_cards[cards_found].pci_data = dev_info; be_b57_dev_cards[cards_found].packet_release_sem = create_sem(0,dev_list[cards_found]); be_b57_dev_cards[cards_found].mem_list_num = 0; be_b57_dev_cards[cards_found].lockmem_list_num = 0; be_b57_dev_cards[cards_found].opened = 0; be_b57_dev_cards[cards_found].block = 1; be_b57_dev_cards[cards_found].lock = 0; #ifdef HAIKU_TARGET_PLATFORM_HAIKU be_b57_dev_cards[cards_found].linkChangeSem = -1; #endif if (LM_GetAdapterInfo(&be_b57_dev_cards[cards_found].lm_dev) != LM_STATUS_SUCCESS) { for (j = 0; j < cards_found; j++) { free(dev_list[j]); delete_sem(be_b57_dev_cards[j].packet_release_sem); } put_module(B_PCI_MODULE_NAME); return ENODEV; } QQ_InitQueue(&be_b57_dev_cards[cards_found].RxPacketReadQ.Container,MAX_RX_PACKET_DESC_COUNT); cards_found++; } mempool_init((MAX_RX_PACKET_DESC_COUNT+MAX_TX_PACKET_DESC_COUNT) * cards_found); dev_list[cards_found] = NULL; return B_OK; }
void TVideoPreviewView::Disconnected( const media_source &producer, const media_destination &where) { FUNCTION("TVideoPreviewView::Disconnect()\n"); mConnected = false; status_t status; mDisplayQuit = true; if (vThread != 0) wait_for_thread(vThread, &status); vThread = 0; if (m_Bitmap != NULL) { delete m_Bitmap; m_Bitmap = NULL; } if (mBufferAvailable != 0) delete_sem(mBufferAvailable); mBufferAvailable = 0; while (mBufferQueue->HasBuffers()) { mBufferQueue->PopFirstBuffer(0)->Recycle(); } delete mBufferQueue; mBufferQueue = 0; }