int
event_queue_get(struct event_queue *eq, struct queue_thread *me, struct server_msg **msg)
{
struct event_queue_msg *el;
int found;
assert(eq != NULL);
event_queue_lock(eq);
if(me->jobid) {
me->jobid = NULL;
me->current = NULL;
}
if(NULL == eq->head) {
event_queue_unlock(eq);
return 0;
}
found = 0;
el = eq->head;
do {
char *jobid = el->msg->job_id_s;
int i;
for(i = 0; i < eq->num_threads; i++) {
if(me == eq->thread + i) {
continue;
}
if(eq->thread[i].jobid && strcmp(jobid, eq->thread[i].jobid) == 0) {
break;
}
}
if(i >= eq->num_threads) {
/* no other thread is working on this job */
found = 1;
break;
}
el = el->prev;
} while(el != eq->head);
if(found && msg) {
me->current = el;
me->jobid = el->msg->job_id_s;
*msg = el->msg;
server_msg_use(*msg);
}
event_queue_unlock(eq);
return found;
}
static int
etw_fetchCallBack(pmdaMetric *mdesc, unsigned int inst, pmAtomValue *atom)
{
__pmID_int *idp = (__pmID_int *)&(mdesc->m_desc.pmid);
etw_event_t *etw;
int sts = PMDA_FETCH_STATIC;
__pmNotifyErr(LOG_WARNING, "called %s, mdesc=%p", __FUNCTION__, mdesc);
switch (idp->cluster) {
case CLUSTER_KERNEL_PROCESS:
if ((etw = ((mdesc != NULL) ? mdesc->m_user : NULL)) == NULL)
return PM_ERR_PMID;
switch (idp->item) {
case 0: /* etw.kernel.process.start.count */
case 20: /* etw.kernel.process.exit.count */
case 50: /* etw.kernel.thread.start.count */
case 70: /* etw.kernel.thread.stop.count */
case 90: /* etw.kernel.process.image_load.count */
case 110: /* etw.kernel.process.image_unload.count */
sts = pmdaEventQueueCounter(etw->queueid, atom);
break;
case 1: /* etw.kernel.process.start.records */
case 21: /* etw.kernel.process.exit.records */
case 51: /* etw.kernel.thread.start.records */
case 71: /* etw.kernel.thread.stop.records */
case 91: /* etw.kernel.process.image_load.records */
case 111: /* etw.kernel.process.image_unload.records */
event_queue_lock(etw);
sts = pmdaEventQueueRecords(etw->queueid, atom,
pmdaGetContext(),
event_decoder, &etw);
event_queue_unlock(etw);
break;
case 2: /* etw.kernel.process.start.numclients */
case 22: /* etw.kernel.process.exit.numclients */
case 52: /* etw.kernel.thread.start.numclients */
case 72: /* etw.kernel.thread.stop.numclients */
case 92: /* etw.kernel.process.image_load.numclients */
case 112: /* etw.kernel.process.image_unload.numclients */
sts = pmdaEventQueueClients(etw->queueid, atom);
break;
case 3: /* etw.kernel.process.start.queuemem */
case 23: /* etw.kernel.process.exit.queuemem */
case 53: /* etw.kernel.thread.start.queuemem */
case 73: /* etw.kernel.thread.stop.queuemem */
case 93: /* etw.kernel.process.image_load.queuemem */
case 113: /* etw.kernel.process.image_unload.queuemem */
sts = pmdaEventQueueMemory(etw->queueid, atom);
break;
default:
return PM_ERR_PMID;
}
break;
case CLUSTER_CONFIGURATION:
switch (idp->item) {
case 0: /* etw.numclients */
sts = pmdaEventClients(atom);
break;
default:
return PM_ERR_PMID;
}
break;
default:
break;
}
return sts;
}
int
event_queue_move_events(struct event_queue *eq_s,
struct event_queue *eq_d,
int (*cmp_func)(struct server_msg *, void *),
void *data)
{
struct event_queue_msg *p, *q, *last;
/* struct event_queue_msg **source_prev, **dest_tail; */
assert(eq_s != NULL);
assert(data != NULL);
event_queue_lock(eq_s);
p = eq_s->head;
if(NULL == p) {
event_queue_unlock(eq_s);
return 0;
}
if(eq_d) {
event_queue_lock(eq_d);
}
last = p->next;
do {
if((*cmp_func)(p->msg, data)) {
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_DEBUG,
" moving event at offset %d(%d) from %s:%d to %s:%d",
p->msg->offset, p->msg->generation, eq_s->dest_name, eq_s->dest_port,
eq_d ? eq_d->dest_name : "trash", eq_d ? eq_d->dest_port : -1);
q = p->prev;
/* remove message from the source queue */
if(p == p->prev) {
/* removing last message */
eq_s->head = NULL;
eq_s->tail_ems = NULL;
} else {
p->next->prev = p->prev;
p->prev->next = p->next;
if(p == eq_s->head) {
eq_s->head = p->prev;
}
if(p == eq_s->tail_ems) {
eq_s->tail_ems = p->prev;
}
}
eq_s->cur_len--;
if(eq_d) {
/* append message to the destination queue */
if(eq_d->head == NULL) {
eq_d->head = p;
eq_d->tail_ems = p;
p->next = p;
p->prev = p;
} else {
/* priorities are ignored */
p->next = eq_d->head->next;
p->prev = eq_d->head;
p->next->prev = p;
p->prev->next = p;
}
if(++eq_d->cur_len > eq_d->max_len) {
eq_d->max_len = eq_d->cur_len;
}
p->eq = eq_d;
} else {
/* signal that the message was 'delivered' */
event_store_commit(p->msg->es, p->msg->ev_len, queue_list_is_log(eq_s),
p->msg->generation);
/* free the message */
server_msg_free(p->msg);
free(p);
}
p = q;
} else {
p = p->prev;
}
} while (eq_s->head && p != last);
#if 0 /* OLD IMPLEMENTATION */
if(eq_d) {
event_queue_lock(eq_d);
/* dest tail is set to point to the last (NULL) pointer in the list */
dest_tail = (eq_d->head == NULL) ? &(eq_d->head) : &(eq_d->tail->prev);
}
source_prev = &(eq_s->head);
p = *source_prev;
eq_s->tail = NULL;
while(p) {
if((*cmp_func)(p->msg, data)) {
glite_common_log(IL_LOG_CATEGORY, LOG_PRIORITY_DEBUG,
" moving event at offset %ld(%d) from %s:%d to %s:%d",
p->msg->offset, p->msg->generation, eq_s->dest_name, eq_s->dest_port,
eq_d ? eq_d->dest_name : "trash", eq_d ? eq_d->dest_port : -1);
/* il_log(LOG_DEBUG, " current: %x, next: %x\n", p, p->prev); */
/* remove the message from the source list */
*source_prev = p->prev;
assert(eq_s->cur_len > 0);
eq_s->cur_len--;
if(eq_d) {
/* append the message at the end of destination list */
p->prev = NULL;
*dest_tail = p;
dest_tail = &(p->prev);
eq_d->tail = p;
if(++eq_d->cur_len > eq_d->max_len) {
eq_d->max_len = eq_d->cur_len;
}
} else {
/* signal that the message was 'delivered' */
event_store_commit(p->msg->es, p->msg->ev_len, queue_list_is_log(eq_s),
p->msg->generation);
/* free the message */
server_msg_free(p->msg);
free(p);
}
} else {
/* message stays */
source_prev = &(p->prev);
eq_s->tail = p;
}
p = *source_prev;
}
#endif /* OLD IMPLEMENTATION */
if(eq_s->cur_len <= queue_size_low) {
eq_s->throttling = 0;
}
if(eq_d) event_queue_unlock(eq_d);
event_queue_unlock(eq_s);
return(0);
}
int
event_queue_remove(struct event_queue *eq, struct queue_thread *me)
{
struct event_queue_msg *el;
#if defined(INTERLOGD_EMS)
struct event_queue_msg *prev;
#endif
assert(eq != NULL);
el = me->current;
if(NULL == el) {
return -1;
}
/* this is critical section */
event_queue_lock(eq);
me->current = NULL;
me->jobid = NULL;
if(eq == el->eq) {
/* message is still ours, remove from queue */
if(el == el->prev) {
/* last element */
eq->head = NULL;
eq->tail_ems = NULL;
} else {
el->next->prev = el->prev;
el->prev->next = el->next;
if(el == eq->head) {
eq->head = el->prev;
}
if(el == eq->tail_ems) {
eq->tail_ems = el->prev;
}
}
if(--eq->cur_len == 0)
eq->times_empty++;
if(eq->cur_len <= queue_size_low) {
eq->throttling = 0;
}
} else {
/* not ours anymore */
server_msg_release(el->msg);
event_queue_unlock(eq);
return 0;
}
#if 0 /* OLD IMPLEMENTATION */
#if defined(INTERLOGD_EMS)
el = eq->mark_this;
prev = eq->mark_prev;
if(el == NULL) {
event_queue_unlock(eq);
return(-1);
}
if(prev == NULL) {
/* removing from head of the queue */
eq->head = el->prev;
} else {
/* removing from middle of the queue */
prev->prev = el->prev;
}
if(el == eq->tail) {
/* we are removing the last message */
eq->tail = prev;
}
if(el == eq->tail_ems) {
/* we are removing last priority message */
eq->tail_ems = prev;
}
eq->mark_this = NULL;
eq->mark_prev = NULL;
#else
el = eq->head;
if(el == NULL) {
event_queue_unlock(eq);
return(-1);
}
eq->head = el->prev;
if(el == eq->tail) {
eq->tail = NULL;
}
#endif
#endif /* OLD IMPLEMENTATION */
event_queue_unlock(eq);
/* end of critical section */
server_msg_free(el->msg);
free(el);
return(0);
}
int
event_queue_insert(struct event_queue *eq, struct server_msg *msg)
{
struct event_queue_msg *el;
#if defined(INTERLOGD_EMS)
struct event_queue_msg *tail;
#endif
assert(eq != NULL);
if(queue_size_high > 0 && (eq->cur_len >= queue_size_high || eq->throttling)) {
eq->throttling = 1;
return 1;
}
if((el = malloc(sizeof(*el))) == NULL)
return(set_error(IL_NOMEM, ENOMEM, "event_queue_insert: not enough room for queue element"));
el->msg = server_msg_copy(msg);
if(el->msg == NULL) {
free(el);
return(-1);
};
/* this is critical section */
event_queue_lock(eq);
if(NULL == eq->head) {
el->prev = el;
el->next = el;
eq->head = el;
eq->tail_ems = el;
} else {
if(server_msg_is_priority(msg)) {
el->next = eq->tail_ems->next;
el->prev = eq->tail_ems;
if(eq->head == eq->tail_ems) {
eq->head = el;
}
} else {
el->next = eq->head->next;
el->prev = eq->head;
}
el->next->prev = el;
el->prev->next = el;
}
#if 0 /* OLD IMPLEMENTATION */
#if defined(INTERLOGD_EMS)
if(server_msg_is_priority(msg)) {
/* priority messages go first */
tail = eq->tail_ems;
if(tail) {
el->prev = tail->prev;
tail->prev = el;
if (tail == eq->tail)
eq->tail = el;
} else {
el->prev = eq->head;
eq->head = el;
if(eq->tail == NULL)
eq->tail = el;
}
eq->tail_ems = el;
} else
#endif
{
/* normal messages */
if(eq->tail)
eq->tail->prev = el;
else
eq->head = el;
eq->tail = el;
el->prev = NULL;
}
#if defined(INTERLOGD_EMS)
/* if we are inserting message between mark_prev and mark_this,
we have to adjust mark_prev accordingly */
if(eq->mark_this && (el->prev == eq->mark_this))
eq->mark_prev = el;
#endif
#endif /* OLD IMPLEMENTATION */
if(++eq->cur_len > eq->max_len)
eq->max_len = eq->cur_len;
el->eq = eq;
event_queue_unlock(eq);
/* end of critical section */
return(0);
}
