src/IOEngine_kevent.c

   1 /* IOengine_kevent.c - IOMultiplexer
   2  * Copyright (C) 2012  Philipp Kreil (pk910)
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 #include "IOEngine.h"
  18
  19 #ifdef HAVE_SYS_EVENT_H
  20 #include <sys/event.h>
  21
  22 #define MAX_EVENTS 32
  23
  24 static int kevent_fd;
  25
  26 static int engine_kevent_init() {
  27     kevent_fd = kqueue();
  28     if (kevent_fd < 0)
  29         return 0;
  30     return 1;
  31 }
  32
  33 static void engine_kevent_add(struct IODescriptor *iofd) {
  34     if(iofd->type == IOTYPE_TIMER) return;
  35     //add descriptor to the kevent queue
  36     struct kevent changes[2];
  37     int nchanges = 0;
  38     int res;
  39
  40     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_READ, EV_ADD, 0, 0, iofd);
  41     if (iohandler_wants_writes(iofd))
  42         EV_SET(&changes[nchanges++], iofd->fd, EVFILT_WRITE, EV_ADD, 0, 0, iofd);
  43
  44     res = kevent(kevent_fd, changes, nchanges, NULL, 0, NULL);
  45     if(res < 0)
  46         iohandler_log(IOLOG_ERROR, "could not add IODescriptor %d to kevent queue. (returned: %d)", res);
  47     }
  48 }
  49
  50 static void engine_kevent_remove(struct IODescriptor *iofd) {
  51     if(iofd->type == IOTYPE_TIMER) return;
  52     struct kevent changes[2];
  53     int nchanges = 0;
  54
  55     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_READ, EV_DELETE, 0, 0, iofd);
  56     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_WRITE, EV_DELETE, 0, 0, iofd);
  57     kevent(kevent_fd, changes, nchanges, NULL, 0, NULL);
  58 }
  59
  60 static void engine_kevent_update(struct IODescriptor *iofd) {
  61     if(iofd->type == IOTYPE_TIMER) return;
  62     if(iofd->state == IO_CLOSED) {
  63         engine_epoll_remove(iofd);
  64         return;
  65     }
  66     struct kevent changes[2];
  67     int nchanges = 0;
  68     int res;
  69
  70     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_READ, EV_ADD, 0, 0, iofd);
  71     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_WRITE, iohandler_wants_writes(iofd) ? EV_ADD : EV_DELETE, 0, 0, iofd);
  72
  73     res = kevent(kevent_fd, changes, nchanges, NULL, 0, NULL);
  74     if(res < 0) {
  75         iohandler_log(IOLOG_ERROR, "could not update IODescriptor %d in kevent queue. (returned: %d)", res);
  76     }
  77 }
  78
  79 static void engine_kevent_loop(struct timeval *timeout) {
  80     struct kevent evts[MAX_EVENTS];
  81     struct timeval now, tdiff;
  82     struct timespec ts, *ptr
  83     int msec;
  84     int events;
  85     int kevent_result;
  86
  87     gettimeofday(&now, NULL);
  88
  89     while(timer_priority) {
  90         tdiff.tv_sec = timer_priority->timeout.tv_sec - now.tv_sec;
  91         tdiff.tv_usec = timer_priority->timeout.tv_usec - now.tv_usec;
  92         if(tdiff.tv_sec < 0 || (tdiff.tv_sec == 0 && tdiff.tv_usec <= 0)) {
  93             iohandler_events(timer_priority, 0, 0);
  94             iohandler_close(timer_priority); //also sets timer_priority to the next timed element
  95             continue;
  96         } else if(tdiff.tv_usec < 0) {
  97             tdiff.tv_sec--;
  98             tdiff.tv_usec += 1000000; //1 sec
  99         }
 100         if(timeval_is_smaler((&tdiff), timeout)) {
 101             timeout->tv_sec = tdiff.tv_sec;
 102             timeout->tv_usec = tdiff.tv_usec;
 103         }
 104         break;
 105     }
 106
 107     if (timeout) {
 108         ts.tv_sec = timeout->tv_sec;
 109         ts.tv_nsec = timeout->tv_usec * 1000;
 110         pts = &ts;
 111     } else {
 112         pts = NULL;
 113     }
 114
 115     //select system call
 116     kevent_result = kevent(kq_fd, NULL, 0, events, MAX_EVENTS, pts);
 117
 118     if (kevent_result < 0) {
 119         if (errno != EINTR) {
 120             iohandler_log(IOLOG_FATAL, "kevent() failed with errno %d: %s", errno, strerror(errno));
 121             return;
 122         }
 123     } else {
 124         int i;
 125         for(i = 0; i < kevent_result; i++)
 126             iohandler_events(evts[i].udata, (evts[i].filter == EVFILT_READ), (evts[i].filter == EVFILT_WRITE));
 127     }
 128
 129     //check timers
 130     while(timer_priority) {
 131         tdiff.tv_sec = timer_priority->timeout.tv_sec - now.tv_sec;
 132         tdiff.tv_usec = timer_priority->timeout.tv_usec - now.tv_usec;
 133         if(tdiff.tv_sec < 0 || (tdiff.tv_sec == 0 && tdiff.tv_usec <= 0)) {
 134             iohandler_events(timer_priority, 0, 0);
 135             iohandler_close(timer_priority); //also sets timer_priority to the next timed element
 136             continue;
 137         }
 138         break;
 139     }
 140
 141 }
 142
 143 static void engine_kevent_cleanup() {
 144     close(kevent_fd);
 145 }
 146
 147 struct IOEngine engine_kevent = {
 148     .name = "kevent",
 149     .init = engine_kevent_init,
 150     .add = engine_kevent_add,
 151     .remove = engine_kevent_remove,
 152     .update = engine_kevent_update,
 153     .loop = engine_kevent_loop,
 154     .cleanup = engine_kevent_cleanup,
 155 };
 156
 157 #else
 158
 159 struct IOEngine engine_kevent = {
 160     .name = "kevent",
 161     .init = NULL,
 162     .add = NULL,
 163     .remove = NULL,
 164     .update = NULL,
 165     .loop = NULL,
 166     .cleanup = NULL,
 167 };
 168
 169 #endif