Mercurial > hg > webserver / file diff

--- a/src/server/daemon/event_solaris.c	Tue Jan 24 23:19:48 2017 +0100
+++ b/src/server/daemon/event_solaris.c	Wed Jan 25 19:19:47 2017 +0100
@@ -32,57 +32,35 @@
 
 #include "event_solaris.h"
 
-event_handler_t* evhandler_create(int numthreads) {
-    event_handler_t *ev = malloc(sizeof(event_handler_t));
-    if(ev == NULL) {
-        return NULL;
-    }
+EVHandler* evhandler_create(EventHandlerConfig *cfg) {
+    EVHandler *ev = malloc(sizeof(EVHandler));
+    ev->current = 0;
+    ev->instances = calloc(cfg->nthreads, sizeof(void*));
+    ev->numins = cfg->nthreads;
     
-    ev->ports = calloc(numthreads, sizeof(int));
-    if(ev->ports == NULL) {
-        free(ev);
-        return NULL;
-    }
-    ev->nports = numthreads;
-    ev->lp = 0;
-    
-    /* create ports event threads */
-    for(int i=0;i<numthreads;i++) {
-        /* create port */
-        ev->ports[i] = port_create();
-        if(ev->ports[i] == 0) {
-            free(ev->ports);
-            free(ev);
+    for(int i=0;i<cfg->nthreads;i++) {
+        EventHandler *handler = malloc(sizeof(EventHandler));
+        ev->instances[i] = handler;
+        
+        handler->port = port_create();
+        if(handler->port == 0) {
+            // TODO: error
             return NULL;
         }
         
-        /*
-         * start a new handler thread
-         * the thread needs the event port and a pointer to the event handler
-         */
-        ev_thr_conf_t *conf = malloc(sizeof(ev_thr_conf_t));
-        if(conf == NULL) {
-            free(ev->ports);
-            free(ev);
-            return NULL;
-        }
-        conf->handler = ev;
-        conf->port = ev->ports[i];
-        
-        systhread_start(0, 0, (thrstartfunc)ev_handle_events, conf);
-        // TODO: error handling
+        SYS_THREAD t = systhread_start(
+                0,
+                0,
+                (thrstartfunc)ev_handle_events,
+                handler);
+        systhread_detach(t);
     }
     
     return ev;
 }
 
-void ev_handle_events(ev_thr_conf_t *conf) {
-    event_handler_t *ev = conf->handler;
-    int port = conf->port;
-    
-    free(conf);
-    
-    port_event_t events[16];
+void ev_handle_events(EventHandler *ev) {   
+    port_event_t events[64];
     struct timespec timeout;
     timeout.tv_nsec = 0;
     timeout.tv_sec = 600;
@@ -90,7 +68,7 @@
     for(;;) {
         // wait for events
         uint_t nev = 1;
-        int ret = port_getn(port, events, 16, &nev, &timeout);
+        int ret = port_getn(ev->port, events, 64, &nev, &timeout);
         if(ret == -1) {
             // TODO: check for error
             perror("port_getn");
@@ -98,28 +76,21 @@
         }
         
         for(int i=0;i<nev;i++) {
-            event_t *event = events[i].portev_user;
+            Event *event = events[i].portev_user;
             if(event->fn) {
-                int saved_ev = event->poll;
                 if(event->fn(ev, event)) {
                     /*
                      * on solaris we have to reassociate the fd after
                      * each event
                      * we do this if the event function returns 1
                      */
-                    
-                    if(event->poll != saved_ev) {
-                        // event type changed
-                        int ne = 0;
-                        if((event->poll & EVENT_POLLIN) == EVENT_POLLIN) {
-                            ne |= POLLIN;
-                        }
-                        if((event->poll & EVENT_POLLOUT) == EVENT_POLLOUT) {
-                            ne |= POLLOUT;
-                        }
-                    }
-                    
-                    if(ev_poll(ev, event)) {
+                    if(port_associate(
+                            ev->port,
+                            PORT_SOURCE_FD,
+                            (uintptr_t)event->object,
+                            ev_convert2sys_events(event->events),
+                            event))
+                    {
                         perror("port_associate");
                     }                 
                 } else if(event->finish) {
@@ -130,53 +101,42 @@
     }
 }
 
-// returns a event handler port
-int ev_get_port(event_handler_t *h) {
-    int nps = h->nports;
-    if(nps == 1) {
-        return h->ports[0];
+int ev_convert2sys_events(int events) {
+    int e = 0;
+    if((events & EVENT_POLLIN) == EVENT_POLLIN) {
+        e |= POLLIN;
     }
-    
-    int cp = h->lp % nps;
-    atomic_inc_32(&h->lp);
-    
-    return h->ports[cp];
+    if((events & EVENT_POLLOUT) == EVENT_POLLOUT) {
+        e |= POLLOUT;
+    }
+    return e;
 }
 
-int ev_pollin(event_handler_t *h, int fd, event_t *event) {
+
+int ev_pollin(EventHandler *h, int fd, Event *event) {
     event->object = (intptr_t)fd;
-    event->events = POLLIN;
-    event->poll = EVENT_POLLIN;
+    event->events = EVENT_POLLIN;
     return port_associate(
-            ev_get_port(h),
+            h->port,
             PORT_SOURCE_FD,
             (uintptr_t)fd,
             POLLIN,
             event);
 }
 
-int ev_pollout(event_handler_t *h, int fd, event_t *event) {
+int ev_pollout(EventHandler *h, int fd, Event *event) {
     event->object = (intptr_t)fd;
-    event->events = POLLOUT;
-    event->poll = EVENT_POLLOUT;
+    event->events = EVENT_POLLOUT;
     return port_associate(
-            ev_get_port(h),
+            h->port,
             PORT_SOURCE_FD,
             (uintptr_t)fd,
             POLLOUT,
             event);
 }
 
-int ev_poll(event_handler_t *h, event_t *event) {
-    return port_associate(
-            ev_get_port(h),
-            PORT_SOURCE_FD,
-            event->object,
-            event->events,
-            event);
+int evt_send(EventHandler *h, Event *event) {
+    event->object = 0;
+    event->events = 0;
+    return port_send(h->port, 0, event);
 }
-
-int evt_send(event_handler_t *h, event_t *event) {
-    event->object = 0;
-    return port_send(ev_get_port(h), 0, event);
-}