Changeset 04aaf954817d7e85e9daf2feb52c9411d1acb30f

Timestamp:

12/04/08 22:19:49 (5 years ago)

Author:

Theo Schlossnagle <jesus@omniti.com>

git-committer:

Theo Schlossnagle <jesus@omniti.com> 1228429189 +0000

git-parent:

[df2e1eb8a0d6b779a1327d8df4d867b961ce4b07]

git-author:

Theo Schlossnagle <jesus@omniti.com> 1228429189 +0000

Message:

Add trigger support, compiles on Mac OS X and Solaris, changes made to Linux, but untested (even compile), refs #65

Files:

• src/eventer/eventer.h (modified) (2 diffs)
• src/eventer/eventer_epoll_impl.c (modified) (4 diffs)
• src/eventer/eventer_kqueue_impl.c (modified) (4 diffs)
• src/eventer/eventer_ports_impl.c (modified) (4 diffs)

src/eventer/eventer.h

@@ -78 +78 @@
-  eventer_t         (*remove_fd)(int fd);
-  eventer_t         (*find_fd)(int fd);
+  void              (*trigger)(eventer_t e, int mask);
-  int               (*loop)();
-} *eventer_impl_t;
@@ -99 +100 @@
-#define eventer_find_fd       __eventer->find_fd
-#define eventer_loop          __eventer->loop
+#define eventer_trigger       __eventer->trigger
-
-extern eventer_impl_t registered_eventers[];

src/eventer/eventer_epoll_impl.c

