void socket_unregister(socket_t *socket) {
assert(socket != NULL);
if (socket->reactor_object)
reactor_unregister(socket->reactor_object);
socket->reactor_object = NULL;
}
void eager_reader_unregister(eager_reader_t *reader) {
assert(reader != NULL);
if (reader->outbound_registration) {
reactor_unregister(reader->outbound_registration);
reader->outbound_registration = NULL;
}
}
int32_t connector_stop(connector_t* con)
{
if (!con || con->h.fd < 0) return -1;
reactor_unregister(con->r, &con->h);
sock_close(con->h.fd);
con->h.fd = -1;
return 0;
}
static void *run_thread(void *start_arg) {
assert(start_arg != NULL);
struct start_arg *start = start_arg;
thread_t *thread = start->thread;
assert(thread != NULL);
if (prctl(PR_SET_NAME, (unsigned long)thread->name) == -1) {
LOG_ERROR("%s unable to set thread name: %s", __func__, strerror(errno));
start->error = errno;
semaphore_post(start->start_sem);
return NULL;
}
thread->tid = gettid();
semaphore_post(start->start_sem);
int fd = fixed_queue_get_dequeue_fd(thread->work_queue);
void *context = thread->work_queue;
reactor_object_t *work_queue_object = reactor_register(thread->reactor, fd, context, work_queue_read_cb, NULL);
reactor_start(thread->reactor);
reactor_unregister(work_queue_object);
// Make sure we dispatch all queued work items before exiting the thread.
// This allows a caller to safely tear down by enqueuing a teardown
// work item and then joining the thread.
size_t count = 0;
work_item_t *item = fixed_queue_try_dequeue(thread->work_queue);
while (item && count <= fixed_queue_capacity(thread->work_queue)) {
item->func(item->context);
osi_free(item);
item = fixed_queue_try_dequeue(thread->work_queue);
++count;
}
if (count > fixed_queue_capacity(thread->work_queue))
LOG_DEBUG("%s growing event queue on shutdown.", __func__);
return NULL;
}
void eager_reader_free(eager_reader_t *reader) {
if (!reader)
return;
eager_reader_unregister(reader);
// Only unregister from the input if we actually did register
if (reader->inbound_read_object)
reactor_unregister(reader->inbound_read_object);
if (reader->bytes_available_fd != INVALID_FD)
close(reader->bytes_available_fd);
// Free the current buffer, because it's not in the queue
// and won't be freed below
if (reader->current_buffer)
reader->allocator->free(reader->current_buffer);
fixed_queue_free(reader->buffers, reader->allocator->free);
thread_free(reader->inbound_read_thread);
osi_free(reader);
}
