Lines Matching defs:manager
333 isc__socketmgr_t *manager;
433 /* Locked by manager lock. */
493 static isc_boolean_t process_ctlfd(isc__socketmgr_t *manager);
508 isc__socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
589 isc__socket_fdwatchcreate(isc_socketmgr_t *manager, int fd, int flags,
901 watch_fd(isc__socketmgr_t *manager, int fd, int msg) {
914 if (kevent(manager->kqueue_fd, &evchange, 1, NULL, 0, NULL) != 0)
924 oldevents = manager->epoll_events[fd];
926 manager->epoll_events[fd] |= EPOLLIN;
928 manager->epoll_events[fd] |= EPOLLOUT;
930 event.events = manager->epoll_events[fd];
935 ret = epoll_ctl(manager->epoll_fd, op, fd, &event);
956 LOCK(&manager->fdlock[lockid]);
957 if (write(manager->devpoll_fd, &pfd, sizeof(pfd)) == -1)
961 manager->fdpollinfo[fd].want_read = 1;
963 manager->fdpollinfo[fd].want_write = 1;
965 UNLOCK(&manager->fdlock[lockid]);
969 LOCK(&manager->lock);
971 FD_SET(fd, manager->read_fds);
973 FD_SET(fd, manager->write_fds);
974 UNLOCK(&manager->lock);
981 unwatch_fd(isc__socketmgr_t *manager, int fd, int msg) {
994 if (kevent(manager->kqueue_fd, &evchange, 1, NULL, 0, NULL) != 0)
1004 manager->epoll_events[fd] &= ~(EPOLLIN);
1006 manager->epoll_events[fd] &= ~(EPOLLOUT);
1008 event.events = manager->epoll_events[fd];
1013 ret = epoll_ctl(manager->epoll_fd, op, fd, &event);
1036 LOCK(&manager->fdlock[lockid]);
1038 manager->fdpollinfo[fd].want_write == 1) {
1044 manager->fdpollinfo[fd].want_read == 1) {
1050 if (write(manager->devpoll_fd, pfds, writelen) == -1)
1054 manager->fdpollinfo[fd].want_read = 0;
1056 manager->fdpollinfo[fd].want_write = 0;
1058 UNLOCK(&manager->fdlock[lockid]);
1062 LOCK(&manager->lock);
1064 FD_CLR(fd, manager->read_fds);
1066 FD_CLR(fd, manager->write_fds);
1067 UNLOCK(&manager->lock);
1074 wakeup_socket(isc__socketmgr_t *manager, int fd, int msg) {
1084 INSIST(fd >= 0 && fd < (int)manager->maxsocks);
1088 INSIST(manager->fdstate[fd] == CLOSE_PENDING);
1089 manager->fdstate[fd] = CLOSED;
1090 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
1091 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
1096 LOCK(&manager->fdlock[lockid]);
1097 if (manager->fdstate[fd] == CLOSE_PENDING) {
1098 UNLOCK(&manager->fdlock[lockid]);
1108 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
1109 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
1112 if (manager->fdstate[fd] != MANAGED) {
1113 UNLOCK(&manager->fdlock[lockid]);
1116 UNLOCK(&manager->fdlock[lockid]);
1121 result = watch_fd(manager, fd, msg);
1211 select_poke(isc__socketmgr_t *manager, int fd, int msg) {
1215 wakeup_socket(manager, fd, msg);
1900 inc_stats(sock->manager->stats, \
1909 inc_stats(sock->manager->stats, \
1938 inc_stats(sock->manager->stats,
1977 if (sock->manager->maxudp != 0 && cc > sock->manager->maxudp)
2069 sock->manager->maxudp != 0 &&
2070 write_count > (size_t)sock->manager->maxudp)
2093 inc_stats(sock->manager->stats, \
2102 inc_stats(sock->manager->stats, \
2138 inc_stats(sock->manager->stats,
2144 inc_stats(sock->manager->stats,
2174 socketclose(isc__socketmgr_t *manager, isc__socket_t *sock, int fd) {
2182 LOCK(&manager->fdlock[lockid]);
2183 manager->fds[fd] = NULL;
2185 manager->fdstate[fd] = CLOSED;
2187 manager->fdstate[fd] = CLOSE_PENDING;
2188 UNLOCK(&manager->fdlock[lockid]);
2199 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
2200 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
2202 select_poke(manager, fd, SELECT_POKE_CLOSE);
2204 inc_stats(manager->stats, sock->statsindex[STATID_CLOSE]);
2206 dec_stats(manager->stats, sock->statsindex[STATID_ACTIVE]);
2211 * update manager->maxfd here (XXX: this should be implemented more
2215 LOCK(&manager->lock);
2216 if (manager->maxfd == fd) {
2219 manager->maxfd = 0;
2223 LOCK(&manager->fdlock[lockid]);
2224 if (manager->fdstate[i] == MANAGED) {
2225 manager->maxfd = i;
2226 UNLOCK(&manager->fdlock[lockid]);
2229 UNLOCK(&manager->fdlock[lockid]);
2232 if (manager->maxfd < manager->pipe_fds[0])
2233 manager->maxfd = manager->pipe_fds[0];
2237 UNLOCK(&manager->lock);
2245 isc__socketmgr_t *manager = sock->manager;
2254 INSIST(sock->fd >= -1 && sock->fd < (int)manager->maxsocks);
2259 socketclose(manager, sock, fd);
2262 LOCK(&manager->lock);
2264 ISC_LIST_UNLINK(manager->socklist, sock, link);
2267 if (ISC_LIST_EMPTY(manager->socklist))
2268 SIGNAL(&manager->shutdown_ok);
2271 /* can't unlock manager as its memory context is still used */
2274 UNLOCK(&manager->lock);
2278 allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type,
2285 sock = isc_mem_get(manager->mctx, sizeof(*sock));
2294 sock->manager = manager;
2322 sock->recvcmsgbuf = isc_mem_get(manager->mctx, cmsgbuflen);
2345 sock->sendcmsgbuf = isc_mem_get(manager->mctx, cmsgbuflen);
2399 isc_mem_put(manager->mctx, sock->recvcmsgbuf,
2402 isc_mem_put(manager->mctx, sock->sendcmsgbuf,
2404 isc_mem_put(manager->mctx, sock, sizeof(*sock));
2433 isc_mem_put(sock->manager->mctx, sock->recvcmsgbuf,
2436 isc_mem_put(sock->manager->mctx, sock->sendcmsgbuf,
2444 isc_mem_put(sock->manager->mctx, sock, sizeof(*sock));
2578 opensocket(isc__socketmgr_t *manager, isc__socket_t *sock,
2663 if (manager->reserved != 0 && sock->type == isc_sockettype_udp &&
2664 sock->fd >= 0 && sock->fd < manager->reserved) {
2666 newfd = fcntl(sock->fd, F_DUPFD, manager->reserved);
2683 if (sock->fd >= (int)manager->maxsocks) {
2690 sock->fd, manager->maxsocks);
2691 inc_stats(manager->stats, sock->statsindex[STATID_OPENFAIL]);
2707 inc_stats(manager->stats,
2719 inc_stats(manager->stats,
2732 inc_stats(manager->stats,
2744 inc_stats(manager->stats, sock->statsindex[STATID_OPENFAIL]);
2949 inc_stats(manager->stats, sock->statsindex[STATID_OPEN]);
2951 inc_stats(manager->stats, sock->statsindex[STATID_ACTIVE]);
2960 * by 'manager'. Events will be posted to 'task' and when dispatched
2969 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
2973 REQUIRE(VALID_MANAGER(manager));
2977 result = allocate_socket(manager, type, &sock);
3004 result = opensocket(manager, sock, (isc__socket_t *)dup_socket);
3020 LOCK(&manager->fdlock[lockid]);
3021 manager->fds[sock->fd] = sock;
3022 manager->fdstate[sock->fd] = MANAGED;
3024 manager->epoll_events[sock->fd] = 0;
3027 INSIST(sock->manager->fdpollinfo[sock->fd].want_read == 0 &&
3028 sock->manager->fdpollinfo[sock->fd].want_write == 0);
3030 UNLOCK(&manager->fdlock[lockid]);
3032 LOCK(&manager->lock);
3033 ISC_LIST_APPEND(manager->socklist, sock, link);
3035 if (manager->maxfd < sock->fd)
3036 manager->maxfd = sock->fd;
3038 UNLOCK(&manager->lock);
3047 * Create a new 'type' socket managed by 'manager'. Events
3070 return (socket_create((isc_socketmgr_t *) sock->manager,
3092 result = opensocket(sock->manager, sock, NULL);
3099 LOCK(&sock->manager->fdlock[lockid]);
3100 sock->manager->fds[sock->fd] = sock;
3101 sock->manager->fdstate[sock->fd] = MANAGED;
3103 sock->manager->epoll_events[sock->fd] = 0;
3106 INSIST(sock->manager->fdpollinfo[sock->fd].want_read == 0 &&
3107 sock->manager->fdpollinfo[sock->fd].want_write == 0);
3109 UNLOCK(&sock->manager->fdlock[lockid]);
3112 LOCK(&sock->manager->lock);
3113 if (sock->manager->maxfd < sock->fd)
3114 sock->manager->maxfd = sock->fd;
3115 UNLOCK(&sock->manager->lock);
3123 * Create a new 'type' socket managed by 'manager'. Events
3133 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
3138 REQUIRE(VALID_MANAGER(manager));
3141 if (fd < 0 || (unsigned int)fd >= manager->maxsocks)
3144 result = allocate_socket(manager, isc_sockettype_fdwatch, &sock);
3165 LOCK(&manager->fdlock[lockid]);
3166 manager->fds[sock->fd] = sock;
3167 manager->fdstate[sock->fd] = MANAGED;
3169 manager->epoll_events[sock->fd] = 0;
3171 UNLOCK(&manager->fdlock[lockid]);
3173 LOCK(&manager->lock);
3174 ISC_LIST_APPEND(manager->socklist, sock, link);
3176 if (manager->maxfd < sock->fd)
3177 manager->maxfd = sock->fd;
3179 UNLOCK(&manager->lock);
3182 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
3184 select_poke(sock->manager, sock->fd, SELECT_POKE_WRITE);
3193 * Indicate to the manager that it should watch the socket again.
3215 select_poke(sock->manager, sock->fd,
3219 select_poke(sock->manager, sock->fd,
3277 isc__socketmgr_t *manager;
3286 REQUIRE(sock->fd >= 0 && sock->fd < (int)sock->manager->maxsocks);
3297 manager = sock->manager;
3311 socketclose(manager, sock, fd);
3322 * The socket and manager must be locked before calling this function.
3404 * before the manager got the socket lock?
3527 isc__socketmgr_t *manager;
3546 manager = sock->manager;
3547 INSIST(VALID_MANAGER(manager));
3666 } else if (fd >= (int)manager->maxsocks) {
3673 fd, manager->maxsocks);
3693 select_poke(sock->manager, sock->fd, SELECT_POKE_ACCEPT);
3732 inc_stats(manager->stats,
3737 LOCK(&manager->fdlock[lockid]);
3738 manager->fds[fd] = NEWCONNSOCK(dev);
3739 manager->fdstate[fd] = MANAGED;
3741 manager->epoll_events[fd] = 0;
3743 UNLOCK(&manager->fdlock[lockid]);
3745 LOCK(&manager->lock);
3748 if (manager->maxfd < fd)
3749 manager->maxfd = fd;
3757 ISC_LIST_APPEND(manager->socklist, NEWCONNSOCK(dev), link);
3759 UNLOCK(&manager->lock);
3761 inc_stats(manager->stats, sock->statsindex[STATID_ACCEPT]);
3763 inc_stats(manager->stats, sock->statsindex[STATID_ACCEPTFAIL]);
3779 select_poke(sock->manager, sock->fd, SELECT_POKE_ACCEPT);
3782 inc_stats(manager->stats, sock->statsindex[STATID_ACCEPTFAIL]);
3846 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
3901 select_poke(sock->manager, sock->fd, SELECT_POKE_WRITE);
3942 select_poke(sock->manager, sock->fd, SELECT_POKE_WRITE);
3983 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
3993 process_fd(isc__socketmgr_t *manager, int fd, isc_boolean_t readable,
4004 LOCK(&manager->fdlock[lockid]);
4005 if (manager->fdstate[fd] == CLOSE_PENDING) {
4006 UNLOCK(&manager->fdlock[lockid]);
4008 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
4009 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
4013 sock = manager->fds[fd];
4052 UNLOCK(&manager->fdlock[lockid]);
4054 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
4056 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
4062 process_fds(isc__socketmgr_t *manager, struct kevent *events, int nevents) {
4070 if (nevents == manager->nevents) {
4076 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
4083 REQUIRE(events[i].ident < manager->maxsocks);
4085 if (events[i].ident == (uintptr_t)manager->pipe_fds[0]) {
4092 process_fd(manager, events[i].ident, readable, writable);
4097 done = process_ctlfd(manager);
4104 process_fds(isc__socketmgr_t *manager, struct epoll_event *events, int nevents)
4112 if (nevents == manager->nevents) {
4113 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
4120 REQUIRE(events[i].data.fd < (int)manager->maxsocks);
4122 if (events[i].data.fd == manager->pipe_fds[0]) {
4137 events[i].events |= manager->epoll_events[fd];
4139 process_fd(manager, events[i].data.fd,
4146 done = process_ctlfd(manager);
4153 process_fds(isc__socketmgr_t *manager, struct pollfd *events, int nevents) {
4160 if (nevents == manager->nevents) {
4161 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
4168 REQUIRE(events[i].fd < (int)manager->maxsocks);
4170 if (events[i].fd == manager->pipe_fds[0]) {
4175 process_fd(manager, events[i].fd,
4182 done = process_ctlfd(manager);
4189 process_fds(isc__socketmgr_t *manager, int maxfd, fd_set *readfds,
4194 REQUIRE(maxfd <= (int)manager->maxsocks);
4198 if (i == manager->pipe_fds[0] || i == manager->pipe_fds[1])
4201 process_fd(manager, i, FD_ISSET(i, readfds),
4209 process_ctlfd(isc__socketmgr_t *manager) {
4213 select_readmsg(manager, &fd, &msg);
4215 manager_log(manager, IOEVENT,
4242 wakeup_socket(manager, fd, msg);
4257 isc__socketmgr_t *manager = uap;
4283 ctlfd = manager->pipe_fds[0];
4289 cc = kevent(manager->kqueue_fd, NULL, 0,
4290 manager->events, manager->nevents, NULL);
4292 cc = epoll_wait(manager->epoll_fd, manager->events,
4293 manager->nevents, -1);
4298 if (manager->calls++ > 1000U) {
4301 &manager->open_max);
4303 manager->open_max = 64;
4304 manager->calls = 0;
4307 dvp.dp_fds = manager->events;
4308 dvp.dp_nfds = manager->nevents;
4309 if (dvp.dp_nfds >= manager->open_max)
4310 dvp.dp_nfds = manager->open_max - 1;
4320 cc = ioctl(manager->devpoll_fd, DP_POLL, &dvp);
4328 &manager->open_max);
4330 manager->open_max = 64;
4335 LOCK(&manager->lock);
4336 memmove(manager->read_fds_copy, manager->read_fds,
4337 manager->fd_bufsize);
4338 memmove(manager->write_fds_copy, manager->write_fds,
4339 manager->fd_bufsize);
4340 maxfd = manager->maxfd + 1;
4341 UNLOCK(&manager->lock);
4343 cc = select(maxfd, manager->read_fds_copy,
4344 manager->write_fds_copy, NULL, NULL);
4373 manager_log(manager,
4385 done = process_fds(manager, manager->events, cc);
4387 process_fds(manager, maxfd, manager->read_fds_copy,
4388 manager->write_fds_copy);
4393 if (FD_ISSET(ctlfd, manager->read_fds_copy))
4394 done = process_ctlfd(manager);
4398 manager_log(manager, TRACE, "%s",
4408 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
4410 REQUIRE(VALID_MANAGER(manager));
4412 manager->reserved = reserved;
4417 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
4419 REQUIRE(VALID_MANAGER(manager));
4421 manager->maxudp = maxudp;
4425 * Create a new socket manager.
4429 setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
4436 manager->nevents = ISC_SOCKET_MAXEVENTS;
4437 manager->events = isc_mem_get(mctx, sizeof(struct kevent) *
4438 manager->nevents);
4439 if (manager->events == NULL)
4441 manager->kqueue_fd = kqueue();
4442 if (manager->kqueue_fd == -1) {
4450 isc_mem_put(mctx, manager->events,
4451 sizeof(struct kevent) * manager->nevents);
4456 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4458 close(manager->kqueue_fd);
4459 isc_mem_put(mctx, manager->events,
4460 sizeof(struct kevent) * manager->nevents);
4465 manager->nevents = ISC_SOCKET_MAXEVENTS;
4466 manager->events = isc_mem_get(mctx, sizeof(struct epoll_event) *
4467 manager->nevents);
4468 if (manager->events == NULL)
4470 manager->epoll_fd = epoll_create(manager->nevents);
4471 if (manager->epoll_fd == -1) {
4479 isc_mem_put(mctx, manager->events,
4480 sizeof(struct epoll_event) * manager->nevents);
4484 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4486 close(manager->epoll_fd);
4487 isc_mem_put(mctx, manager->events,
4488 sizeof(struct epoll_event) * manager->nevents);
4493 manager->nevents = ISC_SOCKET_MAXEVENTS;
4495 &manager->open_max);
4497 manager->open_max = 64;
4498 manager->calls = 0;
4499 manager->events = isc_mem_get(mctx, sizeof(struct pollfd) *
4500 manager->nevents);
4501 if (manager->events == NULL)
4507 manager->fdpollinfo = isc_mem_get(mctx, sizeof(pollinfo_t) *
4508 manager->maxsocks);
4509 if (manager->fdpollinfo == NULL) {
4510 isc_mem_put(mctx, manager->events,
4511 sizeof(struct pollfd) * manager->nevents);
4514 memset(manager->fdpollinfo, 0, sizeof(pollinfo_t) * manager->maxsocks);
4515 manager->devpoll_fd = open("/dev/poll", O_RDWR);
4516 if (manager->devpoll_fd == -1) {
4524 isc_mem_put(mctx, manager->events,
4525 sizeof(struct pollfd) * manager->nevents);
4526 isc_mem_put(mctx, manager->fdpollinfo,
4527 sizeof(pollinfo_t) * manager->maxsocks);
4531 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4533 close(manager->devpoll_fd);
4534 isc_mem_put(mctx, manager->events,
4535 sizeof(struct pollfd) * manager->nevents);
4536 isc_mem_put(mctx, manager->fdpollinfo,
4537 sizeof(pollinfo_t) * manager->maxsocks);
4550 manager->fd_bufsize = howmany(manager->maxsocks, NFDBITS) *
4553 manager->fd_bufsize = sizeof(fd_set);
4556 manager->read_fds = NULL;
4557 manager->read_fds_copy = NULL;
4558 manager->write_fds = NULL;
4559 manager->write_fds_copy = NULL;
4561 manager->read_fds = isc_mem_get(mctx, manager->fd_bufsize);
4562 if (manager->read_fds != NULL)
4563 manager->read_fds_copy = isc_mem_get(mctx, manager->fd_bufsize);
4564 if (manager->read_fds_copy != NULL)
4565 manager->write_fds = isc_mem_get(mctx, manager->fd_bufsize);
4566 if (manager->write_fds != NULL) {
4567 manager->write_fds_copy = isc_mem_get(mctx,
4568 manager->fd_bufsize);
4570 if (manager->write_fds_copy == NULL) {
4571 if (manager->write_fds != NULL) {
4572 isc_mem_put(mctx, manager->write_fds,
4573 manager->fd_bufsize);
4575 if (manager->read_fds_copy != NULL) {
4576 isc_mem_put(mctx, manager->read_fds_copy,
4577 manager->fd_bufsize);
4579 if (manager->read_fds != NULL) {
4580 isc_mem_put(mctx, manager->read_fds,
4581 manager->fd_bufsize);
4585 memset(manager->read_fds, 0, manager->fd_bufsize);
4586 memset(manager->write_fds, 0, manager->fd_bufsize);
4589 (void)watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4590 manager->maxfd = manager->pipe_fds[0];
4592 manager->maxfd = 0;
4600 cleanup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
4604 result = unwatch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4614 close(manager->kqueue_fd);
4615 isc_mem_put(mctx, manager->events,
4616 sizeof(struct kevent) * manager->nevents);
4618 close(manager->epoll_fd);
4619 isc_mem_put(mctx, manager->events,
4620 sizeof(struct epoll_event) * manager->nevents);
4622 close(manager->devpoll_fd);
4623 isc_mem_put(mctx, manager->events,
4624 sizeof(struct pollfd) * manager->nevents);
4625 isc_mem_put(mctx, manager->fdpollinfo,
4626 sizeof(pollinfo_t) * manager->maxsocks);
4628 if (manager->read_fds != NULL)
4629 isc_mem_put(mctx, manager->read_fds, manager->fd_bufsize);
4630 if (manager->read_fds_copy != NULL)
4631 isc_mem_put(mctx, manager->read_fds_copy, manager->fd_bufsize);
4632 if (manager->write_fds != NULL)
4633 isc_mem_put(mctx, manager->write_fds, manager->fd_bufsize);
4634 if (manager->write_fds_copy != NULL)
4635 isc_mem_put(mctx, manager->write_fds_copy, manager->fd_bufsize);
4649 isc__socketmgr_t *manager;
4672 manager = isc_mem_get(mctx, sizeof(*manager));
4673 if (manager == NULL)
4677 memset(manager, 0, sizeof(*manager));
4678 manager->maxsocks = maxsocks;
4679 manager->reserved = 0;
4680 manager->maxudp = 0;
4681 manager->fds = isc_mem_get(mctx,
4682 manager->maxsocks * sizeof(isc__socket_t *));
4683 if (manager->fds == NULL) {
4687 manager->fdstate = isc_mem_get(mctx, manager->maxsocks * sizeof(int));
4688 if (manager->fdstate == NULL) {
4693 manager->epoll_events = isc_mem_get(mctx, (manager->maxsocks *
4695 if (manager->epoll_events == NULL) {
4699 memset(manager->epoll_events, 0, manager->maxsocks * sizeof(uint32_t));
4701 manager->stats = NULL;
4703 manager->common.methods = &socketmgrmethods;
4704 manager->common.magic = ISCAPI_SOCKETMGR_MAGIC;
4705 manager->common.impmagic = SOCKET_MANAGER_MAGIC;
4706 manager->mctx = NULL;
4707 memset(manager->fds, 0, manager->maxsocks * sizeof(isc_socket_t *));
4708 ISC_LIST_INIT(manager->socklist);
4709 result = isc_mutex_init(&manager->lock);
4712 manager->fdlock = isc_mem_get(mctx, FDLOCK_COUNT * sizeof(isc_mutex_t));
4713 if (manager->fdlock == NULL) {
4718 result = isc_mutex_init(&manager->fdlock[i]);
4721 DESTROYLOCK(&manager->fdlock[i]);
4722 isc_mem_put(mctx, manager->fdlock,
4724 manager->fdlock = NULL;
4730 if (isc_condition_init(&manager->shutdown_ok) != ISC_R_SUCCESS) {
4743 if (pipe(manager->pipe_fds) != 0) {
4754 RUNTIME_CHECK(make_nonblock(manager->pipe_fds[0]) == ISC_R_SUCCESS);
4756 RUNTIME_CHECK(make_nonblock(manager->pipe_fds[1]) == ISC_R_SUCCESS);
4761 manager->refs = 1;
4767 result = setup_watcher(mctx, manager);
4771 memset(manager->fdstate, 0, manager->maxsocks * sizeof(int));
4777 if (isc_thread_create(watcher, manager, &manager->watcher) !=
4783 cleanup_watcher(mctx, manager);
4787 isc_thread_setname(manager->watcher, "isc-socket");
4789 isc_mem_attach(mctx, &manager->mctx);
4792 socketmgr = manager;
4794 *managerp = (isc_socketmgr_t *)manager;
4800 (void)close(manager->pipe_fds[0]);
4801 (void)close(manager->pipe_fds[1]);
4806 (void)isc_condition_destroy(&manager->shutdown_ok);
4811 if (manager->fdlock != NULL) {
4813 DESTROYLOCK(&manager->fdlock[i]);
4815 DESTROYLOCK(&manager->lock);
4818 if (manager->fdlock != NULL) {
4819 isc_mem_put(mctx, manager->fdlock,
4823 if (manager->epoll_events != NULL) {
4824 isc_mem_put(mctx, manager->epoll_events,
4825 manager->maxsocks * sizeof(uint32_t));
4828 if (manager->fdstate != NULL) {
4829 isc_mem_put(mctx, manager->fdstate,
4830 manager->maxsocks * sizeof(int));
4832 if (manager->fds != NULL) {
4833 isc_mem_put(mctx, manager->fds,
4834 manager->maxsocks * sizeof(isc_socket_t *));
4836 isc_mem_put(mctx, manager, sizeof(*manager));
4843 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
4844 REQUIRE(VALID_MANAGER(manager));
4847 *nsockp = manager->maxsocks;
4854 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
4856 REQUIRE(VALID_MANAGER(manager));
4857 REQUIRE(ISC_LIST_EMPTY(manager->socklist));
4858 REQUIRE(manager->stats == NULL);
4861 isc_stats_attach(stats, &manager->stats);
4866 isc__socketmgr_t *manager;
4871 * Destroy a socket manager.
4875 manager = (isc__socketmgr_t *)*managerp;
4876 REQUIRE(VALID_MANAGER(manager));
4879 manager->refs--;
4880 if (manager->refs > 0) {
4887 LOCK(&manager->lock);
4892 while (!ISC_LIST_EMPTY(manager->socklist)) {
4894 manager_log(manager, CREATION, "%s",
4898 WAIT(&manager->shutdown_ok, &manager->lock);
4900 UNLOCK(&manager->lock);
4902 LOCK(&manager->lock);
4906 UNLOCK(&manager->lock);
4913 select_poke(manager, 0, SELECT_POKE_SHUTDOWN);
4919 if (isc_thread_join(manager->watcher, NULL) != ISC_R_SUCCESS)
4929 cleanup_watcher(manager->mctx, manager);
4932 (void)close(manager->pipe_fds[0]);
4933 (void)close(manager->pipe_fds[1]);
4934 (void)isc_condition_destroy(&manager->shutdown_ok);
4937 for (i = 0; i < (int)manager->maxsocks; i++)
4938 if (manager->fdstate[i] == CLOSE_PENDING) /* no need to lock */
4942 isc_mem_put(manager->mctx, manager->epoll_events,
4943 manager->maxsocks * sizeof(uint32_t));
4945 isc_mem_put(manager->mctx, manager->fds,
4946 manager->maxsocks * sizeof(isc__socket_t *));
4947 isc_mem_put(manager->mctx, manager->fdstate,
4948 manager->maxsocks * sizeof(int));
4950 if (manager->stats != NULL)
4951 isc_stats_detach(&manager->stats);
4953 if (manager->fdlock != NULL) {
4955 DESTROYLOCK(&manager->fdlock[i]);
4956 isc_mem_put(manager->mctx, manager->fdlock,
4959 DESTROYLOCK(&manager->lock);
4960 manager->common.magic = 0;
4961 manager->common.impmagic = 0;
4962 mctx= manager->mctx;
4963 isc_mem_put(mctx, manager, sizeof(*manager));
5018 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
5053 isc__socketmgr_t *manager;
5063 manager = sock->manager;
5064 REQUIRE(VALID_MANAGER(manager));
5071 dev = allocate_socketevent(manager->mctx, sock,
5108 isc__socketmgr_t *manager;
5113 manager = sock->manager;
5114 REQUIRE(VALID_MANAGER(manager));
5118 dev = allocate_socketevent(manager->mctx, sock,
5222 select_poke(sock->manager, sock->fd,
5268 isc__socketmgr_t *manager;
5275 manager = sock->manager;
5276 REQUIRE(VALID_MANAGER(manager));
5280 dev = allocate_socketevent(manager->mctx, sock,
5315 isc__socketmgr_t *manager;
5325 manager = sock->manager;
5326 REQUIRE(VALID_MANAGER(manager));
5331 dev = allocate_socketevent(manager->mctx, sock,
5598 inc_stats(sock->manager->stats,
5780 isc__socketmgr_t *manager;
5787 manager = sock->manager;
5788 REQUIRE(VALID_MANAGER(manager));
5800 isc_event_allocate(manager->mctx, task, ISC_SOCKEVENT_NEWCONN,
5808 result = allocate_socket(manager, sock->type, &nsock);
5843 select_poke(manager, sock->fd, SELECT_POKE_ACCEPT);
5856 isc__socketmgr_t *manager;
5866 manager = sock->manager;
5867 REQUIRE(VALID_MANAGER(manager));
5875 dev = (isc_socket_connev_t *)isc_event_allocate(manager->mctx, sock,
5946 inc_stats(sock->manager->stats,
5956 inc_stats(sock->manager->stats,
5973 inc_stats(sock->manager->stats,
5994 select_poke(manager, sock->fd, SELECT_POKE_CONNECT);
6068 select_poke(sock->manager, sock->fd,
6075 inc_stats(sock->manager->stats,
6108 inc_stats(sock->manager->stats,
6451 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
6468 if (manager == NULL)
6469 manager = socketmgr;
6471 if (manager == NULL)
6481 swait_private.nevents = kevent(manager->kqueue_fd, NULL, 0,
6482 manager->events, manager->nevents,
6490 swait_private.nevents = epoll_wait(manager->epoll_fd,
6491 manager->events,
6492 manager->nevents, timeout);
6498 if (manager->calls++ > 1000U) {
6500 &manager->open_max);
6502 manager->open_max = 64;
6503 manager->calls = 0;
6506 dvp.dp_fds = manager->events;
6507 dvp.dp_nfds = manager->nevents;
6508 if (dvp.dp_nfds >= manager->open_max)
6509 dvp.dp_nfds = manager->open_max - 1;
6515 n = ioctl(manager->devpoll_fd, DP_POLL, &dvp);
6523 &manager->open_max);
6525 manager->open_max = 64;
6531 memmove(manager->read_fds_copy, manager->read_fds, manager->fd_bufsize);
6532 memmove(manager->write_fds_copy, manager->write_fds,
6533 manager->fd_bufsize);
6535 swait_private.readset = manager->read_fds_copy;
6536 swait_private.writeset = manager->write_fds_copy;
6537 swait_private.maxfd = manager->maxfd + 1;
6549 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
6554 if (manager == NULL)
6555 manager = socketmgr;
6557 if (manager == NULL)
6561 (void)process_fds(manager, manager->events, swait->nevents);
6564 process_fds(manager, swait->maxfd, swait->readset, swait->writeset);