/* must be called with resource lock held */
static int
lnet_md_link(struct lnet_libmd *md, struct lnet_handle_eq eq_handle, int cpt)
{
struct lnet_res_container *container = the_lnet.ln_md_containers[cpt];
/*
* NB we are passed an allocated, but inactive md.
* if we return success, caller may lnet_md_unlink() it.
* otherwise caller may only kfree() it.
*/
/*
* This implementation doesn't know how to create START events or
* disable END events. Best to LASSERT our caller is compliant so
* we find out quickly...
*/
/*
* TODO - reevaluate what should be here in light of
* the removal of the start and end events
* maybe there we shouldn't even allow LNET_EQ_NONE!)
* LASSERT(!eq);
*/
if (!LNetEQHandleIsInvalid(eq_handle)) {
md->md_eq = lnet_handle2eq(&eq_handle);
if (!md->md_eq)
return -ENOENT;
(*md->md_eq->eq_refs[cpt])++;
}
lnet_res_lh_initialize(container, &md->md_lh);
LASSERT(list_empty(&md->md_list));
list_add(&md->md_list, &container->rec_active);
return 0;
}
int
LNetEQPoll (lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
lnet_event_t *event, int *which)
{
int i;
int rc;
#ifdef __KERNEL__
cfs_waitlink_t wl;
cfs_time_t now;
#else
struct timeval then;
struct timeval now;
# ifdef HAVE_LIBPTHREAD
struct timespec ts;
# endif
lnet_ni_t *eqwaitni = the_lnet.ln_eqwaitni;
#endif
ENTRY;
LASSERT (the_lnet.ln_init);
LASSERT (the_lnet.ln_refcount > 0);
if (neq < 1)
RETURN(-ENOENT);
LNET_LOCK();
for (;;) {
#ifndef __KERNEL__
LNET_UNLOCK();
/* Recursion breaker */
if (the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING &&
!LNetHandleIsEqual(eventqs[0], the_lnet.ln_rc_eqh))
lnet_router_checker();
LNET_LOCK();
#endif
for (i = 0; i < neq; i++) {
lnet_eq_t *eq = lnet_handle2eq(&eventqs[i]);
if (eq == NULL) {
LNET_UNLOCK();
RETURN(-ENOENT);
}
rc = lib_get_event (eq, event);
if (rc != 0) {
LNET_UNLOCK();
*which = i;
RETURN(rc);
}
}
#ifdef __KERNEL__
if (timeout_ms == 0) {
LNET_UNLOCK();
RETURN (0);
}
cfs_waitlink_init(&wl);
set_current_state(TASK_INTERRUPTIBLE);
cfs_waitq_add(&the_lnet.ln_waitq, &wl);
LNET_UNLOCK();
if (timeout_ms < 0) {
cfs_waitq_wait (&wl, CFS_TASK_INTERRUPTIBLE);
} else {
struct timeval tv;
now = cfs_time_current();
cfs_waitq_timedwait(&wl, CFS_TASK_INTERRUPTIBLE,
cfs_time_seconds(timeout_ms)/1000);
cfs_duration_usec(cfs_time_sub(cfs_time_current(), now),
&tv);
timeout_ms -= tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (timeout_ms < 0)
timeout_ms = 0;
}
LNET_LOCK();
cfs_waitq_del(&the_lnet.ln_waitq, &wl);
#else
if (eqwaitni != NULL) {
/* I have a single NI that I have to call into, to get
* events queued, or to block. */
lnet_ni_addref_locked(eqwaitni);
LNET_UNLOCK();
if (timeout_ms <= 0) {
(eqwaitni->ni_lnd->lnd_wait)(eqwaitni, timeout_ms);
} else {
gettimeofday(&then, NULL);
(eqwaitni->ni_lnd->lnd_wait)(eqwaitni, timeout_ms);
gettimeofday(&now, NULL);
timeout_ms -= (now.tv_sec - then.tv_sec) * 1000 +
(now.tv_usec - then.tv_usec) / 1000;
if (timeout_ms < 0)
timeout_ms = 0;
}
LNET_LOCK();
lnet_ni_decref_locked(eqwaitni);
/* don't call into eqwaitni again if timeout has
* expired */
if (timeout_ms == 0)
eqwaitni = NULL;
continue; /* go back and check for events */
}
if (timeout_ms == 0) {
LNET_UNLOCK();
RETURN (0);
}
# ifndef HAVE_LIBPTHREAD
/* If I'm single-threaded, LNET fails at startup if it can't
* set the_lnet.ln_eqwaitni correctly. */
LBUG();
# else
if (timeout_ms < 0) {
pthread_cond_wait(&the_lnet.ln_cond,
&the_lnet.ln_lock);
} else {
gettimeofday(&then, NULL);
ts.tv_sec = then.tv_sec + timeout_ms/1000;
ts.tv_nsec = then.tv_usec * 1000 +
(timeout_ms%1000) * 1000000;
if (ts.tv_nsec >= 1000000000) {
ts.tv_sec++;
ts.tv_nsec -= 1000000000;
}
pthread_cond_timedwait(&the_lnet.ln_cond,
&the_lnet.ln_lock, &ts);
gettimeofday(&now, NULL);
timeout_ms -= (now.tv_sec - then.tv_sec) * 1000 +
(now.tv_usec - then.tv_usec) / 1000;
if (timeout_ms < 0)
timeout_ms = 0;
}
# endif
#endif
}
}