static void
rtwn_usb_reset_tx_list(struct rtwn_usb_softc *uc,
rtwn_datahead *head, struct ieee80211vap *vap)
{
struct rtwn_vap *uvp = RTWN_VAP(vap);
struct rtwn_data *dp, *tmp;
int id;
id = (uvp != NULL ? uvp->id : RTWN_VAP_ID_INVALID);
STAILQ_FOREACH_SAFE(dp, head, next, tmp) {
if (vap == NULL || (dp->ni == NULL &&
(dp->id == id || id == RTWN_VAP_ID_INVALID)) ||
(dp->ni != NULL && dp->ni->ni_vap == vap)) {
if (dp->ni != NULL) {
ieee80211_free_node(dp->ni);
dp->ni = NULL;
}
if (dp->m != NULL) {
m_freem(dp->m);
dp->m = NULL;
}
STAILQ_REMOVE(head, dp, rtwn_data, next);
STAILQ_INSERT_TAIL(&uc->uc_tx_inactive, dp, next);
}
}
}
int
ctl_frontend_deregister(struct ctl_frontend *fe)
{
struct ctl_io_pool *pool;
int port_num;
int retval;
retval = 0;
pool = (struct ctl_io_pool *)fe->ctl_pool_ref;
if (fe->targ_port == -1) {
retval = 1;
goto bailout;
}
mtx_lock(&control_softc->ctl_lock);
STAILQ_REMOVE(&control_softc->fe_list, fe, ctl_frontend, links);
control_softc->num_frontends--;
port_num = (fe->targ_port < CTL_MAX_PORTS) ? fe->targ_port :
fe->targ_port - CTL_MAX_PORTS;
ctl_clear_mask(&control_softc->ctl_port_mask, port_num);
control_softc->ctl_ports[port_num] = NULL;
mtx_unlock(&control_softc->ctl_lock);
ctl_pool_free(pool);
bailout:
return (retval);
}
static void idle_backend_handler(struct ns_connection *nc, int ev,
void *ev_data) {
(void) ev_data; /* Unused. */
struct be_conn *bec = nc->user_data;
const time_t now = time(NULL);
#ifdef DEBUG
write_log("%d idle bec=%p nc=%p ev=%d deadline=%d\n", now, bec, nc, ev,
bec->idle_deadline);
#endif
switch (ev) {
case NS_POLL: {
if (bec->idle_deadline > 0 && now > bec->idle_deadline) {
#ifdef DEBUG
write_log("bec=%p nc=%p closing due to idleness\n", bec, bec->nc);
#endif
bec->nc->flags |= NSF_CLOSE_IMMEDIATELY;
}
break;
}
case NS_CLOSE: {
#ifdef DEBUG
write_log("bec=%p closed\n", bec);
#endif
if (bec->idle_deadline > 0) {
STAILQ_REMOVE(&bec->be->conns, bec, be_conn, conns);
}
free(bec);
break;
}
}
}
/*
* Allocate a single object of specified size with specified flags (either
* M_WAITOK or M_NOWAIT).
*/
void *
memguard_alloc(unsigned long size, int flags)
{
void *obj;
struct memguard_entry *e = NULL;
int numpgs;
numpgs = size / PAGE_SIZE;
if ((size % PAGE_SIZE) != 0)
numpgs++;
if (numpgs > MAX_PAGES_PER_ITEM)
panic("MEMGUARD: You must increase MAX_PAGES_PER_ITEM " \
"in memguard.c (requested: %d pages)", numpgs);
if (numpgs == 0)
return NULL;
/*
* If we haven't exhausted the memguard_map yet, allocate from
* it and grab a new page, even if we have recycled pages in our
* FIFO. This is because we wish to allow recycled pages to live
* guarded in the FIFO for as long as possible in order to catch
* even very late tamper-after-frees, even though it means that
* we end up wasting more memory, this is only a DEBUGGING allocator
* after all.
*/
MEMGUARD_CRIT_SECTION_ENTER;
if (memguard_mapused >= memguard_mapsize) {
e = STAILQ_FIRST(&memguard_fifo_pool[numpgs - 1]);
if (e != NULL) {
STAILQ_REMOVE(&memguard_fifo_pool[numpgs - 1], e,
memguard_entry, entries);
MEMGUARD_CRIT_SECTION_EXIT;
obj = e->ptr;
free(e, M_TEMP);
memguard_unguard(obj, numpgs);
if (flags & M_ZERO)
bzero(obj, PAGE_SIZE * numpgs);
return obj;
}
MEMGUARD_CRIT_SECTION_EXIT;
if (flags & M_WAITOK)
panic("MEMGUARD: Failed with M_WAITOK: " \
"memguard_map too small");
return NULL;
}
memguard_mapused += (PAGE_SIZE * numpgs);
MEMGUARD_CRIT_SECTION_EXIT;
obj = (void *)kmem_malloc(memguard_map, PAGE_SIZE * numpgs, flags);
if (obj != NULL) {
vsetmgfifo((vm_offset_t)obj, &memguard_fifo_pool[numpgs - 1]);
if (flags & M_ZERO)
bzero(obj, PAGE_SIZE * numpgs);
} else {
MEMGUARD_CRIT_SECTION_ENTER;
memguard_mapused -= (PAGE_SIZE * numpgs);
MEMGUARD_CRIT_SECTION_EXIT;
}
return obj;
}
void net_habitue_device_SC101::completeIO(outstanding_io *io)
{
STAILQ_REMOVE(&_outstandingHead, io, outstanding_io, entries);
_outstandingCount--;
dequeueAndSubmitIO();
}
/*! \fn void *thread_io_device(void *parg)
* \brief Thread dispositivo I/O
* \details La funzione costituisce il corpo del thread che rappresenta il
* dispositivo di I/O. Il suddetto thread sospende la propria esecuzione
* fintanto che non siano presenti delle richieste d'accesso al dispositivo.
* Il thread termina la propria esecuzione quando sono stati compiuti il
* numero massimo d'accessi alla memoria (ad opera dell'MMU).
* \param parg inutilizzato
* \return inutilizzato
*/
static void *
thread_io_device(void *parg)
{
io_entry_t *req;
struct timespec timeout;
int num;
printf("--> Thread DEVICE I/O avviato [Tmin=%d, Tmax=%d]\n",
io_dev.Tmin, io_dev.Tmax);
while (!io_device_should_exit) {
pthread_mutex_lock(&wait_lock);
while ((ioreq_count == 0) && !io_device_should_exit) {
pthread_cond_wait(&wait_cond, &wait_lock);
}
if (io_device_should_exit && (ioreq_count == 0)) {
pthread_mutex_unlock(&wait_lock);
break;
}
/*
* Estraggo la prima richiesta e la rimuovo dalla coda, aggiornando
* la variabile "ioreq_count" che tiene traccia di quante richieste
* sono ancora in attesa.
*/
req = STAILQ_FIRST(&io_request_head);
assert(req);
pthread_mutex_lock(&fifo_lock);
STAILQ_REMOVE(&io_request_head, req, io_entry, entries);
ioreq_count--;
pthread_mutex_unlock(&fifo_lock);
/*
* Genero un numero casuale compreso nell'intervallo chiuso
* [Tmin,Tmax] utile a simulare il reperimento dell'informazione dal
* dispositivo.
*/
num = bounded_rand(io_dev.Tmin, io_dev.Tmax);
timeout.tv_sec = 0;
timeout.tv_nsec = num * 1000000;
nanosleep(&timeout, NULL);
fprintf(LOG_FILE(req->procnum),
"Richiesta d'accesso servita in %d ms\n", num);
/*
* Aggiorno le statistiche e "risveglio" il processo che ha fatto la
* richiesta.
*/
io_dev.req_count++;
proc_table[req->procnum]->stats.io_requests++;
proc_table[req->procnum]->stats.time_elapsed += num;
pthread_mutex_unlock(&wait_lock);
pthread_cond_signal(&proc_table[req->procnum]->io_cond);
XFREE(req);
}
printf("<-- Thread DEVICE I/O terminato\n");
pthread_exit(NULL);
}
int timer_remove(long timer_id)
{
int rc = 0;
struct timer_elm_s *timer_p;
TMR_DEBUG("Removing timer 0x%lx\n", timer_id);
pthread_mutex_lock(&timer_desc.timer_list_mutex);
TIMER_SEARCH(timer_p, timer, ((timer_t)timer_id), &timer_desc.timer_queue);
/* We didn't find the timer in list */
if (timer_p == NULL) {
pthread_mutex_unlock(&timer_desc.timer_list_mutex);
TMR_ERROR("Didn't find timer 0x%lx in list\n", timer_id);
return -1;
}
STAILQ_REMOVE(&timer_desc.timer_queue, timer_p, timer_elm_s, entries);
pthread_mutex_unlock(&timer_desc.timer_list_mutex);
if (timer_delete(timer_p->timer) < 0) {
TMR_ERROR("Failed to delete timer 0x%lx\n", (long)timer_p->timer);
rc = -1;
}
free(timer_p);
timer_p = NULL;
return rc;
}
struct os_event *
os_eventq_get(struct os_eventq *evq)
{
struct os_event *ev;
os_sr_t sr;
OS_ENTER_CRITICAL(sr);
pull_one:
ev = STAILQ_FIRST(&evq->evq_list);
if (ev) {
STAILQ_REMOVE(&evq->evq_list, ev, os_event, ev_next);
ev->ev_queued = 0;
} else {
evq->evq_task = os_sched_get_current_task();
os_sched_sleep(evq->evq_task, OS_TIMEOUT_NEVER);
OS_EXIT_CRITICAL(sr);
os_sched(NULL, 0);
OS_ENTER_CRITICAL(sr);
evq->evq_task = NULL;
goto pull_one;
}
OS_EXIT_CRITICAL(sr);
return (ev);
}
int
linker_file_unload(linker_file_t file)
{
module_t mod, next;
struct common_symbol* cp;
int error = 0;
int i;
KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
lockmgr(&lock, LK_EXCLUSIVE|LK_RETRY, 0, curproc);
if (file->refs == 1) {
KLD_DPF(FILE, ("linker_file_unload: file is unloading, informing modules\n"));
/*
* Inform any modules associated with this file.
*/
for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
next = module_getfnext(mod);
/*
* Give the module a chance to veto the unload.
*/
if (error = module_unload(mod)) {
KLD_DPF(FILE, ("linker_file_unload: module %x vetoes unload\n",
mod));
lockmgr(&lock, LK_RELEASE, 0, curproc);
goto out;
}
module_release(mod);
}
}
file->refs--;
if (file->refs > 0) {
lockmgr(&lock, LK_RELEASE, 0, curproc);
goto out;
}
linker_file_sysuninit(file);
TAILQ_REMOVE(&files, file, link);
lockmgr(&lock, LK_RELEASE, 0, curproc);
for (i = 0; i < file->ndeps; i++)
linker_file_unload(file->deps[i]);
free(file->deps, M_LINKER);
for (cp = STAILQ_FIRST(&file->common); cp;
cp = STAILQ_FIRST(&file->common)) {
STAILQ_REMOVE(&file->common, cp, common_symbol, link);
free(cp, M_LINKER);
}
file->ops->unload(file);
free(file, M_LINKER);
out:
return error;
}
/*
* Remove mbuf from the mhdr Q
*/
void
mbuf_remove(struct mhdr *mhdr, struct mbuf *mbuf)
{
log_debug(LOG_VVERB, "remove mbuf %p len %d", mbuf, mbuf->last - mbuf->pos);
STAILQ_REMOVE(mhdr, mbuf, mbuf, next);
STAILQ_NEXT(mbuf, next) = NULL;
}
static int
smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait)
{
struct smu_softc *sc;
uint8_t cmd_code;
int error;
sc = device_get_softc(dev);
cmd_code = cmd->cmd;
mtx_lock(&sc->sc_mtx);
if (sc->sc_cur_cmd != NULL) {
STAILQ_INSERT_TAIL(&sc->sc_cmdq, cmd, cmd_q);
} else
smu_send_cmd(dev, cmd);
mtx_unlock(&sc->sc_mtx);
if (!wait)
return (0);
if (sc->sc_doorbellirqid < 0) {
/* Poll if the IRQ has not been set up yet */
do {
DELAY(50);
smu_doorbell_intr(dev);
} while (sc->sc_cur_cmd != NULL);
} else {
/* smu_doorbell_intr will wake us when the command is ACK'ed */
error = tsleep(cmd, 0, "smu", 800 * hz / 1000);
if (error != 0)
smu_doorbell_intr(dev); /* One last chance */
if (error != 0) {
mtx_lock(&sc->sc_mtx);
if (cmd->cmd == cmd_code) { /* Never processed */
/* Abort this command if we timed out */
if (sc->sc_cur_cmd == cmd)
sc->sc_cur_cmd = NULL;
else
STAILQ_REMOVE(&sc->sc_cmdq, cmd, smu_cmd,
cmd_q);
mtx_unlock(&sc->sc_mtx);
return (error);
}
error = 0;
mtx_unlock(&sc->sc_mtx);
}
}
/* SMU acks the command by inverting the command bits */
if (cmd->cmd == ((~cmd_code) & 0xff))
error = 0;
else
error = EIO;
return (error);
}
int __recvpath
psmi_mq_handle_data(psm_mq_req_t req, psm_epaddr_t epaddr,
uint32_t egrid, uint32_t offset,
const void *buf, uint32_t nbytes)
{
psm_mq_t mq;
int rc;
if (req == NULL) goto no_req;
mq = req->mq;
if (req->state == MQ_STATE_MATCHED)
rc = MQ_RET_MATCH_OK;
else {
psmi_assert(req->state == MQ_STATE_UNEXP);
rc = MQ_RET_UNEXP_OK;
}
psmi_assert(req->egrid.egr_data == egrid);
psmi_mq_req_copy(req, epaddr, offset, buf, nbytes);
if (req->send_msgoff == req->send_msglen) {
if (req->type & MQE_TYPE_EGRLONG) {
STAILQ_REMOVE(&epaddr->mctxt_master->egrlong,
req, psm_mq_req, nextq);
}
if (req->state == MQ_STATE_MATCHED) {
req->state = MQ_STATE_COMPLETE;
mq_qq_append(&mq->completed_q, req);
}
else { /* MQ_STATE_UNEXP */
req->state = MQ_STATE_COMPLETE;
}
_IPATH_VDBG("epaddr=%s completed %d byte send, state=%d\n",
psmi_epaddr_get_name(epaddr->epid),
(int)req->send_msglen, req->state);
}
return rc;
no_req:
mq = epaddr->ep->mq;
req = psmi_mq_req_alloc(mq, MQE_TYPE_RECV);
psmi_assert(req != NULL);
req->egrid.egr_data = egrid;
req->recv_msgoff = offset;
req->recv_msglen = nbytes;
req->buf = psmi_mq_sysbuf_alloc(mq, nbytes);
psmi_mq_mtucpy(req->buf, buf, nbytes);
STAILQ_INSERT_TAIL(&epaddr->mctxt_master->egrdata, req, nextq);
return MQ_RET_UNEXP_OK;
}
rstatus_t
cursor_destory(cursor_t *cursor)
{
leveldb_iter_destroy(cursor->iter);
STAILQ_REMOVE(&cursorq, cursor, cursor_s, next);
nc_free(cursor);
ncursor--;
return NC_OK;
}
gdp_event_t *
gdp_event_next(gdp_gcl_t *gcl, EP_TIME_SPEC *timeout)
{
gdp_event_t *gev;
EP_TIME_SPEC *abs_to = NULL;
EP_TIME_SPEC tv;
if (timeout != NULL)
{
ep_time_deltanow(timeout, &tv);
abs_to = &tv;
}
ep_thr_mutex_lock(&ActiveListMutex);
for (;;)
{
int err;
while ((gev = STAILQ_FIRST(&ActiveList)) == NULL)
{
// wait until we have at least one thing to try
err = ep_thr_cond_wait(&ActiveListSig, &ActiveListMutex, abs_to);
if (err == ETIMEDOUT)
goto fail0;
}
while (gev != NULL)
{
// if this isn't the GCL we want, keep searching the list
if (gcl == NULL || gev->gcl == gcl)
break;
// not the event we want
gev = STAILQ_NEXT(gev, queue);
}
if (gev != NULL)
{
// found a match!
break;
}
// if there is no match, wait until something is added and try again
err = ep_thr_cond_wait(&ActiveListSig, &ActiveListMutex, abs_to);
if (err == ETIMEDOUT)
break;
}
if (gev != NULL)
STAILQ_REMOVE(&ActiveList, gev, gdp_event, queue);
fail0:
ep_thr_mutex_unlock(&ActiveListMutex);
// the callback must call gdp_event_free(gev)
return gev;
}
void rte_vmbus_chan_close(struct vmbus_channel *chan)
{
const struct rte_vmbus_device *device = chan->device;
struct vmbus_channel *primary = device->primary;
if (chan != primary)
STAILQ_REMOVE(&primary->subchannel_list, chan,
vmbus_channel, next);
rte_free(chan);
}
void net_habitue_device_SC101::dequeueAndSubmitIO()
{
outstanding_io *io = STAILQ_FIRST(&_pendingHead);
if (io)
{
STAILQ_REMOVE(&_pendingHead, io, outstanding_io, entries);
_pendingCount--;
submitIO(io);
}
}
static void
nvmf_deactive_tx_desc(struct nvme_qp_tx_desc *tx_desc)
{
struct spdk_nvmf_conn *conn;
RTE_VERIFY(tx_desc != NULL);
conn = tx_desc->conn;
RTE_VERIFY(tx_desc->conn != NULL);
STAILQ_REMOVE(&conn->qp_tx_active_desc, tx_desc, nvme_qp_tx_desc, link);
STAILQ_INSERT_TAIL(&conn->qp_tx_desc, tx_desc, link);
}
void
os_eventq_remove(struct os_eventq *evq, struct os_event *ev)
{
os_sr_t sr;
OS_ENTER_CRITICAL(sr);
if (OS_EVENT_QUEUED(ev)) {
STAILQ_REMOVE(&evq->evq_list, ev, os_event, ev_next);
}
ev->ev_queued = 0;
OS_EXIT_CRITICAL(sr);
}
/**
* mutt_regexlist_free - Free a RegexList object
* @param rl RegexList to free
*/
void mutt_regexlist_free(struct RegexList *rl)
{
if (!rl)
return;
struct RegexListNode *np = NULL, *tmp = NULL;
STAILQ_FOREACH_SAFE(np, rl, entries, tmp)
{
STAILQ_REMOVE(rl, np, RegexListNode, entries);
mutt_regex_free(&np->regex);
FREE(&np);
}
struct conn *
conn_cq_pop(struct conn_q *cq)
{
struct conn *c;
pthread_mutex_lock(&cq->lock);
c = STAILQ_FIRST(&cq->hdr);
if (c != NULL) {
STAILQ_REMOVE(&cq->hdr, c, conn, c_tqe);
}
pthread_mutex_unlock(&cq->lock);
return c;
}
void
taskqueue_free(struct taskqueue *queue)
{
int s = splhigh();
queue->tq_draining = 1;
splx(s);
taskqueue_run(queue);
s = splhigh();
STAILQ_REMOVE(&taskqueue_queues, queue, taskqueue, tq_link);
splx(s);
free(queue, M_TASKQUEUE);
}
static inline void
hv_put_rndis_request(rndis_device *device, rndis_request *request)
{
mtx_lock_spin(&device->req_lock);
/* Fixme: Has O(n) performance */
/*
* XXXKYS: Use Doubly linked lists.
*/
STAILQ_REMOVE(&device->myrequest_list, request, rndis_request_,
mylist_entry);
mtx_unlock_spin(&device->req_lock);
sema_destroy(&request->wait_sema);
free(request, M_DEVBUF);
}
static int
flowadv_thread_cont(int err)
{
#pragma unused(err)
for (;;) {
lck_mtx_assert(&fadv_lock, LCK_MTX_ASSERT_OWNED);
while (STAILQ_EMPTY(&fadv_list)) {
VERIFY(!fadv_active);
(void) msleep0(&fadv_list, &fadv_lock, (PSOCK | PSPIN),
"flowadv_cont", 0, flowadv_thread_cont);
/* NOTREACHED */
}
fadv_active = 1;
for (;;) {
struct flowadv_fcentry *fce;
VERIFY(!STAILQ_EMPTY(&fadv_list));
fce = STAILQ_FIRST(&fadv_list);
STAILQ_REMOVE(&fadv_list, fce,
flowadv_fcentry, fce_link);
STAILQ_NEXT(fce, fce_link) = NULL;
lck_mtx_unlock(&fadv_lock);
switch (fce->fce_flowsrc) {
case FLOWSRC_INPCB:
inp_flowadv(fce->fce_flowid);
break;
case FLOWSRC_IFNET:
ifnet_flowadv(fce->fce_flowid);
break;
case FLOWSRC_PF:
default:
break;
}
flowadv_free_entry(fce);
lck_mtx_lock_spin(&fadv_lock);
/* if there's no pending request, we're done */
if (STAILQ_EMPTY(&fadv_list))
break;
}
fadv_active = 0;
}
}
/* Push a new entry into the slow log.
* This function will make sure to trim the slow log accordingly to the
* configured max length.
* The unit of duration is microseconds */
void slowlog_push_entry_if_needed(struct msg *r, long long duration) {
if (slowlog_log_slower_than < 0) return; /* Slowlog disabled */
if (duration >= slowlog_log_slower_than) {
slowlog_entry *se = slowlog_create_entry(r,duration);
pthread_rwlock_wrlock(&rwlocker);
se->id = slowlog_entry_id++;
STAILQ_INSERT_HEAD(&slowlog, se, next);
if (slowlog_len >= slowlog_max_len) {
se = STAILQ_LAST(&slowlog, slowlog_entry, next);
STAILQ_REMOVE(&slowlog, se, slowlog_entry, next);
slowlog_free_entry(se);
} else {
slowlog_len ++;
}
pthread_rwlock_unlock(&rwlocker);
slowlog_statistics_input();
}
}
/*
* mpipe support thread for request failures when mpipe_alloc_callback()
* is called.
*/
static void
mpipe_thread(void *arg)
{
malloc_pipe_t mpipe = arg;
struct mpipe_callback *mcb;
lwkt_gettoken(&mpipe->token);
while ((mpipe->mpflags & MPF_EXITING) == 0) {
while (mpipe->free_count &&
(mcb = STAILQ_FIRST(&mpipe->queue)) != NULL) {
STAILQ_REMOVE(&mpipe->queue, mcb, mpipe_callback, entry);
mcb->func(mcb->arg1, mcb->arg2);
kfree(mcb, M_MPIPEARY);
}
mpipe->mpflags |= MPF_QUEUEWAIT;
tsleep(&mpipe->queue, 0, "wait", 0);
}
mpipe->thread = NULL;
wakeup(mpipe);
lwkt_reltoken(&mpipe->token);
}
static struct conn *
_conn_get(void)
{
struct conn *c;
pthread_mutex_lock(&free_connq_mutex);
if (!STAILQ_EMPTY(&free_connq)) {
ASSERT(nfree_connq > 0);
c = STAILQ_FIRST(&free_connq);
nfree_connq--;
STAILQ_REMOVE(&free_connq, c, conn, c_tqe);
} else {
c = NULL;
}
pthread_mutex_unlock(&free_connq_mutex);
return c;
}
static void
apmdtor(void *data)
{
struct apm_clone_data *clone;
struct acpi_softc *acpi_sc;
clone = data;
acpi_sc = clone->acpi_sc;
/* We are about to lose a reference so check if suspend should occur */
if (acpi_sc->acpi_next_sstate != 0 &&
clone->notify_status != APM_EV_ACKED)
acpi_AckSleepState(clone, 0);
/* Remove this clone's data from the list and free it. */
ACPI_LOCK(acpi);
STAILQ_REMOVE(&acpi_sc->apm_cdevs, clone, apm_clone_data, entries);
seldrain(&clone->sel_read);
knlist_destroy(&clone->sel_read.si_note);
ACPI_UNLOCK(acpi);
free(clone, M_APMDEV);
}
static int
apmclose(struct cdev *dev, int flag, int fmt, d_thread_t *td)
{
struct apm_clone_data *clone;
struct acpi_softc *acpi_sc;
clone = dev->si_drv1;
acpi_sc = clone->acpi_sc;
/* We are about to lose a reference so check if suspend should occur */
if (acpi_sc->acpi_next_sstate != 0 &&
clone->notify_status != APM_EV_ACKED)
acpi_AckSleepState(clone, 0);
/* Remove this clone's data from the list and free it. */
ACPI_LOCK(acpi);
STAILQ_REMOVE(&acpi_sc->apm_cdevs, clone, apm_clone_data, entries);
knlist_destroy(&clone->sel_read.si_note);
ACPI_UNLOCK(acpi);
free(clone, M_APMDEV);
destroy_dev_sched(dev);
return (0);
}
void
remove_backend(struct Backend_head *head, struct Backend *backend) {
STAILQ_REMOVE(head, backend, Backend, entries);
free_backend(backend);
}
/*
* 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;
}
