static void
ke_change (register int const ident,
register int const filter,
register int const flags,
register eventer_t e) {
register struct kevent *kep;
KQUEUE_DECL;
KQUEUE_SETUP;
if(!kqs) kqs = master_kqs;
if(kqs == master_kqs) pthread_mutex_lock(&kqs_lock);
if (!ke_vec_a) {
kqs_init(kqs);
}
else if (ke_vec_used == ke_vec_a) {
ke_vec_a <<= 1;
ke_vec = (struct kevent *) realloc(ke_vec,
ke_vec_a * sizeof (struct kevent));
}
kep = &ke_vec[ke_vec_used++];
EV_SET(kep, ident, filter, flags, 0, 0, (void *)(vpsized_int)e->fd);
noitL(eventer_deb, "debug: ke_change(fd:%d, filt:%x, flags:%x)\n",
ident, filter, flags);
if(kqs == master_kqs) pthread_mutex_unlock(&kqs_lock);
}
static void *eventer_kqueue_spec_alloc() {
struct kqueue_spec *spec;
spec = calloc(1, sizeof(*spec));
spec->kqueue_fd = kqueue();
if(spec->kqueue_fd == -1) {
mtevFatal(mtev_error, "error in eveter_kqueue_spec_alloc... spec->epoll_fd < 0 (%d)\n",
spec->kqueue_fd);
}
kqs_init(spec);
pthread_mutex_init(&spec->lock, NULL);
return spec;
}
static int eventer_kqueue_impl_init() {
struct rlimit rlim;
int rv;
/* super init */
if((rv = eventer_impl_init()) != 0) return rv;
signal(SIGPIPE, SIG_IGN);
kqueue_fd = kqueue();
if(kqueue_fd == -1) {
return -1;
}
pthread_mutex_init(&kqs_lock, NULL);
pthread_key_create(&kqueue_setup_key, NULL);
master_kqs = calloc(1, sizeof(*master_kqs));
kqs_init(master_kqs);
getrlimit(RLIMIT_NOFILE, &rlim);
maxfds = rlim.rlim_cur;
master_fds = calloc(maxfds, sizeof(*master_fds));
masks = calloc(maxfds, sizeof(*masks));
return 0;
}
static int eventer_kqueue_impl_loop() {
struct timeval __dyna_sleep = { 0, 0 };
KQUEUE_DECL;
KQUEUE_SETUP;
if(!kqs) {
kqs = calloc(1, sizeof(*kqs));
kqs_init(kqs);
}
pthread_setspecific(kqueue_setup_key, kqs);
while(1) {
struct timeval __now, __sleeptime;
struct timespec __kqueue_sleeptime;
int fd_cnt = 0;
if(compare_timeval(eventer_max_sleeptime, __dyna_sleep) < 0)
__dyna_sleep = eventer_max_sleeptime;
__sleeptime = __dyna_sleep;
eventer_dispatch_timed(&__now, &__sleeptime);
if(compare_timeval(__sleeptime, __dyna_sleep) > 0)
__sleeptime = __dyna_sleep;
/* Handle recurrent events */
eventer_dispatch_recurrent(&__now);
/* If we're the master, we need to lock the master_kqs and make mods */
if(master_kqs->__ke_vec_used) {
struct timespec __zerotime = { 0, 0 };
pthread_mutex_lock(&kqs_lock);
fd_cnt = kevent(kqueue_fd,
master_kqs->__ke_vec, master_kqs->__ke_vec_used,
NULL, 0,
&__zerotime);
noitLT(eventer_deb, &__now, "debug: kevent(%d, [], %d) => %d\n", kqueue_fd, master_kqs->__ke_vec_used, fd_cnt);
if(fd_cnt < 0) {
noitLT(eventer_err, &__now, "kevent: %s\n", strerror(errno));
}
master_kqs->__ke_vec_used = 0;
pthread_mutex_unlock(&kqs_lock);
}
/* Now we move on to our fd-based events */
__kqueue_sleeptime.tv_sec = __sleeptime.tv_sec;
__kqueue_sleeptime.tv_nsec = __sleeptime.tv_usec * 1000;
fd_cnt = kevent(kqueue_fd, ke_vec, ke_vec_used,
ke_vec, ke_vec_a,
&__kqueue_sleeptime);
noitLT(eventer_deb, &__now, "debug: kevent(%d, [], %d) => %d\n", kqueue_fd, ke_vec_used, fd_cnt);
ke_vec_used = 0;
if(fd_cnt < 0) {
noitLT(eventer_err, &__now, "kevent: %s\n", strerror(errno));
}
else if(fd_cnt == 0) {
/* timeout */
add_timeval(__dyna_sleep, __dyna_increment, &__dyna_sleep);
}
else {
int idx;
__dyna_sleep.tv_sec = __dyna_sleep.tv_usec = 0; /* reset */
/* loop once to clear */
for(idx = 0; idx < fd_cnt; idx++) {
struct kevent *ke;
ke = &ke_vec[idx];
if(ke->flags & EV_ERROR) continue;
masks[ke->ident] = 0;
}
/* Loop again to aggregate */
for(idx = 0; idx < fd_cnt; idx++) {
struct kevent *ke;
ke = &ke_vec[idx];
if(ke->flags & EV_ERROR) continue;
if(ke->filter == EVFILT_READ) masks[ke->ident] |= EVENTER_READ;
if(ke->filter == EVFILT_WRITE) masks[ke->ident] |= EVENTER_WRITE;
}
/* Loop a last time to process */
for(idx = 0; idx < fd_cnt; idx++) {
struct kevent *ke;
eventer_t e;
int fd;
ke = &ke_vec[idx];
if(ke->flags & EV_ERROR) {
if(ke->data != EBADF && ke->data != ENOENT)
noitLT(eventer_err, &__now, "error [%d]: %s\n",
(int)ke->ident, strerror(ke->data));
continue;
}
assert((vpsized_int)ke->udata == (vpsized_int)ke->ident);
fd = ke->ident;
e = master_fds[fd].e;
/* If we've seen this fd, don't callback twice */
if(!masks[fd]) continue;
/* It's possible that someone removed the event and freed it
* before we got here.
*/
if(e) eventer_kqueue_impl_trigger(e, masks[fd]);
masks[fd] = 0; /* indicates we've processed this fd */
}
}
}
/* NOTREACHED */
return 0;
}
