kqueue.c File Reference

#include "uv.h"
#include "internal.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <sys/event.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>

Go to the source code of this file.

Macros
#define	EV_OOBAND   EV_FLAG1

Functions
static void	uv__fs_event (uv_loop_t *loop, uv__io_t *w, unsigned int fflags)
int	uv__kqueue_init (uv_loop_t *loop)
int	uv__io_fork (uv_loop_t *loop)
int	uv__io_check_fd (uv_loop_t *loop, int fd)
void	uv__io_poll (uv_loop_t *loop, int timeout)
void	uv__platform_invalidate_fd (uv_loop_t *loop, int fd)
int	uv_fs_event_init (uv_loop_t *loop, uv_fs_event_t *handle)
int	uv_fs_event_start (uv_fs_event_t *handle, uv_fs_event_cb cb, const char *path, unsigned int flags)
int	uv_fs_event_stop (uv_fs_event_t *handle)
void	uv__fs_event_close (uv_fs_event_t *handle)

Macro Definition Documentation

EV_OOBAND

#define EV_OOBAND   EV_FLAG1

Definition at line 45 of file kqueue.c.

Function Documentation

uv__fs_event()

static void uv__fs_event ( uv_loop_t *  loop, uv__io_t *  w, unsigned int  fflags  )

static

Definition at line 444 of file kqueue.c.

                                                                            {
  uv_fs_event_t* handle;
  struct kevent ev;
  int events;
  const char* path;
#if defined(F_GETPATH)
  /* MAXPATHLEN == PATH_MAX but the former is what XNU calls it internally. */
  char pathbuf[MAXPATHLEN];
#endif
 
  handle = container_of(w, uv_fs_event_t, event_watcher);
 
  if (fflags & (NOTE_ATTRIB | NOTE_EXTEND))
    events = UV_CHANGE;
  else
    events = UV_RENAME;
 
  path = NULL;
#if defined(F_GETPATH)
  /* Also works when the file has been unlinked from the file system. Passing
   * in the path when the file has been deleted is arguably a little strange
   * but it's consistent with what the inotify backend does.
   */
  if (fcntl(handle->event_watcher.fd, F_GETPATH, pathbuf) == 0)
    path = uv__basename_r(pathbuf);
#endif
  handle->cb(handle, path, events, 0);
 
  if (handle->event_watcher.fd == -1)
    return;
 
  /* Watcher operates in one-shot mode, re-arm it. */
  fflags = NOTE_ATTRIB | NOTE_WRITE  | NOTE_RENAME
         | NOTE_DELETE | NOTE_EXTEND | NOTE_REVOKE;
 
  EV_SET(&ev, w->fd, EVFILT_VNODE, EV_ADD | EV_ONESHOT, fflags, 0, 0);
 
  if (kevent(loop->backend_fd, &ev, 1, NULL, 0, NULL))
    abort();
}

References container_of, fcntl, handle, loop, NULL, path, UV_CHANGE, UV_RENAME, and w.

Referenced by uv__io_poll(), and uv_fs_event_start().

uv__fs_event_close()

void uv__fs_event_close

(

uv_fs_event_t *

handle

)

Definition at line 583 of file kqueue.c.

                                               {
  uv_fs_event_stop(handle);
}

References handle, and uv_fs_event_stop().

uv__io_check_fd()

int uv__io_check_fd	(	uv_loop_t *	loop,
		int	fd
	)

