/**
* etch_apr_queue_unsafe_interrupt_all()
* added by Cisco to opeate when lock already held since queue lock is not nestable.
*/
apr_status_t etch_apr_queue_unsafe_interrupt_all(etch_apr_queue_t *queue)
{
Q_DBG("intr all", queue);
apr_thread_cond_broadcast(queue->not_empty);
apr_thread_cond_broadcast(queue->not_full);
return APR_SUCCESS;
}
apr_status_t etch_apr_queue_interrupt_all(etch_apr_queue_t *queue)
{
apr_status_t rv;
Q_DBG("intr all", queue);
if (APR_SUCCESS == (rv = apr_thread_mutex_lock(queue->one_big_mutex)))
{
apr_thread_cond_broadcast(queue->not_empty);
apr_thread_cond_broadcast(queue->not_full);
apr_thread_mutex_unlock(queue->one_big_mutex);
}
return rv;
}
apr_status_t h2_beam_send(h2_bucket_beam *beam,
apr_bucket_brigade *red_brigade,
apr_read_type_e block)
{
apr_bucket *bred;
apr_status_t status = APR_SUCCESS;
h2_beam_lock bl;
/* Called from the red thread to add buckets to the beam */
if (enter_yellow(beam, &bl) == APR_SUCCESS) {
r_purge_reds(beam);
if (beam->aborted) {
status = APR_ECONNABORTED;
}
else if (red_brigade) {
int force_report = !APR_BRIGADE_EMPTY(red_brigade);
while (!APR_BRIGADE_EMPTY(red_brigade)
&& status == APR_SUCCESS) {
bred = APR_BRIGADE_FIRST(red_brigade);
status = append_bucket(beam, bred, block, beam->red_pool, &bl);
}
report_production(beam, force_report);
if (beam->m_cond) {
apr_thread_cond_broadcast(beam->m_cond);
}
}
report_consumption(beam, 0);
leave_yellow(beam, &bl);
}
return status;
}
apr_status_t h2_beam_shutdown(h2_bucket_beam *beam, apr_read_type_e block)
{
apr_status_t status;
h2_beam_lock bl;
if ((status = enter_yellow(beam, &bl)) == APR_SUCCESS) {
r_purge_reds(beam);
h2_blist_cleanup(&beam->red);
beam_close(beam);
report_consumption(beam, 0);
while (status == APR_SUCCESS
&& (!H2_BPROXY_LIST_EMPTY(&beam->proxies)
|| (beam->green && !APR_BRIGADE_EMPTY(beam->green)))) {
if (block == APR_NONBLOCK_READ || !bl.mutex) {
status = APR_EAGAIN;
break;
}
if (beam->m_cond) {
apr_thread_cond_broadcast(beam->m_cond);
}
status = wait_cond(beam, bl.mutex);
}
leave_yellow(beam, &bl);
}
return status;
}
void single_gop_mark_completed(op_generic_t *gop, op_status_t status)
{
op_common_t *base = &(gop->base);
int mode;
log_printf(15, "gop_mark_completed: START gid=%d status=%d\n", gop_id(gop), status.op_status);
lock_gop(gop);
log_printf(15, "gop_mark_completed: after lock gid=%d\n", gop_id(gop));
//** Store the status
base->status = status;
//** and trigger any callbacks
log_printf(15, "gop_mark_completed: before cb gid=%d op_status=%d\n", gop_id(gop), base->status.op_status);
callback_execute(base->cb, base->status.op_status);
log_printf(15, "gop_mark_completed: after cb gid=%d op_success=%d\n", gop_id(gop), base->status.op_status);
base->state = 1;
//** Lastly trigger the signal. for anybody listening
apr_thread_cond_broadcast(gop->base.ctl->cond);
log_printf(15, "gop_mark_completed: after brodcast gid=%d\n", gop_id(gop));
mode = gop_get_auto_destroy(gop); //** Get the auto destroy status w/in the lock
unlock_gop(gop);
//** Check if we do an auto cleanop
if (mode == 1) gop_free(gop, OP_DESTROY);
}
static void pong(toolbox_t *box)
{
apr_status_t rv;
abts_case *tc = box->tc;
rv = apr_thread_mutex_lock(box->mutex);
ABTS_SUCCESS(rv);
if (state == TOSS)
state = PONG;
do {
rv = apr_thread_cond_signal(box->cond);
ABTS_SUCCESS(rv);
state = PING;
rv = apr_thread_cond_wait(box->cond, box->mutex);
ABTS_SUCCESS(rv);
ABTS_TRUE(tc, state == PONG || state == OVER);
} while (state != OVER);
rv = apr_thread_mutex_unlock(box->mutex);
ABTS_SUCCESS(rv);
rv = apr_thread_cond_broadcast(box->cond);
ABTS_SUCCESS(rv);
}
static apr_size_t trim_idle_threads(apr_thread_pool_t *me, apr_size_t cnt)
{
apr_size_t n_dbg;
struct apr_thread_list_elt *elt, *head, *tail;
apr_status_t rv;
elt = trim_threads(me, &cnt, 1);
apr_thread_mutex_lock(me->lock);
apr_thread_cond_broadcast(me->cond);
apr_thread_mutex_unlock(me->lock);
n_dbg = 0;
if (NULL != (head = elt)) {
while (elt) {
tail = elt;
apr_thread_join(&rv, elt->thd);
elt = APR_RING_NEXT(elt, link);
++n_dbg;
}
apr_thread_mutex_lock(me->lock);
APR_RING_SPLICE_TAIL(me->recycled_thds, head, tail,
apr_thread_list_elt, link);
apr_thread_mutex_unlock(me->lock);
}
assert(cnt == n_dbg);
return cnt;
}
static void broadcast_threads(abts_case *tc, void *data)
{
toolbox_t box;
unsigned int i;
apr_status_t rv;
apr_uint32_t count = 0;
apr_thread_cond_t *cond = NULL;
apr_thread_mutex_t *mutex = NULL;
apr_thread_t *thread[NTHREADS];
rv = apr_thread_cond_create(&cond, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, cond);
rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, mutex);
rv = apr_thread_mutex_lock(mutex);
ABTS_SUCCESS(rv);
box.tc = tc;
box.data = &count;
box.mutex = mutex;
box.cond = cond;
box.func = lock_and_wait;
for (i = 0; i < NTHREADS; i++) {
rv = apr_thread_create(&thread[i], NULL, thread_routine, &box, p);
ABTS_SUCCESS(rv);
}
do {
rv = apr_thread_mutex_unlock(mutex);
ABTS_SUCCESS(rv);
apr_sleep(100000);
rv = apr_thread_mutex_lock(mutex);
ABTS_SUCCESS(rv);
} while (apr_atomic_read32(&count) != NTHREADS);
rv = apr_thread_cond_broadcast(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_unlock(mutex);
ABTS_SUCCESS(rv);
for (i = 0; i < NTHREADS; i++) {
apr_status_t retval;
rv = apr_thread_join(&retval, thread[i]);
ABTS_SUCCESS(rv);
}
ABTS_INT_EQUAL(tc, 0, count);
rv = apr_thread_cond_destroy(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_destroy(mutex);
ABTS_SUCCESS(rv);
}
void rs_simple_destroy(resource_service_fn_t *rs)
{
rs_simple_priv_t *rss = (rs_simple_priv_t *)rs->priv;
apr_status_t value;
log_printf(15, "rs_simple_destroy: sl=%p\n", rss->rid_table);
tbx_log_flush();
//** Notify the depot check thread
apr_thread_mutex_lock(rss->lock);
rss->shutdown = 1;
apr_thread_cond_broadcast(rss->cond);
apr_thread_mutex_unlock(rss->lock);
//** Wait for it to shutdown
apr_thread_join(&value, rss->check_thread);
//** Now we can free up all the space
apr_thread_mutex_destroy(rss->lock);
apr_thread_cond_destroy(rss->cond);
apr_pool_destroy(rss->mpool); //** This also frees the hash tables
if (rss->rid_table != NULL) tbx_list_destroy(rss->rid_table);
free(rss->random_array);
free(rss->fname);
free(rss);
free(rs);
}
APU_DECLARE(apr_status_t) apr_queue_interrupt_all(apr_queue_t *queue)
{
apr_status_t rv;
Q_DBG("intr all", queue);
if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {
return rv;
}
apr_thread_cond_broadcast(queue->not_empty);
apr_thread_cond_broadcast(queue->not_full);
if ((rv = apr_thread_mutex_unlock(queue->one_big_mutex)) != APR_SUCCESS) {
return rv;
}
return APR_SUCCESS;
}
static int
on_topic_add_discard(SESSION_T *session, void *context)
{
apr_thread_mutex_lock(mutex);
apr_thread_cond_broadcast(cond);
apr_thread_mutex_unlock(mutex);
return HANDLER_SUCCESS;
}
op_status_t mqs_response_client_more(void *task_arg, int tid)
{
mq_task_t *task = (mq_task_t *)task_arg;
mq_stream_t *mqs = (mq_stream_t *)task->arg;
op_status_t status = op_success_status;
log_printf(5, "START msid=%d\n", mqs->msid);
//** Parse the response
mq_remove_header(task->response, 1);
//** Wait for a notification that the data can be processed
apr_thread_mutex_lock(mqs->lock);
log_printf(5, "INIT STATUS msid=%d waiting=%d processed=%d\n", mqs->msid, mqs->waiting, mqs->processed);
mqs->transfer_packets++;
mqs->waiting = 0;
apr_thread_cond_broadcast(mqs->cond);
//** Now wait until the application is ready
while (mqs->waiting == 0) {
apr_thread_cond_wait(mqs->cond, mqs->lock);
}
//** Can accept the data
mq_get_frame(mq_msg_first(task->response), (void **)&(mqs->data), &(mqs->len));
pack_read_new_data(mqs->pack, &(mqs->data[MQS_HEADER]), mqs->len-MQS_HEADER);
//** Notify the consumer it's available
mqs->waiting = -2;
apr_thread_cond_broadcast(mqs->cond);
//** Wait until it's consumed
while (mqs->processed == 0) {
apr_thread_cond_wait(mqs->cond, mqs->lock);
}
mqs->data = NULL; //** Nullify the data so it's not accidentally accessed
mqs->processed = 0; //** and reset the processed flag back to 0
apr_thread_mutex_unlock(mqs->lock);
log_printf(5, "END msid=%d status=%d %d\n", mqs->msid, status.op_status, status.error_code);
return(status);
}
static int
on_topic_removed(SESSION_T *session, const SVC_REMOVE_TOPICS_RESPONSE_T *response, void *context)
{
puts("on_topic_removed");
apr_thread_mutex_lock(mutex);
apr_thread_cond_broadcast(cond);
apr_thread_mutex_unlock(mutex);
return HANDLER_SUCCESS;
}
static int
on_topic_add_failed(SESSION_T *session, const SVC_ADD_TOPIC_RESPONSE_T *response, void *context)
{
printf("Failed to add topic (%d)\n", response->response_code);
apr_thread_mutex_lock(mutex);
apr_thread_cond_broadcast(cond);
apr_thread_mutex_unlock(mutex);
return HANDLER_SUCCESS;
}
apr_status_t ap_queue_interrupt_all(fd_queue_t *queue)
{
apr_status_t rv;
if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {
return rv;
}
apr_thread_cond_broadcast(queue->not_empty);
return apr_thread_mutex_unlock(queue->one_big_mutex);
}
static apr_status_t beam_close(h2_bucket_beam *beam)
{
if (!beam->closed) {
beam->closed = 1;
if (beam->m_cond) {
apr_thread_cond_broadcast(beam->m_cond);
}
}
return APR_SUCCESS;
}
apr_status_t ap_queue_info_term(fd_queue_info_t *queue_info)
{
apr_status_t rv;
rv = apr_thread_mutex_lock(queue_info->idlers_mutex);
if (rv != APR_SUCCESS) {
return rv;
}
queue_info->terminated = 1;
apr_thread_cond_broadcast(queue_info->wait_for_idler);
return apr_thread_mutex_unlock(queue_info->idlers_mutex);
}
static int
on_update_source_deregistered(SESSION_T *session,
const CONVERSATION_ID_T *updater_id,
void *context)
{
char *id_str = conversation_id_to_string(*updater_id);
printf("Deregistered update source \"%s\"\n", id_str);
free(id_str);
apr_thread_mutex_lock(mutex);
apr_thread_cond_broadcast(cond);
apr_thread_mutex_unlock(mutex);
return HANDLER_SUCCESS;}
/**
* Callback invoked when/if a message is sent on the topic that the
* client is writing to.
*/
static int
on_send(SESSION_T *session, void *context)
{
printf("on_send() successful. Context=\"%s\".\n", (char *)context);
// Allow main thread to continue.
apr_thread_mutex_lock(mutex);
apr_thread_cond_broadcast(cond);
apr_thread_mutex_unlock(mutex);
return HANDLER_SUCCESS;
}
void gop_finished_submission(op_generic_t *g)
{
lock_gop(g);
if (gop_get_type(g) == Q_TYPE_QUE) {
g->q->finished_submission = 1;
//** If nothing left to do trigger the condition in case anyone's waiting
if (g->q->nleft == 0) {
apr_thread_cond_broadcast(g->base.ctl->cond);
}
}
unlock_gop(g);
}
/*
* Handlers for registration of update source feature
*/
static int
on_update_source_init(SESSION_T *session,
const CONVERSATION_ID_T *updater_id,
const SVC_UPDATE_REGISTRATION_RESPONSE_T *response,
void *context)
{
char *id_str = conversation_id_to_string(*updater_id);
printf("Topic source \"%s\" in init state\n", id_str);
free(id_str);
apr_thread_mutex_lock(mutex);
apr_thread_cond_broadcast(cond);
apr_thread_mutex_unlock(mutex);
return HANDLER_SUCCESS;
}
void h2_beam_abort(h2_bucket_beam *beam)
{
h2_beam_lock bl;
if (enter_yellow(beam, &bl) == APR_SUCCESS) {
r_purge_reds(beam);
h2_blist_cleanup(&beam->red);
beam->aborted = 1;
report_consumption(beam, 0);
if (beam->m_cond) {
apr_thread_cond_broadcast(beam->m_cond);
}
leave_yellow(beam, &bl);
}
}
static void lost_signal(abts_case *tc, void *data)
{
apr_status_t rv;
apr_thread_cond_t *cond = NULL;
apr_thread_mutex_t *mutex = NULL;
rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, mutex);
rv = apr_thread_cond_create(&cond, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, cond);
rv = apr_thread_cond_signal(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_lock(mutex);
ABTS_SUCCESS(rv);
rv = apr_thread_cond_timedwait(cond, mutex, 10000);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
rv = apr_thread_mutex_unlock(mutex);
ABTS_SUCCESS(rv);
rv = apr_thread_cond_broadcast(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_lock(mutex);
ABTS_SUCCESS(rv);
rv = apr_thread_cond_timedwait(cond, mutex, 10000);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
rv = apr_thread_mutex_unlock(mutex);
ABTS_SUCCESS(rv);
rv = apr_thread_cond_destroy(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_destroy(mutex);
ABTS_SUCCESS(rv);
}
void gop_dummy_destroy()
{
apr_status_t tstat;
//** Signal a shutdown
apr_thread_mutex_lock(gd_lock);
gd_shutdown = 1;
apr_thread_cond_broadcast(gd_cond);
apr_thread_mutex_unlock(gd_lock);
//** Wait for the thread to complete
apr_thread_join(&tstat, gd_thread);
//** Clean up;
free_stack(gd_stack, 0);
apr_thread_mutex_destroy(gd_lock);
apr_thread_cond_destroy(gd_cond);
apr_pool_destroy(gd_pool);
}
void rss_mapping_notify(resource_service_fn_t *rs, int new_version, int status_change)
{
rs_simple_priv_t *rss = (rs_simple_priv_t *)rs->priv;
apr_hash_index_t *hi;
rs_mapping_notify_t *rsn;
apr_ssize_t klen;
void *rid;
if (status_change > 0) status_change = tbx_random_get_int64(0, 100000);
apr_thread_mutex_lock(rss->update_lock);
for (hi = apr_hash_first(NULL, rss->mapping_updates); hi != NULL; hi = apr_hash_next(hi)) {
apr_hash_this(hi, (const void **)&rid, &klen, (void **)&rsn);
apr_thread_mutex_lock(rsn->lock);
rsn->map_version = new_version;
if (status_change > 0) rsn->status_version = status_change;
apr_thread_cond_broadcast(rsn->cond);
apr_thread_mutex_unlock(rsn->lock);
}
apr_thread_mutex_unlock(rss->update_lock);
}
void LLConditionVariableImpl::notify_all()
{
APRExceptionThrower(apr_thread_cond_broadcast(mConditionVariableImpl));
}
static void pipe_producer_consumer(abts_case *tc, void *data)
{
apr_status_t rv;
toolbox_t boxcons, boxprod;
apr_thread_t *thread[NTHREADS];
apr_thread_cond_t *cond = NULL;
apr_thread_mutex_t *mutex = NULL;
apr_file_t *in = NULL, *out = NULL;
apr_uint32_t i, ncons = (apr_uint32_t)(NTHREADS * 0.70);
rv = apr_file_pipe_create(&in, &out, p);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, mutex);
rv = apr_thread_cond_create(&cond, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, cond);
boxcons.tc = tc;
boxcons.data = in;
boxcons.mutex = mutex;
boxcons.cond = cond;
boxcons.func = pipe_consumer;
for (i = 0; i < ncons; i++) {
rv = apr_thread_create(&thread[i], NULL, thread_routine, &boxcons, p);
ABTS_SUCCESS(rv);
}
boxprod.tc = tc;
boxprod.data = out;
boxprod.mutex = mutex;
boxprod.cond = cond;
boxprod.func = pipe_producer;
for (; i < NTHREADS; i++) {
rv = apr_thread_create(&thread[i], NULL, thread_routine, &boxprod, p);
ABTS_SUCCESS(rv);
}
for (i = ncons; i < NTHREADS; i++) {
apr_status_t retval;
rv = apr_thread_join(&retval, thread[i]);
ABTS_SUCCESS(rv);
}
rv = apr_thread_mutex_lock(mutex);
ABTS_SUCCESS(rv);
exiting = 1;
rv = apr_thread_cond_broadcast(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_unlock(mutex);
ABTS_SUCCESS(rv);
for (i = 0; i < ncons; i++) {
apr_status_t retval;
rv = apr_thread_join(&retval, thread[i]);
ABTS_SUCCESS(rv);
}
rv = apr_thread_cond_destroy(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_destroy(mutex);
ABTS_SUCCESS(rv);
rv = apr_file_close(in);
ABTS_SUCCESS(rv);
rv = apr_file_close(out);
ABTS_SUCCESS(rv);
}
void LLCondition::broadcast()
{
apr_thread_cond_broadcast(mAPRCondp);
}
SWITCH_DECLARE(switch_status_t) switch_thread_cond_broadcast(switch_thread_cond_t *cond)
{
return apr_thread_cond_broadcast(cond);
}
int mq_stream_read_wait(mq_stream_t *mqs)
{
int err = 0;
apr_interval_time_t dt;
op_status_t status;
//** If 1st time make all the variables
if (mqs->mpool == NULL) {
apr_pool_create(&mqs->mpool, NULL);
apr_thread_mutex_create(&(mqs->lock), APR_THREAD_MUTEX_DEFAULT, mqs->mpool);
apr_thread_cond_create(&(mqs->cond), mqs->mpool);
}
dt = apr_time_from_sec(1);
//** Flag the just processed gop to clean up
apr_thread_mutex_lock(mqs->lock);
log_printf(5, "START msid=%d waiting=%d processed=%d gop_processed=%p\n", mqs->msid, mqs->waiting, mqs->processed, mqs->gop_processed);
if (mqs->gop_processed != NULL) mqs->processed = 1;
apr_thread_cond_broadcast(mqs->cond);
if (mqs->data) {
if (mqs->data[MQS_STATE_INDEX] != MQS_MORE) err = 1;
}
apr_thread_mutex_unlock(mqs->lock);
if (mqs->gop_processed != NULL) {
gop_waitany(mqs->gop_processed);
gop_free(mqs->gop_processed, OP_DESTROY);
mqs->gop_processed = NULL;
}
if (err != 0) {
log_printf(2, "ERROR no more data available!\n");
return(-1);
}
//** Now handle the waiting gop
apr_thread_mutex_lock(mqs->lock);
log_printf(5, "before loop msid=%d waiting=%d processed=%d\n", mqs->msid, mqs->waiting, mqs->processed);
while (mqs->waiting == 1) {
log_printf(5, "LOOP msid=%d waiting=%d processed=%d\n", mqs->msid, mqs->waiting, mqs->processed);
if (gop_will_block(mqs->gop_waiting) == 0) { //** Oops! failed request
status = gop_get_status(mqs->gop_waiting);
log_printf(2, "msid=%d gid=%d status=%d\n", mqs->msid, gop_id(mqs->gop_waiting), status.op_status);
if (status.op_status != OP_STATE_SUCCESS) {
mqs->waiting = -3;
err = 1;
} else {
apr_thread_cond_timedwait(mqs->cond, mqs->lock, dt);
}
} else {
apr_thread_cond_timedwait(mqs->cond, mqs->lock, dt);
}
}
if (mqs->waiting == 0) { //** Flag the receiver to accept the data
mqs->waiting = -1;
apr_thread_cond_broadcast(mqs->cond); //** Let the receiver know we're ready to accept the data
//** Wait for the data to be accepted
while (mqs->waiting != -2) {
apr_thread_cond_wait(mqs->cond, mqs->lock);
}
} else if (mqs->waiting == -3) { //**error occured
err = 1;
}
apr_thread_mutex_unlock(mqs->lock);
//** Flip states
mqs->gop_processed = mqs->gop_waiting;
mqs->gop_waiting = NULL;
//** This shouldn't get triggered but just in case lets throw an error.
if ((mqs->gop_processed == NULL) && (mqs->data != NULL)) {
if ((mqs->data[MQS_STATE_INDEX] == MQS_MORE) && (mqs->want_more == MQS_MORE)) {
err = 3;
log_printf(0, "ERROR: MQS gop processed=waiting=NULL want_more set!!!!!! err=%d\n", err);
fprintf(stderr, "ERROR: MQS gop processed=waiting=NULL want_more set!!!!!! err=%d\n", err);
}
}
//** Check if we need to fire off the next request
if (mqs->data != NULL) {
if ((mqs->data[MQS_STATE_INDEX] == MQS_MORE) && (mqs->want_more == MQS_MORE)) {
mq_stream_read_request(mqs);
}
}
log_printf(5, "err=%d\n", err);
return(err);
}
