/* * cleanup -- (internal) clean up after each run */ static void cleanup(char test_type) { switch (test_type) { case 'm': os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex))->PMEMmutex_lock); break; case 'r': os_rwlock_destroy(&((PMEMrwlock_internal *) &(Test_obj->rwlock))->PMEMrwlock_lock); break; case 'c': os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex))->PMEMmutex_lock); os_cond_destroy(&((PMEMcond_internal *) &(Test_obj->cond))->PMEMcond_cond); break; case 't': os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex))->PMEMmutex_lock); os_mutex_destroy(&((PMEMmutex_internal *) &(Test_obj->mutex_locked))->PMEMmutex_lock); break; default: FATAL_USAGE(); } }
int fdwatch_destroy(FDWATCH_HANDLE handle) { assert(handle && handle->inuse); if(handle==NULL || (!handle->inuse)) return ERR_INVALID_HANDLE; os_mutex_destroy(&handle->list_mtx); handle->inuse = 0; return ERR_NOERROR; }
struct OsMutex *os_mutex_create(void) { struct OsMutex *mutex = allocate_zero<OsMutex>(1); if (!mutex) { os_mutex_destroy(mutex); return NULL; } #if defined(GENESIS_OS_WINDOWS) InitializeCriticalSection(&mutex->id); #else int err; if ((err = pthread_mutex_init(&mutex->id, NULL))) { os_mutex_destroy(mutex); return NULL; } mutex->id_init = true; #endif return mutex; }
static void wsf_os_free_resource(void) { if ( NULL != msg_id_lock ) { os_mutex_destroy(msg_id_lock); msg_id_lock = NULL; } if ( NULL != sess_lock ) { os_mutex_destroy(sess_lock); sess_lock = NULL; } if ( NULL != device_lock ) { os_mutex_destroy(device_lock); device_lock = NULL; } if ( NULL != global_request_queue) { wsf_msg_queue_destroy(global_request_queue); global_request_queue = NULL; } deinit_req_glist(); }
int log_close(LOG_HANDLE ctx) { int ret; if(ctx->stream.buf!=NULL) { os_sem_post(&ctx->stream.inque); os_thread_wait(ctx->stream.thread, NULL); os_sem_destroy(&ctx->stream.inque); os_sem_destroy(&ctx->stream.ouque); os_mutex_destroy(&ctx->stream.mtx); } ret = map[ctx->type].func_close(ctx); free(ctx); return ret; }
/****************************************************************************** * Function: jpeg_queue_destroy * Description: Destroys the queue object and cleans up internal variables * Input parameters: * p_queue - The pointer to queue object to be destroyed. * Return values: none * Notes: none *****************************************************************************/ void jpeg_queue_destroy(jpeg_queue_t *p_queue) { if (p_queue) { jpeg_q_t *p_q = (jpeg_q_t *)(*p_queue); if (p_q) { JPEG_DBG_LOW("jpeg_queue_destroy: jpeg queue destroy\n"); jpeg_queue_abort(p_queue); JPEG_DBG_LOW("jpeg_queue_destroy: aborted\n"); // queue clean up os_cond_destroy(&(p_q->get_cond)); os_cond_destroy(&(p_q->abort_cond)); os_mutex_destroy(&(p_q->mutex)); JPEG_FREE(p_q); } *p_queue = NULL; } }
void ordered_map_file_close(OrderedMapFile *omf) { if (!omf) return; if (omf->mutex && omf->cond && !omf->queue.error()) { ordered_map_file_flush(omf); omf->running = false; omf->queue.wakeup_all(); } os_thread_destroy(omf->write_thread); if (omf->file) fclose(omf->file); destroy_list(omf); destroy_map(omf); os_mutex_destroy(omf->mutex); os_cond_destroy(omf->cond); destroy(omf, 1); }
void destroy_midi_hardware(struct MidiHardware *midi_hardware) { if (midi_hardware) { if (midi_hardware->thread) { // send dummy event to make thread wake up from blocking midi_hardware->quit_flag = true; snd_seq_event_t ev; snd_seq_ev_clear(&ev); ev.source.client = midi_hardware->client_id; ev.source.port = 0; snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); ev.type = SND_SEQ_EVENT_USR0; int err = snd_seq_event_output(midi_hardware->seq, &ev); if (err < 0) panic("unable to send event: %s\n", snd_strerror(err)); err = snd_seq_drain_output(midi_hardware->seq); if (err < 0) panic("unable to drain output: %s\n", snd_strerror(err)); os_thread_destroy(midi_hardware->thread); } destroy_devices_info(midi_hardware->current_devices_info); destroy_devices_info(midi_hardware->ready_devices_info); genesis_midi_device_unref(midi_hardware->system_announce_device); genesis_midi_device_unref(midi_hardware->system_timer_device); if (midi_hardware->seq) { if (midi_hardware->client_info) snd_seq_client_info_free(midi_hardware->client_info); if (midi_hardware->port_info) snd_seq_port_info_free(midi_hardware->port_info); snd_seq_close(midi_hardware->seq); } os_mutex_destroy(midi_hardware->mutex); destroy(midi_hardware, 1); } }
int main(int argc, char *argv[]) { START(argc, argv, "obj_direct"); if (argc != 3) UT_FATAL("usage: %s [directory] [# of pools]", argv[0]); unsigned npools = ATOU(argv[2]); const char *dir = argv[1]; int r; os_mutex_init(&lock1); os_mutex_init(&lock2); os_cond_init(&sync_cond1); os_cond_init(&sync_cond2); cond1 = cond2 = 0; PMEMobjpool **pops = MALLOC(npools * sizeof(PMEMobjpool *)); UT_ASSERTne(pops, NULL); size_t length = strlen(dir) + MAX_PATH_LEN; char *path = MALLOC(length); for (unsigned i = 0; i < npools; ++i) { int ret = snprintf(path, length, "%s"OS_DIR_SEP_STR"testfile%d", dir, i); if (ret < 0 || ret >= length) UT_FATAL("!snprintf"); pops[i] = pmemobj_create(path, LAYOUT_NAME, PMEMOBJ_MIN_POOL, S_IWUSR | S_IRUSR); if (pops[i] == NULL) UT_FATAL("!pmemobj_create"); } PMEMoid *oids = MALLOC(npools * sizeof(PMEMoid)); UT_ASSERTne(oids, NULL); PMEMoid *tmpoids = MALLOC(npools * sizeof(PMEMoid)); UT_ASSERTne(tmpoids, NULL); oids[0] = OID_NULL; UT_ASSERTeq(obj_direct(oids[0]), NULL); for (unsigned i = 0; i < npools; ++i) { oids[i] = (PMEMoid) {pops[i]->uuid_lo, 0}; UT_ASSERTeq(obj_direct(oids[i]), NULL); uint64_t off = pops[i]->heap_offset; oids[i] = (PMEMoid) {pops[i]->uuid_lo, off}; UT_ASSERTeq((char *)obj_direct(oids[i]) - off, (char *)pops[i]); r = pmemobj_alloc(pops[i], &tmpoids[i], 100, 1, NULL, NULL); UT_ASSERTeq(r, 0); } r = pmemobj_alloc(pops[0], &thread_oid, 100, 2, NULL, NULL); UT_ASSERTeq(r, 0); UT_ASSERTne(obj_direct(thread_oid), NULL); os_thread_t t; PTHREAD_CREATE(&t, NULL, test_worker, NULL); /* wait for the worker thread to perform the first check */ os_mutex_lock(&lock1); while (!cond1) os_cond_wait(&sync_cond1, &lock1); os_mutex_unlock(&lock1); for (unsigned i = 0; i < npools; ++i) { UT_ASSERTne(obj_direct(tmpoids[i]), NULL); pmemobj_free(&tmpoids[i]); UT_ASSERTeq(obj_direct(tmpoids[i]), NULL); pmemobj_close(pops[i]); UT_ASSERTeq(obj_direct(oids[i]), NULL); } /* signal the worker that we're free and closed */ os_mutex_lock(&lock2); cond2 = 1; os_cond_signal(&sync_cond2); os_mutex_unlock(&lock2); PTHREAD_JOIN(&t, NULL); os_cond_destroy(&sync_cond1); os_cond_destroy(&sync_cond2); os_mutex_destroy(&lock1); os_mutex_destroy(&lock2); FREE(pops); FREE(tmpoids); FREE(oids); DONE(NULL); }
~LockedQueue() { destroy(_items, _capacity); os_mutex_destroy(_mutex); os_cond_destroy(_cond); }