Definition at line 94 of file kqueue.c.

                                             {
  struct kevent ev;
  int rc;
 
  rc = 0;
  EV_SET(&ev, fd, EVFILT_READ, EV_ADD, 0, 0, 0);
  if (kevent(loop->backend_fd, &ev, 1, NULL, 0, NULL))
    rc = UV__ERR(errno);
 
  EV_SET(&ev, fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
  if (rc == 0)
    if (kevent(loop->backend_fd, &ev, 1, NULL, 0, NULL))
      abort();
 
  return rc;
}

References fd, loop, NULL, and UV__ERR.

uv__io_fork()

int uv__io_fork

(

uv_loop_t *

loop

)

Definition at line 66 of file kqueue.c.

                                 {
  int err;
  loop->backend_fd = -1;
  err = uv__kqueue_init(loop);
  if (err)
    return err;
 
#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
  if (loop->cf_state != NULL) {
    /* We cannot start another CFRunloop and/or thread in the child
       process; CF aborts if you try or if you try to touch the thread
       at all to kill it. So the best we can do is ignore it from now
       on. This means we can't watch directories in the same way
       anymore (like other BSDs). It also means we cannot properly
       clean up the allocated resources; calling
       uv__fsevents_loop_delete from uv_loop_close will crash the
       process. So we sidestep the issue by pretending like we never
       started it in the first place.
    */
    uv__store_relaxed(&uv__has_forked_with_cfrunloop, 1);
    uv__free(loop->cf_state);
    loop->cf_state = NULL;
  }
#endif /* #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 */
  return err;
}

References err, loop, NULL, uv__free(), uv__kqueue_init(), and uv__store_relaxed.

uv__io_poll()

void uv__io_poll	(	uv_loop_t *	loop,
		int	timeout
	)

Definition at line 112 of file kqueue.c.

                                               {
  struct kevent events[1024];
  struct kevent* ev;
  struct timespec spec;
  unsigned int nevents;
  unsigned int revents;
  QUEUE* q;
  uv__io_t* w;
  sigset_t* pset;
  sigset_t set;
  uint64_t base;
  uint64_t diff;
  int have_signals;
  int filter;
  int fflags;
  int count;
  int nfds;
  int fd;
  int op;
  int i;
  int user_timeout;
  int reset_timeout;
 
  if (loop->nfds == 0) {
    assert(QUEUE_EMPTY(&loop->watcher_queue));
    return;
  }
 
  nevents = 0;
 
  while (!QUEUE_EMPTY(&loop->watcher_queue)) {
    q = QUEUE_HEAD(&loop->watcher_queue);
    QUEUE_REMOVE(q);
    QUEUE_INIT(q);
 
    w = QUEUE_DATA(q, uv__io_t, watcher_queue);
    assert(w->pevents != 0);
    assert(w->fd >= 0);
    assert(w->fd < (int) loop->nwatchers);
 
    if ((w->events & POLLIN) == 0 && (w->pevents & POLLIN) != 0) {
      filter = EVFILT_READ;
      fflags = 0;
      op = EV_ADD;
 
      if (w->cb == uv__fs_event) {
        filter = EVFILT_VNODE;
        fflags = NOTE_ATTRIB | NOTE_WRITE  | NOTE_RENAME
               | NOTE_DELETE | NOTE_EXTEND | NOTE_REVOKE;
        op = EV_ADD | EV_ONESHOT; /* Stop the event from firing repeatedly. */
      }
 
      EV_SET(events + nevents, w->fd, filter, op, fflags, 0, 0);
 
      if (++nevents == ARRAY_SIZE(events)) {
        if (kevent(loop->backend_fd, events, nevents, NULL, 0, NULL))
          abort();
        nevents = 0;
      }
    }
 
    if ((w->events & POLLOUT) == 0 && (w->pevents & POLLOUT) != 0) {
      EV_SET(events + nevents, w->fd, EVFILT_WRITE, EV_ADD, 0, 0, 0);
 
      if (++nevents == ARRAY_SIZE(events)) {
        if (kevent(loop->backend_fd, events, nevents, NULL, 0, NULL))
          abort();
        nevents = 0;
      }
    }
 
   if ((w->events & UV__POLLPRI) == 0 && (w->pevents & UV__POLLPRI) != 0) {
      EV_SET(events + nevents, w->fd, EV_OOBAND, EV_ADD, 0, 0, 0);
 
      if (++nevents == ARRAY_SIZE(events)) {
        if (kevent(loop->backend_fd, events, nevents, NULL, 0, NULL))
          abort();
        nevents = 0;
      }
    }
 
    w->events = w->pevents;
  }
 
  pset = NULL;
  if (loop->flags & UV_LOOP_BLOCK_SIGPROF) {
    pset = &set;
    sigemptyset(pset);
    sigaddset(pset, SIGPROF);
  }
 
  assert(timeout >= -1);
  base = loop->time;
  count = 48; /* Benchmarks suggest this gives the best throughput. */
 
  if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) {
    reset_timeout = 1;
    user_timeout = timeout;
    timeout = 0;
  } else {
    reset_timeout = 0;
  }
 
  for (;; nevents = 0) {
    /* Only need to set the provider_entry_time if timeout != 0. The function
     * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME.
     */
    if (timeout != 0)
      uv__metrics_set_provider_entry_time(loop);
 
    if (timeout != -1) {
      spec.tv_sec = timeout / 1000;
      spec.tv_nsec = (timeout % 1000) * 1000000;
    }
 
    if (pset != NULL)
      pthread_sigmask(SIG_BLOCK, pset, NULL);
 
    nfds = kevent(loop->backend_fd,
                  events,
                  nevents,
                  events,
                  ARRAY_SIZE(events),
                  timeout == -1 ? NULL : &spec);
 
    if (pset != NULL)
      pthread_sigmask(SIG_UNBLOCK, pset, NULL);
 
    /* Update loop->time unconditionally. It's tempting to skip the update when
     * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the
     * operating system didn't reschedule our process while in the syscall.
     */
    SAVE_ERRNO(uv__update_time(loop));
 
    if (nfds == 0) {
      if (reset_timeout != 0) {
        timeout = user_timeout;
        reset_timeout = 0;
        if (timeout == -1)
          continue;
        if (timeout > 0)
          goto update_timeout;
      }
 
      assert(timeout != -1);
      return;
    }
 
    if (nfds == -1) {
      if (errno != EINTR)
        abort();
 
      if (reset_timeout != 0) {
        timeout = user_timeout;
        reset_timeout = 0;
      }
 
      if (timeout == 0)
        return;
 
      if (timeout == -1)
        continue;
 
      /* Interrupted by a signal. Update timeout and poll again. */
      goto update_timeout;
    }
 
    have_signals = 0;
    nevents = 0;
 
    assert(loop->watchers != NULL);
    loop->watchers[loop->nwatchers] = (void*) events;
    loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds;
    for (i = 0; i < nfds; i++) {
      ev = events + i;
      fd = ev->ident;
      /* Skip invalidated events, see uv__platform_invalidate_fd */
      if (fd == -1)
        continue;
      w = loop->watchers[fd];
 
      if (w == NULL) {
        /* File descriptor that we've stopped watching, disarm it.
         * TODO: batch up. */
        struct kevent events[1];
 
        EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
        if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
          if (errno != EBADF && errno != ENOENT)
            abort();
 
        continue;
      }
 
      if (ev->filter == EVFILT_VNODE) {
        assert(w->events == POLLIN);
        assert(w->pevents == POLLIN);
        uv__metrics_update_idle_time(loop);
        w->cb(loop, w, ev->fflags); /* XXX always uv__fs_event() */
        nevents++;
        continue;
      }
 
      revents = 0;
 
      if (ev->filter == EVFILT_READ) {
        if (w->pevents & POLLIN) {
          revents |= POLLIN;
          w->rcount = ev->data;
        } else {
          /* TODO batch up */
          struct kevent events[1];
          EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
          if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
            if (errno != ENOENT)
              abort();
        }
      }
 
      if (ev->filter == EV_OOBAND) {
        if (w->pevents & UV__POLLPRI) {
          revents |= UV__POLLPRI;
          w->rcount = ev->data;
        } else {
          /* TODO batch up */
          struct kevent events[1];
          EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
          if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
            if (errno != ENOENT)
              abort();
        }
      }
 
      if (ev->filter == EVFILT_WRITE) {
        if (w->pevents & POLLOUT) {
          revents |= POLLOUT;
          w->wcount = ev->data;
        } else {
          /* TODO batch up */
          struct kevent events[1];
          EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
          if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
            if (errno != ENOENT)
              abort();
        }
      }
 
      if (ev->flags & EV_ERROR)
        revents |= POLLERR;
 
      if ((ev->flags & EV_EOF) && (w->pevents & UV__POLLRDHUP))
        revents |= UV__POLLRDHUP;
 
      if (revents == 0)
        continue;
 
      /* Run signal watchers last.  This also affects child process watchers
       * because those are implemented in terms of signal watchers.
       */
      if (w == &loop->signal_io_watcher) {
        have_signals = 1;
      } else {
        uv__metrics_update_idle_time(loop);
        w->cb(loop, w, revents);
      }
 
      nevents++;
    }
 
    if (reset_timeout != 0) {
      timeout = user_timeout;
      reset_timeout = 0;
    }
 
    if (have_signals != 0) {
      uv__metrics_update_idle_time(loop);
      loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN);
    }
 
    loop->watchers[loop->nwatchers] = NULL;
    loop->watchers[loop->nwatchers + 1] = NULL;
 
    if (have_signals != 0)
      return;  /* Event loop should cycle now so don't poll again. */
 
    if (nevents != 0) {
      if (nfds == ARRAY_SIZE(events) && --count != 0) {
        /* Poll for more events but don't block this time. */
        timeout = 0;
        continue;
      }
      return;
    }
 
    if (timeout == 0)
      return;
 
    if (timeout == -1)
      continue;
 
update_timeout:
    assert(timeout > 0);
 
    diff = loop->time - base;
    if (diff >= (uint64_t) timeout)
      return;
 
    timeout -= diff;
  }
}

