/* * note: the socket must be in non-blocking mode, or the call might block while the mutex is being locked */ int cloexec_accept(int socket, struct sockaddr *addr, socklen_t *addrlen) { int fd = -1; #ifndef _MSC_VER pthread_mutex_lock(&cloexec_mutex); #else uv_mutex_lock(&cloexec_mutex); #endif if ((fd = accept(socket, addr, addrlen)) == -1) goto Exit; if (set_cloexec(fd) != 0) { closesocket(fd); fd = -1; goto Exit; } Exit: #ifndef _MSC_VER pthread_mutex_unlock(&cloexec_mutex); #else uv_mutex_unlock(&cloexec_mutex); #endif return fd; }
int pc_add_listener(pc_client_t *client, const char *event, pc_event_cb event_cb) { if(PC_ST_CLOSED == client->state) { LOGD( "Pomelo client has closed.\n"); return -1; } pc_listener_t *listener = pc_listener_new(); if(listener == NULL) { LOGD( "Fail to create listener.\n"); return -1; } listener->cb = event_cb; uv_mutex_lock(&client->listener_mutex); ngx_queue_t *head = pc_map_get(client->listeners, event); if(head == NULL) { head = (ngx_queue_t *)malloc(sizeof(ngx_queue_t)); if(head == NULL) { LOGD( "Fail to create listener queue.\n"); pc_listener_destroy(listener); return -1; } ngx_queue_init(head); pc_map_set(client->listeners, event, head); } ngx_queue_insert_tail(head, &listener->queue); uv_mutex_unlock(&client->listener_mutex); return 0; }
void Adapter::cleanUpV8Resources() { uv_mutex_lock(adapterCloseMutex); if (asyncStatus != nullptr) { auto handle = reinterpret_cast<uv_handle_t *>(asyncStatus); uv_close(handle, [](uv_handle_t *handle) { delete handle; }); this->statusCallback.reset(); asyncStatus = nullptr; } if (eventIntervalTimer != nullptr) { // Deallocate resources related to the event handling interval timer if (uv_timer_stop(eventIntervalTimer) != 0) { std::terminate(); } auto handle = reinterpret_cast<uv_handle_t *>(eventIntervalTimer); uv_close(handle, [](uv_handle_t *handle) { delete handle; }); eventIntervalTimer = nullptr; } if (asyncEvent != nullptr) { auto handle = reinterpret_cast<uv_handle_t *>(asyncEvent); uv_close(handle, [](uv_handle_t *handle) { delete handle; }); this->eventCallback.reset(); asyncEvent = nullptr; } if (asyncLog != nullptr) { auto logHandle = reinterpret_cast<uv_handle_t *>(asyncLog); uv_close(logHandle, [](uv_handle_t *handle) { delete handle; }); this->logCallback.reset(); asyncLog = nullptr; } uv_mutex_unlock(adapterCloseMutex); }
int status_wait(Status* status, uint64_t timeout_secs) { int count; uv_mutex_lock(&status->mutex); uv_cond_timedwait(&status->cond, &status->mutex, timeout_secs * 1000 * 1000 * 1000); count = status->count; uv_mutex_unlock(&status->mutex); return count; }
static int uv__custom_sem_trywait(uv_sem_t* sem_) { uv_semaphore_t* sem; sem = *(uv_semaphore_t**)sem_; if (uv_mutex_trylock(&sem->mutex) != 0) return UV_EAGAIN; if (sem->value == 0) { uv_mutex_unlock(&sem->mutex); return UV_EAGAIN; } sem->value--; uv_mutex_unlock(&sem->mutex); return 0; }
inline static void uv__rwlock_fallback_rdlock(uv_rwlock_t* rwlock) { uv_mutex_lock(&rwlock->fallback_.read_mutex_); if (++rwlock->fallback_.num_readers_ == 1) uv_mutex_lock(&rwlock->fallback_.write_mutex_); uv_mutex_unlock(&rwlock->fallback_.read_mutex_); }
void udprelay_close(struct server_context *server) { uv_poll_stop(&server->watcher); close(server->udp_fd); uv_mutex_lock(&mutex); cache_removeall(cache, server->udp.loop, select_cb); uv_mutex_unlock(&mutex); }
void Workers::submit(const JobResult &result) { uv_mutex_lock(&m_mutex); m_queue.push_back(result); uv_mutex_unlock(&m_mutex); uv_async_send(&m_async); }
size_t Workers::hugePages() { uv_mutex_lock(&m_mutex); const size_t hugePages = m_status.hugePages; uv_mutex_unlock(&m_mutex); return hugePages; }
size_t Workers::threads() { uv_mutex_lock(&m_mutex); const size_t threads = m_status.threads; uv_mutex_unlock(&m_mutex); return threads; }
static void WaitForDeviceHandled() { uv_mutex_lock(¬ify_mutex); if(deviceHandled == false) { uv_cond_wait(¬ifyDeviceHandled, ¬ify_mutex); } deviceHandled = false; uv_mutex_unlock(¬ify_mutex); }
void RecursiveLockGuard::release() { void* lkey = uv_key_get(mutex_key); if (lkey) { uv_mutex_unlock(mutex); uv_key_set(mutex_key, 0); } locked = false; }
/* * TODO: last waiter frees descriptor ? */ void pg_cache_punch_hole(struct rrdengine_instance *ctx, struct rrdeng_page_cache_descr *descr) { struct page_cache *pg_cache = &ctx->pg_cache; Pvoid_t *PValue; struct pg_cache_page_index *page_index; int ret; uv_rwlock_rdlock(&pg_cache->metrics_index.lock); PValue = JudyHSGet(pg_cache->metrics_index.JudyHS_array, descr->id, sizeof(uuid_t)); assert(NULL != PValue); page_index = *PValue; uv_rwlock_rdunlock(&pg_cache->metrics_index.lock); uv_rwlock_wrlock(&page_index->lock); ret = JudyLDel(&page_index->JudyL_array, (Word_t)(descr->start_time / USEC_PER_SEC), PJE0); uv_rwlock_wrunlock(&page_index->lock); if (unlikely(0 == ret)) { error("Page under deletion was not in index."); if (unlikely(debug_flags & D_RRDENGINE)) print_page_cache_descr(descr); goto destroy; } assert(1 == ret); uv_rwlock_wrlock(&pg_cache->pg_cache_rwlock); ++ctx->stats.pg_cache_deletions; --pg_cache->page_descriptors; uv_rwlock_wrunlock(&pg_cache->pg_cache_rwlock); uv_mutex_lock(&descr->mutex); while (!pg_cache_try_get_unsafe(descr, 1)) { debug(D_RRDENGINE, "%s: Waiting for locked page:", __func__); if(unlikely(debug_flags & D_RRDENGINE)) print_page_cache_descr(descr); pg_cache_wait_event_unsafe(descr); } /* even a locked page could be dirty */ while (unlikely(descr->flags & RRD_PAGE_DIRTY)) { debug(D_RRDENGINE, "%s: Found dirty page, waiting for it to be flushed:", __func__); if (unlikely(debug_flags & D_RRDENGINE)) print_page_cache_descr(descr); pg_cache_wait_event_unsafe(descr); } uv_mutex_unlock(&descr->mutex); if (descr->flags & RRD_PAGE_POPULATED) { /* only after locking can it be safely deleted from LRU */ pg_cache_replaceQ_delete(ctx, descr); uv_rwlock_wrlock(&pg_cache->pg_cache_rwlock); pg_cache_evict_unsafe(ctx, descr); uv_rwlock_wrunlock(&pg_cache->pg_cache_rwlock); } pg_cache_put(descr); destroy: pg_cache_destroy_descr(descr); pg_cache_update_metric_times(page_index); }
// send data to the grapher app void graph_thread(void* user) { Graph* g = static_cast<Graph*>(user); int sock = nn_socket(AF_SP, NN_PUSH); if(sock == -1) { printf("error: cannot create client socket.\n"); return; } int rc = nn_connect(sock, g->address.c_str()); if(rc < 0) { printf("error: cannot connect, %s\n", nn_strerror(errno)); return; } std::vector<GraphPacket*> todo; while(true) { // get the work! uv_mutex_lock(&g->mutex); { while(g->work.size() == 0) { uv_cond_wait(&g->cv, &g->mutex); } std::copy(g->work.begin(), g->work.end(), std::back_inserter(todo)); g->work.clear(); } uv_mutex_unlock(&g->mutex); // perform work bool must_stop = false; for(std::vector<GraphPacket*>::iterator it = todo.begin(); it != todo.end(); ++it) { GraphPacket* p = *it; if(p->data[0] == PKT_TYPE_STOP) { must_stop = true; break; } else { int rc = nn_send(sock, (char*)&p->data.front(), p->data.size(), 0); if(rc < 0) { printf("error: cannot send to grapher: %s\n", nn_strerror(rc)); } } delete p; p = NULL; } // for todo.clear(); if(must_stop) { break; } } printf("@todo -> cleanup socket.\n"); }
static void worker(void* arg) { printf("worker\n"); worker_config* wc = (worker_config*) arg; uv_mutex_lock(&wc->mutex); uv_cond_signal(&wc->cond); uv_mutex_unlock(&wc->mutex); }
void EventStream::add(Event * event) { uv_mutex_lock(&mutex); eventVector.push_back(event); uv_ref(reinterpret_cast<uv_handle_t *>(&async)); uv_mutex_unlock(&mutex); uv_async_send(&async); }
void nub_thread_dispose(nub_thread_t* thread, nub_thread_disposed_cb cb) { thread->disposed = 1; thread->disposed_cb_ = cb; thread->nubloop->disposed_ = 1; uv_mutex_lock(&thread->nubloop->thread_dispose_lock_); fuq_enqueue(&thread->nubloop->thread_dispose_queue_, thread); uv_mutex_unlock(&thread->nubloop->thread_dispose_lock_); uv_async_send(thread->nubloop->work_ping_); }
void wait_exit() { uv_mutex_lock(&mutex); while (close_future == NULL) { uv_cond_wait(&cond, &mutex); } uv_mutex_unlock(&mutex); cass_future_wait(close_future); cass_future_free(close_future); }
void iobuf_remove(struct iobuf_t *io, size_t n) { uv_mutex_lock(&io->lock); if(n > 0 && n <= io->len) { memmove(io->buf, io->buf + n, io->len - n); io->len -= n; io->buf[io->len] = 0; } uv_mutex_unlock(&io->lock); }
void signal_exit(CassSession* session) { uv_mutex_lock(&mutex); if (session) { close_future = cass_session_close(session); } exit_flag = 1; uv_cond_signal(&cond); uv_mutex_unlock(&mutex); }
void uv_chan_send(uv_chan_t *chan, void *data) { uv__chan_item_t *item = (uv__chan_item_t *)malloc(sizeof(uv__chan_item_t)); item->data = data; uv_mutex_lock(&chan->mutex); QUEUE_INSERT_TAIL(&chan->q, &item->active_queue); uv_cond_signal(&chan->cond); uv_mutex_unlock(&chan->mutex); }
void rtb_window_unlock(struct rtb_window *rwin) { struct xrtb_window *self = RTB_WINDOW_AS(rwin, xrtb_window); glXMakeContextCurrent(self->xrtb->dpy, None, None, NULL); XUnlockDisplay(self->xrtb->dpy); uv_mutex_unlock(&self->lock); }
static void lock_callback(int mode, int type, const char *file, int line) { if (mode & CRYPTO_LOCK) { uv_mutex_lock(&(g_pMutex[type])); } else { uv_mutex_unlock(&(g_pMutex[type])); } }
bool Kinect::setup() { if(ctx) { printf("Error: the freenect context has been setup already.\n"); return false; } if(freenect_init(&ctx, NULL) < 0) { printf("Error: cannot init libfreenect.\n"); return false; } freenect_set_log_level(ctx, FREENECT_LOG_DEBUG); int ndevices = freenect_num_devices(ctx); if(ndevices < 1) { printf("Error: cannot find a kinect. @todo cleanup mem.\n"); freenect_shutdown(ctx); ctx = NULL; return false; } printf("Number of found kinect devices: %d\n", ndevices); freenect_select_subdevices(ctx, (freenect_device_flags)(FREENECT_DEVICE_MOTOR | FREENECT_DEVICE_CAMERA)); //freenect_select_subdevices(ctx, (freenect_device_flags)( FREENECT_DEVICE_CAMERA)); int devnum = 0; if(freenect_open_device(ctx, &device, devnum) < 0) { printf("Error: cannot open device: %d\n", devnum); freenect_shutdown(ctx); ctx = NULL; return false; } freenect_set_user(device, this); uint32_t w = 640; uint32_t h = 480; uint32_t nbytes = w * h * 3; nbytes_rgb = nbytes; rgb_back = new uint8_t[nbytes]; rgb_mid = new uint8_t[nbytes]; rgb_front = new uint8_t[nbytes]; depth_back = new uint8_t[nbytes]; depth_mid = new uint8_t[nbytes]; depth_front = new uint8_t[nbytes]; uv_mutex_lock(&mutex); must_stop = false; uv_mutex_unlock(&mutex); uv_thread_create(&thread, kinect_thread, this); return true; }
int CAudioDecoder::put(cc_src_sample_t buf) { int ret = 0; uv_mutex_lock(&queue_mutex); if (buf_deque.size() > 50){ uv_mutex_unlock(&queue_mutex); free(buf.buf); return ret; } buf_deque.push_back(buf); iFrame++; uv_mutex_unlock(&queue_mutex); uv_cond_signal(&queue_not_empty); if (!bOpen && buf_deque.size() > 0){ open(); } return ret; }
MVMObject * MVM_dll_find_symbol(MVMThreadContext *tc, MVMString *lib, MVMString *sym) { MVMDLLRegistry *entry; MVMDLLSym *obj; char *csym; void *address; uv_mutex_lock(&tc->instance->mutex_dll_registry); MVM_string_flatten(tc, lib); MVM_HASH_GET(tc, tc->instance->dll_registry, lib, entry); if (!entry) { uv_mutex_unlock(&tc->instance->mutex_dll_registry); MVM_exception_throw_adhoc(tc, "cannot find symbol in non-existent library"); } if (!entry->lib) { uv_mutex_unlock(&tc->instance->mutex_dll_registry); MVM_exception_throw_adhoc(tc, "cannot find symbol in unloaded library"); } csym = MVM_string_utf8_encode_C_string(tc, sym); address = dlFindSymbol(entry->lib, csym); free(csym); if (!address) { uv_mutex_unlock(&tc->instance->mutex_dll_registry); return NULL; } obj = (MVMDLLSym *)MVM_repr_alloc_init(tc, tc->instance->raw_types.RawDLLSym); obj->body.address = address; obj->body.dll = entry; entry->refcount++; uv_mutex_unlock(&tc->instance->mutex_dll_registry); return (MVMObject *)obj; }
static void async_cb(uv_async_t *handle) { Loop *l = handle->loop->data; uv_mutex_lock(&l->mutex); while (!multiqueue_empty(l->thread_events)) { Event ev = multiqueue_get(l->thread_events); multiqueue_put_event(l->fast_events, ev); } uv_mutex_unlock(&l->mutex); }
static void uv__custom_sem_post(uv_sem_t* sem_) { uv_semaphore_t* sem; sem = *(uv_semaphore_t**)sem_; uv_mutex_lock(&sem->mutex); sem->value++; if (sem->value == 1) uv_cond_signal(&sem->cond); uv_mutex_unlock(&sem->mutex); }
static void _dynlock_lock_callback (int mode, CRYPTO_dynlock_value* self, const char* file, int line) { if (mode & CRYPTO_LOCK) { uv_mutex_lock(self->lock); } else { uv_mutex_unlock(self->lock); } }
static void uv__custom_sem_wait(uv_sem_t* sem_) { uv_semaphore_t* sem; sem = *(uv_semaphore_t**)sem_; uv_mutex_lock(&sem->mutex); while (sem->value == 0) uv_cond_wait(&sem->cond, &sem->mutex); sem->value--; uv_mutex_unlock(&sem->mutex); }