static struct ioloop_notify_handler_context *io_loop_notify_handler_init(void) { struct ioloop_notify_handler_context *ctx; ctx = current_ioloop->notify_handler_context = i_new(struct ioloop_notify_handler_context, 1); ctx->kq = kqueue(); if (ctx->kq < 0) i_fatal("kqueue(notify) failed: %m"); fd_close_on_exec(ctx->kq, TRUE); return ctx; }
int network_init() { memset(g_fds, 0, sizeof(network_socket*) * MAXCLIENTS); g_kqueue = kqueue(); if(g_kqueue == -1) { log_write(ERROR, "kqueue control fd could not be created. check your platform?"); return -1; } return 0; }
void kqueue_monitor::initialize_kqueue() { if (kq != -1) throw libfsw_exception(_("kqueue already running.")); kq = kqueue(); if (kq == -1) { perror("kqueue()"); throw libfsw_exception(_("kqueue failed.")); } }
ATF_TC_BODY(file, tc) { char buffer[128]; struct kevent event[1]; pid_t pid; int fd, kq, n, num, status; RL(pid = fork()); if (pid == 0) { child(); /* NOTREACHED */ } RL(fd = open(FILENAME, O_RDONLY|O_CREAT, 0644)); #if 1 /* XXX: why was this disabled? */ RL(lseek(fd, 0, SEEK_END)); #endif RL(kq = kqueue()); EV_SET(&event[0], fd, EVFILT_READ, EV_ADD|EV_ENABLE, 0, 0, 0); RL(kevent(kq, event, 1, NULL, 0, NULL)); for (num = 0; num < NLINES;) { RL(n = kevent(kq, NULL, 0, event, 1, NULL)); num += n; (void)printf("kevent num %d flags: %#x, fflags: %#x, data: " #ifdef __FreeBSD__ "%" PRIdPTR "\n", n, event[0].flags, event[0].fflags, #else "%" PRId64 "\n", n, event[0].flags, event[0].fflags, #endif event[0].data); if (event[0].data < 0) #if 1 /* XXXLUKEM */ RL(lseek(fd, 0, SEEK_END)); #else RL(lseek(fd, event[0].data, SEEK_END)); #endif RL(n = read(fd, buffer, 128)); buffer[n] = '\0'; (void)printf("file(%d): %s", num, buffer); } (void)waitpid(pid, &status, 0); (void)printf("read: successful end\n"); }
static tb_void_t tb_aiop_rtor_kqueue_cler(tb_aiop_rtor_impl_t* rtor) { tb_aiop_rtor_kqueue_impl_t* impl = (tb_aiop_rtor_kqueue_impl_t*)rtor; if (impl) { // close kqfd if (impl->kqfd >= 0) { close(impl->kqfd); impl->kqfd = kqueue(); } } }
/* * netio_init * * This is a needed exported function which will be called to initialise * the network loop code. */ void netio_init(void) { int fd; if ((fd = kqueue()) < 0) { ilog(LOG_TYPE_IRCD, "netio_init: couldn't open kqueue fd: %s", strerror(errno)); exit(EXIT_FAILURE); /* Whee! */ } fd_open(&kqfd, fd, 0, "kqueue() file descriptor"); }
static int fdevent_freebsd_kqueue_reset(fdevents * ev) { if (-1 == (ev->kq_fd = kqueue())) { fprintf(stderr, "%s.%d: kqueue failed (%s), try to set server.event-handler = \"poll\" or \"select\"\n", __FILE__, __LINE__, strerror(errno)); return -1; } return 0; }
void inline_size kqueue_fork (EV_P) { close (backend_fd); while ((backend_fd = kqueue ()) < 0) ev_syserr ("(libev) kqueue"); fcntl (backend_fd, F_SETFD, FD_CLOEXEC); /* re-register interest in fds */ fd_rearm_all (EV_A); }
/* * init_netio * * This is a needed exported function which will be called to initialise * the network loop code. */ void init_netio(void) { int fd; if ((fd = kqueue()) < 0) { ilog(LOG_TYPE_IRCD, "init_netio: Couldn't open kqueue fd!"); exit(115); /* Whee! */ } fd_open(&kqfd, fd, 0, "kqueue() file descriptor"); }
void test_kqueue(void *unused) { int kqfd; (void)unused; if ((kqfd = kqueue()) < 0) die("kqueue()"); test_no_kevents(kqfd); if (close(kqfd) < 0) die("close()"); }
KQueueEngine::KQueueEngine(InspIRCd* Instance) : SocketEngine(Instance) { EngineHandle = kqueue(); if (EngineHandle == -1) { ServerInstance->Log(SPARSE,"ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); ServerInstance->Log(SPARSE,"ERROR: this is a fatal error, exiting now."); printf("ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); printf("ERROR: this is a fatal error, exiting now."); InspIRCd::Exit(ERROR); } CurrentSetSize = 0; }
void test_evfilt_user() { kqfd = kqueue(); add_and_delete(); event_wait(); disable_and_enable(); oneshot(); /* TODO: try different fflags operations */ close(kqfd); }
/* * init_netio * * This is a needed exported function which will be called to initialise * the network loop code. */ void init_netio(void) { if ((kq = kqueue()) < 0) { ilog(L_CRIT, "init_netio: Couldn't open kqueue fd!"); exit(115); /* Whee! */ } kqmax = getdtablesize(); kqlst = MyMalloc(sizeof(struct kevent) * kqmax); zero_timespec.tv_sec = 0; zero_timespec.tv_nsec = 0; }
void sockinit(Handle f, void *x, int64 ns) { tick = f; tickval = x; ival = ns; ivalts.tv_sec = ns / 1000000000; ivalts.tv_nsec = ns % 1000000000; kq = kqueue(); if (kq == -1) { twarn("kqueue"); exit(1); } }
void wz_work() { time_t last_clean_time = time(0); kQueue = kqueue(); if (kQueue == -1) { log_error("Error creating kqueue: %s", strerror(errno)); throw std::logic_error("error creating kqueue"); } while (!doQuit && !doRestart) { struct timespec timeout = {5, 0}; int r; r = kevent(kQueue, kChanges, nChanges, kChanges, aChanges, &timeout); nChanges = 0; if (r > 0) { struct kevent* ke = kChanges; int i; for (i = 0; i < r; i++, ke++) { if (ke->flags & EV_EOF) { watchEvent(ke->ident, EVFILT_READ, EV_DELETE, 0, 0); close(ke->ident); continue; } handle_event(ke->ident); } } else { if (r < 0 && errno != EINTR && errno != EAGAIN) { log_error("Strange error %s, %d", strerror(errno), errno); } } if (time(0) - last_clean_time > 5) { last_clean_time = clean_talkers(); plugins.idle(); } } }
int Observer::initObserver() { int localFD = nodeNet->getNodeDescriptor(); this->obsQueue = kqueue(); EV_SET(&this->nodeEventSets, localFD, EVFILT_READ, EV_ADD, 0, 0, NULL); if (kevent(this->obsQueue, &this->nodeEventSets, 1, NULL, 0, NULL) < 0) { // error return FAILURE; } return SUCCESS; }
_inline int InitSocketMultiplexing() { int smfd; #if defined(_USE_KQUEUE) smfd = kqueue(); #elif defined(_USE_EPOLL) smfd = epoll_create(NUM_CONNS_PER_POOL); #elif defined(_USE_DEVPOLL) smfd = open("/dev/poll", O_RDWR)); if (smfd < 0) return -1; #endif return smfd; }
void _modinit(module_t *m) { int kq; kq = kqueue(); if (kq == -1) { m->mflags = MODTYPE_FAIL; return; } kq_conn = connection_add("procwatch kqueue", kq, 0, procwatch_readhandler, NULL); service_named_bind_command("operserv", &os_procwatch); }
int kqueue_init(mspool *nsp) { struct kqueue_engine_info *kinfo; kinfo = (struct kqueue_engine_info *)safe_malloc(sizeof(struct kqueue_engine_info)); kinfo->kqfd = kqueue(); kinfo->maxfd = -1; kinfo->evlen = INITIAL_EV_COUNT; kinfo->events = (struct kevent *)safe_malloc(INITIAL_EV_COUNT * sizeof(struct kevent)); nsp->engine_data = (void *)kinfo; return 1; }
int kill_and_wait_sigchild(pid_t child_pid, int signal, uint32_t timeout_seconds) { if (kill(child_pid, signal) == -1) { ERRMSG("kill() failed"); return -1; } int kq; if ((kq = kqueue()) == -1) { ERRMSG("kqueue() failed"); return -1; } if (poll_add(kq, SIGCHLD, EVFILT_SIGNAL) == -1) { ERRMSG("poll_add() failed"); close(kq); return -1; } struct timespec timeout; timeout.tv_sec = timeout_seconds; timeout.tv_nsec = 0; if (kevent(kq, NULL, 0, NULL, 0, &timeout) == -1) { ERRMSG("kevent() failed"); close(kq); return -1; } close(kq); return 0; }
void kore_platform_event_init(void) { if ((kfd = kqueue()) == -1) fatal("kqueue(): %s", errno_s); nchanges = 0; event_count = worker_max_connections + 1; events = kore_calloc(event_count, sizeof(struct kevent)); changelist = kore_calloc(event_count, sizeof(struct kevent)); kore_platform_event_schedule(server.fd, EVFILT_READ, EV_ADD | EV_DISABLE, &server); }
int event_kqueue_reload(struct _fdevent *ev) { int nfd; if ((nfd = dup(ev->kq_fd)) != -1) { close(nfd); close(ev->kq_fd); } if ((ev->kq_fd = kqueue()) == -1) { return 0; } return 1; }
static int iv_fd_kqueue_init(struct iv_state *st) { int kqueue_fd; kqueue_fd = kqueue(); if (kqueue_fd < 0) return -1; iv_fd_set_cloexec(kqueue_fd); st->u.kqueue.kqueue_fd = kqueue_fd; INIT_IV_LIST_HEAD(&st->u.kqueue.notify); return 0; }
BSDDirectoryWatcherStrategy(DirectoryWatcher& owner): DirectoryWatcherStrategy(owner), _queueFD(-1), _dirFD(-1), _stopped(false) { _dirFD = open(owner.directory().path().c_str(), O_EVTONLY); if (_dirFD < 0) throw Poco::FileNotFoundException(owner.directory().path()); _queueFD = kqueue(); if (_queueFD < 0) { close(_dirFD); throw Poco::SystemException("Cannot create kqueue", errno); } }
static gpointer tp_kqueue_init (SocketIOData *data) { tp_kqueue_data *result; result = g_new0 (tp_kqueue_data, 1); result->fd = kqueue (); if (result->fd == -1) return NULL; data->shutdown = tp_kqueue_shutdown; data->modify = tp_kqueue_modify; data->wait = tp_kqueue_wait; return result; }
KeyHashtableTimeout::KeyHashtableTimeout(HashTable *_keyHashtable, int _timeout) { if (! _keyHashtable) { systemLog->sysLog(CRITICAL, "keyHashtable is NULL, something is terribly wrong"); return; } kQueue = kqueue(); if (kQueue < 0) { systemLog->sysLog(CRITICAL, "cannot initialize kQueue for KeyHashtableTimeout object: %s", strerror(errno)); return; } timeout = _timeout; keyHashtable = _keyHashtable; return; }
ATF_TC_BODY(pipe1, tc) { struct kevent event[1]; int fds[2]; int kq, n; RL(pipe(fds)); RL(kq = kqueue()); RL(close(fds[0])); EV_SET(&event[0], fds[1], EVFILT_WRITE, EV_ADD|EV_ENABLE, 0, 0, 0); ATF_REQUIRE_EQ_MSG((n = kevent(kq, event, 1, NULL, 0, NULL)), -1, "got: %d", n); ATF_REQUIRE_EQ_MSG(errno, EBADF, "got: %s", strerror(errno)); }
grn_rc grn_com_event_init(grn_ctx *ctx, grn_com_event *ev, int max_nevents, int data_size) { ev->max_nevents = max_nevents; if ((ev->hash = grn_hash_create(ctx, NULL, sizeof(grn_sock), data_size, 0))) { MUTEX_INIT(ev->mutex); COND_INIT(ev->cond); GRN_COM_QUEUE_INIT(&ev->recv_old); ev->msg_handler = NULL; memset(&(ev->curr_edge_id), 0, sizeof(grn_com_addr)); ev->acceptor = NULL; ev->opaque = NULL; #ifndef USE_SELECT # ifdef USE_EPOLL if ((ev->events = GRN_MALLOC(sizeof(struct epoll_event) * max_nevents))) { if ((ev->epfd = epoll_create(max_nevents)) != -1) { goto exit; } else { SERR("epoll_create"); } GRN_FREE(ev->events); } # else /* USE_EPOLL */ # ifdef USE_KQUEUE if ((ev->events = GRN_MALLOC(sizeof(struct kevent) * max_nevents))) { if ((ev->kqfd = kqueue()) != -1) { goto exit; } else { SERR("kqueue"); } GRN_FREE(ev->events); } # else /* USE_KQUEUE */ if ((ev->events = GRN_MALLOC(sizeof(struct pollfd) * max_nevents))) { goto exit; } # endif /* USE_KQUEUE*/ # endif /* USE_EPOLL */ grn_hash_close(ctx, ev->hash); ev->hash = NULL; ev->events = NULL; #else /* USE_SELECT */ goto exit; #endif /* USE_SELECT */ } exit : return ctx->rc; }
/* setup buffers for kqueue */ void ir_kqueue_init(void) { ir_kqueue_change_size = 0; ir_kqueue_event_max = 64; FD_ZERO(&ir_kqueue_readset); FD_ZERO(&ir_kqueue_writeset); ir_kqueue_fd = kqueue (); if (ir_kqueue_fd < 0) { fprintf(stderr, "Failed to start kqueue()\n"); ir_kqueue_fd = FD_UNUSED; } else { fcntl(ir_kqueue_fd, F_SETFD, FD_CLOEXEC); ir_kqueue_set_buffer(); } }
QT_BEGIN_NAMESPACE // #define KEVENT_DEBUG #ifdef KEVENT_DEBUG # define DEBUG qDebug #else # define DEBUG if(false)qDebug #endif QKqueueFileSystemWatcherEngine *QKqueueFileSystemWatcherEngine::create() { int kqfd = kqueue(); if (kqfd == -1) return 0; return new QKqueueFileSystemWatcherEngine(kqfd); }