@@ -196 +196 @@
-static eventer_t eventer_epoll_impl_find_fd(int fd) {
-  return master_fds[fd].e;
+}
+
+static void eventer_epoll_impl_trigger(eventer_t e, int mask) {
+  struct timeval __now;
+  int fd, oldmask, newmask;
+  const char *cbname;
+  ev_lock_state_t lockstate;
+
+  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, "epoll: fire on %d/%x to %s(%p)\n",
+         fd, mask, cbname?cbname:"???", e->callback);
+  newmask = e->callback(e, mask, e->closure, &__now);
+
+  if(newmask) {
+    struct epoll_event _ev;
+    memset(&_ev, 0, sizeof(_ev));
+    _ev.data.fd = fd;
+    if(newmask & EVENTER_READ) _ev.events |= (EPOLLIN|EPOLLPRI);
+    if(newmask & EVENTER_WRITE) _ev.events |= (EPOLLOUT);
+    if(newmask & EVENTER_EXCEPTION) _ev.events |= (EPOLLERR|EPOLLHUP);
+    epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &_ev);
+    /* Set our mask */
+    e->mask = newmask;
+  }
+  else {
+    /* see kqueue implementation for details on the next line */
+    if(master_fds[fd].e == e) master_fds[fd].e = NULL;
+    eventer_free(e);
+  }
+  release_master_fd(fd, lockstate);
-}
-static int eventer_epoll_impl_loop() {
@@ -269 +307 @@
-      for(idx = 0; idx < fd_cnt; idx++) {
-        struct epoll_event *ev;
-        const char *cbname;
-        ev_lock_state_t lockstate;
-        eventer_t e;
-oldmask, 
+
-
-        ev = &epev[idx];
@@ -281 +317 @@
-
-        fd = ev->data.fd;
+
-        e = master_fds[fd].e;
-        /* It's possible that someone removed the event and freed it
@@ -287 +324 @@
-        if(!e) continue;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-      }
-    }

src/eventer/eventer_kqueue_impl.c

@@ -251 +251 @@
-static eventer_t eventer_kqueue_impl_find_fd(int fd) {
-  return master_fds[fd].e;
+}
+static void eventer_kqueue_impl_trigger(eventer_t e, int mask) {
+  ev_lock_state_t lockstate;
+  struct timeval __now;
+  int oldmask, newmask;
+  const char *cbname;
+  int fd;
+
+  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, "kqueue: fire on %d/%x to %s(%p)\n",
+         fd, masks[fd], cbname?cbname:"???", e->callback);
+  newmask = e->callback(e, mask, e->closure, &__now);
+
+  if(newmask) {
+    /* toggle the read bits if needed */
+    if(newmask & (EVENTER_READ | EVENTER_EXCEPTION)) {
+      if(!(oldmask & (EVENTER_READ | EVENTER_EXCEPTION)))
+        ke_change(fd, EVFILT_READ, EV_ADD | EV_ENABLE, e);
+    }
+    else if(oldmask & (EVENTER_READ | EVENTER_EXCEPTION))
+      ke_change(fd, EVFILT_READ, EV_DELETE | EV_DISABLE, e);
+
+    /* toggle the write bits if needed */
+    if(newmask & EVENTER_WRITE) {
+      if(!(oldmask & EVENTER_WRITE))
+        ke_change(fd, EVFILT_WRITE, EV_ADD | EV_ENABLE, e);
+    }
+    else if(oldmask & EVENTER_WRITE)
+        ke_change(fd, EVFILT_WRITE, EV_DELETE | EV_DISABLE, e);
+
+    /* Set our mask */
+    e->mask = newmask;
+  }
+  else {
+    /*
+     * 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 int eventer_kqueue_impl_loop() {
@@ -366 +431 @@
-      /* Loop a last time to process */
-      for(idx = 0; idx < fd_cnt; idx++) {
-        ev_lock_state_t lockstate;
-        struct kevent *ke;
-        eventer_t e;
-, oldmask
+
-
-        ke = &ke_vec[idx];
-        if(ke->flags & EV_ERROR) {
-          if(ke->data != EBADF)
-
+
+
-          continue;
-        }
@@ -384 +449 @@
-         * before we got here.
-         */
-
-
-
-
-
-
-
-
-
-
+
-        masks[fd] = 0; /* indicates we've processed this fd */
-
-        if(newmask) {
-          /* toggle the read bits if needed */
-          if(newmask & (EVENTER_READ | EVENTER_EXCEPTION)) {
-            if(!(oldmask & (EVENTER_READ | EVENTER_EXCEPTION)))
-              ke_change(fd, EVFILT_READ, EV_ADD | EV_ENABLE, e);
-          }
-          else if(oldmask & (EVENTER_READ | EVENTER_EXCEPTION))
-            ke_change(fd, EVFILT_READ, EV_DELETE | EV_DISABLE, e);
-  
-          /* toggle the write bits if needed */
-          if(newmask & EVENTER_WRITE) {
-            if(!(oldmask & EVENTER_WRITE))
-              ke_change(fd, EVFILT_WRITE, EV_ADD | EV_ENABLE, e);
-          }
-          else if(oldmask & EVENTER_WRITE)
-              ke_change(fd, EVFILT_WRITE, EV_DELETE | EV_DISABLE, e);
-  
-          /* Set our mask */
-          e->mask = newmask;
-        }
-        else {
-          /*
-           * 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);
-      }
-    }
@@ -456 +467 @@
-  eventer_kqueue_impl_remove_fd,
-  eventer_kqueue_impl_find_fd,
+  eventer_kqueue_impl_trigger,
-  eventer_kqueue_impl_loop
-};

src/eventer/eventer_ports_impl.c

@@ -201 +201 @@
-static eventer_t eventer_ports_impl_find_fd(int fd) {
-  return master_fds[fd].e;
+}
+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);
+  newmask = e->callback(e, mask, e->closure, &__now);
+
+  if(newmask) {
+    alter_fd(e, newmask);
+    /* Set our mask */
+    e->mask = newmask;
+  }
+  else {
+    /*
+     * 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 int eventer_ports_impl_loop() {
@@ -285 +335 @@
-      /* Loop a last time to process */
-      for(idx = 0; idx < fd_cnt; idx++) {
-        ev_lock_state_t lockstate;
-        port_event_t *pe;
-        eventer_t e;
@@ -305 +354 @@
-         * before we got here.
-         */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-      }
-    }
@@ -360 +370 @@
-  eventer_ports_impl_remove_fd,
-  eventer_ports_impl_find_fd,
+  eventer_ports_impl_trigger,
-  eventer_ports_impl_loop
-};