static eventer_t eventer_ports_impl_remove(eventer_t e) {
eventer_t removed = NULL;
if(e->mask & EVENTER_ASYNCH) {
mtevFatal(mtev_error, "error in eventer_ports_impl_remove: got unexpected EVENTER_ASYNCH mask\n");
}
if(e->mask & (EVENTER_READ | EVENTER_WRITE | EVENTER_EXCEPTION)) {
ev_lock_state_t lockstate;
lockstate = acquire_master_fd(e->fd);
if(e == master_fds[e->fd].e) {
removed = e;
master_fds[e->fd].e = NULL;
alter_fd(e, 0);
}
release_master_fd(e->fd, lockstate);
}
else if(e->mask & EVENTER_TIMER) {
removed = eventer_remove_timed(e);
}
else if(e->mask & EVENTER_RECURRENT) {
removed = eventer_remove_recurrent(e);
}
else {
mtevFatal(mtev_error, "error in eventer_ports_impl_remove: got unknown mask (0x%04x)\n",
e->mask);
}
return removed;
}
static void eventer_ports_impl_add(eventer_t e) {
mtevAssert(e->mask);
ev_lock_state_t lockstate;
const char *cbname;
cbname = eventer_name_for_callback_e(e->callback, e);
if(e->mask & EVENTER_ASYNCH) {
mtevL(eventer_deb, "debug: eventer_add asynch (%s)\n", cbname ? cbname : "???");
eventer_add_asynch(NULL, e);
return;
}
/* Recurrent delegation */
if(e->mask & EVENTER_RECURRENT) {
mtevL(eventer_deb, "debug: eventer_add recurrent (%s)\n", cbname ? cbname : "???");
eventer_add_recurrent(e);
return;
}
/* Timed events are simple */
if(e->mask & EVENTER_TIMER) {
eventer_add_timed(e);
return;
}
/* file descriptor event */
mtevL(eventer_deb, "debug: eventer_add fd (%s,%d,0x%04x)\n", cbname ? cbname : "???", e->fd, e->mask);
lockstate = acquire_master_fd(e->fd);
mtevAssert(e->whence.tv_sec == 0 && e->whence.tv_usec == 0);
master_fds[e->fd].e = e;
alter_fd(e, e->mask);
release_master_fd(e->fd, lockstate);
}
static eventer_t eventer_ports_impl_remove(eventer_t e) {
eventer_t removed = NULL;
if(e->mask & EVENTER_ASYNCH) {
abort();
}
if(e->mask & (EVENTER_READ | EVENTER_WRITE | EVENTER_EXCEPTION)) {
ev_lock_state_t lockstate;
lockstate = acquire_master_fd(e->fd);
if(e == master_fds[e->fd].e) {
removed = e;
master_fds[e->fd].e = NULL;
alter_fd(e, 0);
}
release_master_fd(e->fd, lockstate);
}
else if(e->mask & EVENTER_TIMER) {
removed = eventer_remove_timed(e);
}
else if(e->mask & EVENTER_RECURRENT) {
removed = eventer_remove_recurrent(e);
}
else {
abort();
}
return removed;
}
static void eventer_ports_impl_update(eventer_t e, int mask) {
if(e->mask & EVENTER_TIMER) {
eventer_update_timed_internal(e,mask,&e->whence);
return;
}
alter_fd(e, mask);
e->mask = mask;
}
static void
eventer_ports_impl_trigger(eventer_t e, int mask) {
ev_lock_state_t lockstate;
const char *cbname;
struct timeval __now;
int fd, oldmask, newmask;
fd = e->fd;
if(e != master_fds[fd].e) return;
lockstate = acquire_master_fd(fd);
if(lockstate == EV_ALREADY_OWNED) return;
assert(lockstate == EV_OWNED);
gettimeofday(&__now, NULL);
oldmask = e->mask;
cbname = eventer_name_for_callback(e->callback);
noitLT(eventer_deb, &__now, "ports: fire on %d/%x to %s(%p)\n",
fd, mask, cbname?cbname:"???", e->callback);
EVENTER_CALLBACK_ENTRY((void *)e->callback, (char *)cbname, fd, e->mask, mask);
newmask = e->callback(e, mask, e->closure, &__now);
EVENTER_CALLBACK_RETURN((void *)e->callback, (char *)cbname, newmask);
if(newmask) {
alter_fd(e, newmask);
/* Set our mask */
e->mask = newmask;
noitLT(eventer_deb, &__now, "ports: complete on %d/(%x->%x) to %s(%p)\n",
fd, mask, newmask, cbname?cbname:"???", e->callback);
}
else {
noitLT(eventer_deb, &__now, "ports: complete on %d/none to %s(%p)\n",
fd, cbname?cbname:"???", e->callback);
/*
* Long story long:
* When integrating with a few external event systems, we find
* it difficult to make their use of remove+add as an update
* as it can be recurrent in a single handler call and you cannot
* remove completely from the event system if you are going to
* just update (otherwise the eventer_t in your call stack could
* be stale). What we do is perform a superficial remove, marking
* the mask as 0, but not eventer_remove_fd. Then on an add, if
* we already have an event, we just update the mask (as we
* have not yet returned to the eventer's loop.
* This leaves us in a tricky situation when a remove is called
* and the add doesn't roll in, we return 0 (mask == 0) and hit
* this spot. We have intended to remove the event, but it still
* resides at master_fds[fd].e -- even after we free it.
* So, in the evnet that we return 0 and the event that
* master_fds[fd].e == the event we're about to free... we NULL
* it out.
*/
if(master_fds[fd].e == e) master_fds[fd].e = NULL;
eventer_free(e);
}
release_master_fd(fd, lockstate);
}
static eventer_t eventer_ports_impl_remove_fd(int fd) {
eventer_t eiq = NULL;
ev_lock_state_t lockstate;
if(master_fds[fd].e) {
lockstate = acquire_master_fd(fd);
eiq = master_fds[fd].e;
master_fds[fd].e = NULL;
alter_fd(eiq, 0);
release_master_fd(fd, lockstate);
}
return eiq;
}
static eventer_t eventer_ports_impl_remove_fd(int fd) {
eventer_t eiq = NULL;
ev_lock_state_t lockstate;
if(master_fds[fd].e) {
lockstate = acquire_master_fd(fd);
/* Looks redundant, but we need to make sure we didn't lose
* the event between checking and acquiring the lock */
if(master_fds[fd].e) {
eiq = master_fds[fd].e;
master_fds[fd].e = NULL;
alter_fd(eiq, 0);
}
release_master_fd(fd, lockstate);
}
return eiq;
}
static void
eventer_ports_impl_trigger(eventer_t e, int mask) {
ev_lock_state_t lockstate;
const char *cbname;
struct timeval __now;
int fd, newmask;
uint64_t start, duration;
int cross_thread = mask & EVENTER_CROSS_THREAD_TRIGGER;
mask = mask & ~(EVENTER_RESERVED);
fd = e->fd;
if(cross_thread) {
if(master_fds[fd].e != NULL) {
mtevL(eventer_deb, "Attempting to trigger already-registered event fd: %d cross thread.\n", fd);
}
/* mtevAssert(master_fds[fd].e == NULL); */
}
if(!pthread_equal(pthread_self(), e->thr_owner)) {
/* If we're triggering across threads, it can't be registered yet */
if(master_fds[fd].e != NULL) {
mtevL(eventer_deb, "Attempting to trigger already-registered event fd: %d cross thread.\n", fd);
}
/* mtevAssert(master_fds[fd].e == NULL); */
eventer_cross_thread_trigger(e,mask);
return;
}
if(master_fds[fd].e == NULL) {
lockstate = acquire_master_fd(fd);
if (lockstate == EV_ALREADY_OWNED) {
/* The incoming triggered event is already owned by this thread.
This means our floated event completed before the current
event handler even exited. So it retriggered recursively
from inside the event handler.
Treat this special case the same as a cross thread trigger
and just queue this event to be picked up on the next loop
*/
eventer_cross_thread_trigger(e, mask);
return;
}
release_master_fd(fd, lockstate);
master_fds[fd].e = e;
e->mask = 0;
}
if(e != master_fds[fd].e) return;
lockstate = acquire_master_fd(fd);
if(lockstate == EV_ALREADY_OWNED) {
mtevL(eventer_deb, "Incoming event: %p already owned by this thread\n", e);
return;
}
mtevAssert(lockstate == EV_OWNED);
eventer_mark_callback_time();
eventer_gettimeofcallback(&__now, NULL);
cbname = eventer_name_for_callback_e(e->callback, e);
mtevL(eventer_deb, "ports: fire on %d/%x to %s(%p)\n",
fd, mask, cbname?cbname:"???", e->callback);
mtev_memory_begin();
LIBMTEV_EVENTER_CALLBACK_ENTRY((void *)e, (void *)e->callback, (char *)cbname, fd, e->mask, mask);
start = mtev_gethrtime();
newmask = eventer_run_callback(e, mask, e->closure, &__now);
duration = mtev_gethrtime() - start;
LIBMTEV_EVENTER_CALLBACK_RETURN((void *)e, (void *)e->callback, (char *)cbname, newmask);
mtev_memory_end();
stats_set_hist_intscale(eventer_callback_latency, duration, -9, 1);
stats_set_hist_intscale(eventer_latency_handle_for_callback(e->callback), duration, -9, 1);
if(newmask) {
if(!pthread_equal(pthread_self(), e->thr_owner)) {
pthread_t tgt = e->thr_owner;
e->thr_owner = pthread_self();
alter_fd(e, 0);
e->thr_owner = tgt;
alter_fd(e, newmask);
mtevL(eventer_deb, "moved event[%p] from t@%d to t@%d\n", e, pthread_self(), tgt);
}
else {
alter_fd(e, newmask);
/* Set our mask */
e->mask = newmask;
mtevL(eventer_deb, "ports: complete on %d/(%x->%x) to %s(%p)\n",
fd, mask, newmask, cbname?cbname:"???", e->callback);
}
}
else {
mtevL(eventer_deb, "ports: complete on %d/none to %s(%p)\n",
fd, cbname?cbname:"???", e->callback);
/*
* Long story long:
* When integrating with a few external event systems, we find
* it difficult to make their use of remove+add as an update
* as it can be recurrent in a single handler call and you cannot
* remove completely from the event system if you are going to
* just update (otherwise the eventer_t in your call stack could
* be stale). What we do is perform a superficial remove, marking
* the mask as 0, but not eventer_remove_fd. Then on an add, if
* we already have an event, we just update the mask (as we
* have not yet returned to the eventer's loop.
* This leaves us in a tricky situation when a remove is called
* and the add doesn't roll in, we return 0 (mask == 0) and hit
* this spot. We have intended to remove the event, but it still
* resides at master_fds[fd].e -- even after we free it.
* So, in the evnet that we return 0 and the event that
* master_fds[fd].e == the event we're about to free... we NULL
* it out.
*/
if(master_fds[fd].e == e) master_fds[fd].e = NULL;
eventer_free(e);
}
release_master_fd(fd, lockstate);
}
