/**
* mutt_list_insert_after - Insert a string after a given ListNode
* @param h Head of the List
* @param n ListNode after which the string will be inserted
* @param s String to insert
* @retval ptr Newly created ListNode containing the string
*/
struct ListNode *mutt_list_insert_after(struct ListHead *h, struct ListNode *n, char *s)
{
struct ListNode *np = mutt_mem_calloc(1, sizeof(struct ListNode));
np->data = s;
STAILQ_INSERT_AFTER(h, n, np, entries);
return np;
}
int
taskqueue_enqueue(struct taskqueue *queue, struct task *task)
{
struct task *ins;
struct task *prev;
int s = splhigh();
/*
* Don't allow new tasks on a queue which is being freed.
*/
if (queue->tq_draining) {
splx(s);
return EPIPE;
}
/*
* Count multiple enqueues.
*/
if (task->ta_pending) {
task->ta_pending++;
splx(s);
return 0;
}
/*
* Optimise the case when all tasks have the same priority.
*/
prev = STAILQ_LAST(&queue->tq_queue);
if (!prev || prev->ta_priority >= task->ta_priority) {
STAILQ_INSERT_TAIL(&queue->tq_queue, task, ta_link);
} else {
prev = 0;
for (ins = STAILQ_FIRST(&queue->tq_queue); ins;
prev = ins, ins = STAILQ_NEXT(ins, ta_link))
if (ins->ta_priority < task->ta_priority)
break;
if (prev)
STAILQ_INSERT_AFTER(&queue->tq_queue, prev, task, ta_link);
else
STAILQ_INSERT_HEAD(&queue->tq_queue, task, ta_link);
}
task->ta_pending = 1;
if (queue->tq_enqueue)
queue->tq_enqueue(queue->tq_context);
splx(s);
return 0;
}
/*
* Note, epaddr is the master.
*/
int __recvpath
psmi_mq_handle_outoforder_queue(psm_epaddr_t epaddr)
{
psm_mq_t mq = epaddr->ep->mq;
psm_mq_req_t ureq, ereq;
uint32_t msglen;
next_ooo:
ureq = mq_ooo_match(&epaddr->outoforder_q, epaddr->mctxt_recv_seqnum);
if (ureq == NULL) return 0;
epaddr->mctxt_recv_seqnum++;
epaddr->outoforder_c--;
ereq = mq_req_match(&(mq->expected_q), ureq->tag, 1);
if (ereq == NULL) {
mq_sq_append(&mq->unexpected_q, ureq);
if (epaddr->outoforder_c) goto next_ooo;
return 0;
}
psmi_assert(MQE_TYPE_IS_RECV(ereq->type));
ereq->tag = ureq->tag;
msglen = mq_set_msglen(ereq, ereq->buf_len, ureq->send_msglen);
switch (ureq->state) {
case MQ_STATE_COMPLETE:
if (ureq->buf != NULL) { /* 0-byte don't alloc a sysbuf */
psmi_mq_mtucpy(ereq->buf,
(const void *)ureq->buf, msglen);
psmi_mq_sysbuf_free(mq, ureq->buf);
}
ereq->state = MQ_STATE_COMPLETE;
mq_qq_append(&mq->completed_q, ereq);
break;
case MQ_STATE_UNEXP: /* not done yet */
ereq->type = ureq->type;
ereq->egrid = ureq->egrid;
ereq->epaddr = ureq->epaddr;
ereq->send_msgoff = ureq->send_msgoff;
ereq->recv_msgoff = min(ureq->recv_msgoff, msglen);
psmi_mq_mtucpy(ereq->buf,
(const void *)ureq->buf, ereq->recv_msgoff);
psmi_mq_sysbuf_free(mq, ureq->buf);
ereq->state = MQ_STATE_MATCHED;
STAILQ_INSERT_AFTER(&ureq->epaddr->mctxt_master->egrlong,
ureq, ereq, nextq);
STAILQ_REMOVE(&ureq->epaddr->mctxt_master->egrlong,
ureq, psm_mq_req, nextq);
break;
case MQ_STATE_UNEXP_RV: /* rendez-vous ... */
ereq->state = MQ_STATE_MATCHED;
ereq->rts_peer = ureq->rts_peer;
ereq->rts_sbuf = ureq->rts_sbuf;
ereq->send_msgoff = 0;
ereq->rts_callback = ureq->rts_callback;
ereq->rts_reqidx_peer = ureq->rts_reqidx_peer;
ereq->type = ureq->type;
ereq->rts_callback(ereq, 0);
break;
default:
fprintf(stderr, "Unexpected state %d in req %p\n", ureq->state, ureq);
fprintf(stderr, "type=%d, mq=%p, tag=%p\n",
ureq->type, ureq->mq, (void *)(uintptr_t)ureq->tag);
abort();
}
psmi_mq_req_free(ureq);
if (epaddr->outoforder_c) goto next_ooo;
return 0;
}
void
mbuf_insert_after(struct mhdr *mhdr, struct mbuf *mbuf, struct mbuf *nbuf)
{
STAILQ_INSERT_AFTER(mhdr, nbuf, mbuf, next);
log_debug(LOG_VVERB, "insert head mbuf %p len %d", mbuf, mbuf->last - mbuf->pos);
}