References ARRAY_SIZE, assert(), count, EBADF, EINTR, ENOENT, EV_OOBAND, fd, filter(), flags, i, loop, nfds, NULL, op, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INIT, QUEUE_REMOVE, SAVE_ERRNO, timeout, timespec::tv_nsec, timespec::tv_sec, uv__fs_event(), uv__get_internal_fields, uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), UV__POLLPRI, UV__POLLRDHUP, UV_LOOP_BLOCK_SIGPROF, UV_METRICS_IDLE_TIME, and w.

uv__kqueue_init()

int uv__kqueue_init

(

uv_loop_t *

loop

)

Definition at line 51 of file kqueue.c.

                                     {
  loop->backend_fd = kqueue();
  if (loop->backend_fd == -1)
    return UV__ERR(errno);
 
  uv__cloexec(loop->backend_fd, 1);
 
  return 0;
}

References loop, uv__cloexec, and UV__ERR.

Referenced by uv__io_fork(), and uv__platform_loop_init().

uv__platform_invalidate_fd()

void uv__platform_invalidate_fd	(	uv_loop_t *	loop,
		int	fd
	)

Definition at line 424 of file kqueue.c.

                                                         {
  struct kevent* events;
  uintptr_t i;
  uintptr_t nfds;
 
  assert(loop->watchers != NULL);
  assert(fd >= 0);
 
  events = (struct kevent*) loop->watchers[loop->nwatchers];
  nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1];
  if (events == NULL)
    return;
 
  /* Invalidate events with same file descriptor */
  for (i = 0; i < nfds; i++)
    if ((int) events[i].ident == fd)
      events[i].ident = -1;
}

References assert(), fd, i, loop, nfds, and NULL.

uv_fs_event_init()

int uv_fs_event_init	(	uv_loop_t *	loop,
		uv_fs_event_t *	handle
	)

Definition at line 486 of file kqueue.c.

                                                             {
  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
  return 0;
}

References handle, loop, and uv__handle_init.

uv_fs_event_start()

int uv_fs_event_start	(	uv_fs_event_t *	handle,
		uv_fs_event_cb	cb,
		const char *	path,
		unsigned int	flags
	)

Definition at line 492 of file kqueue.c.

                                          {
  int fd;
#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
  struct stat statbuf;
#endif
 
  if (uv__is_active(handle))
    return UV_EINVAL;
 
  handle->cb = cb;
  handle->path = uv__strdup(path);
  if (handle->path == NULL)
    return UV_ENOMEM;
 
  /* TODO open asynchronously - but how do we report back errors? */
  fd = open(handle->path, O_RDONLY);
  if (fd == -1) {
    uv__free(handle->path);
    handle->path = NULL;
    return UV__ERR(errno);
  }
 
#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
  /* Nullify field to perform checks later */
  handle->cf_cb = NULL;
  handle->realpath = NULL;
  handle->realpath_len = 0;
  handle->cf_flags = flags;
 
  if (fstat(fd, &statbuf))
    goto fallback;
  /* FSEvents works only with directories */
  if (!(statbuf.st_mode & S_IFDIR))
    goto fallback;
 
  if (0 == uv__load_relaxed(&uv__has_forked_with_cfrunloop)) {
    int r;
    /* The fallback fd is no longer needed */
    uv__close_nocheckstdio(fd);
    handle->event_watcher.fd = -1;
    r = uv__fsevents_init(handle);
    if (r == 0) {
      uv__handle_start(handle);
    } else {
      uv__free(handle->path);
      handle->path = NULL;
    }
    return r;
  }
fallback:
#endif /* #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 */
 
  uv__handle_start(handle);
  uv__io_init(&handle->event_watcher, uv__fs_event, fd);
  uv__io_start(handle->loop, &handle->event_watcher, POLLIN);
 
  return 0;
}

References cb, fd, flags, fstat, handle, NULL, O_RDONLY, path, r, uv__close_nocheckstdio(), UV__ERR, uv__free(), uv__fs_event(), uv__fsevents_init(), uv__handle_start, uv__io_init(), uv__io_start(), uv__is_active, uv__load_relaxed, and uv__strdup().

uv_fs_event_stop()

int uv_fs_event_stop

(

uv_fs_event_t *

handle

)

Definition at line 555 of file kqueue.c.

                                            {
  int r;
  r = 0;
 
  if (!uv__is_active(handle))
    return 0;
 
  uv__handle_stop(handle);
 
#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
  if (0 == uv__load_relaxed(&uv__has_forked_with_cfrunloop))
    if (handle->cf_cb != NULL)
      r = uv__fsevents_close(handle);
#endif
 
  if (handle->event_watcher.fd != -1) {
    uv__io_close(handle->loop, &handle->event_watcher);
    uv__close(handle->event_watcher.fd);
    handle->event_watcher.fd = -1;
  }
 
  uv__free(handle->path);
  handle->path = NULL;
 
  return r;
}

References handle, NULL, r, uv__close(), uv__free(), uv__fsevents_close(), uv__handle_stop, uv__io_close(), uv__is_active, and uv__load_relaxed.

Referenced by uv__fs_event_close().