Lines Matching refs:manager
303 isc__socketmgr_t *manager;
395 /* Locked by manager lock. */
454 static isc_boolean_t process_ctlfd(isc__socketmgr_t *manager);
468 isc__socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
549 isc__socket_fdwatchcreate(isc_socketmgr_t *manager, int fd, int flags,
805 watch_fd(isc__socketmgr_t *manager, int fd, int msg) {
818 if (kevent(manager->kqueue_fd, &evchange, 1, NULL, 0, NULL) != 0)
831 if (epoll_ctl(manager->epoll_fd, EPOLL_CTL_ADD, fd, &event) == -1 &&
848 LOCK(&manager->fdlock[lockid]);
849 if (write(manager->devpoll_fd, &pfd, sizeof(pfd)) == -1)
853 manager->fdpollinfo[fd].want_read = 1;
855 manager->fdpollinfo[fd].want_write = 1;
857 UNLOCK(&manager->fdlock[lockid]);
861 LOCK(&manager->lock);
863 FD_SET(fd, manager->read_fds);
865 FD_SET(fd, manager->write_fds);
866 UNLOCK(&manager->lock);
873 unwatch_fd(isc__socketmgr_t *manager, int fd, int msg) {
886 if (kevent(manager->kqueue_fd, &evchange, 1, NULL, 0, NULL) != 0)
899 if (epoll_ctl(manager->epoll_fd, EPOLL_CTL_DEL, fd, &event) == -1 &&
922 LOCK(&manager->fdlock[lockid]);
924 manager->fdpollinfo[fd].want_write == 1) {
930 manager->fdpollinfo[fd].want_read == 1) {
936 if (write(manager->devpoll_fd, pfds, writelen) == -1)
940 manager->fdpollinfo[fd].want_read = 0;
942 manager->fdpollinfo[fd].want_write = 0;
944 UNLOCK(&manager->fdlock[lockid]);
948 LOCK(&manager->lock);
950 FD_CLR(fd, manager->read_fds);
952 FD_CLR(fd, manager->write_fds);
953 UNLOCK(&manager->lock);
960 wakeup_socket(isc__socketmgr_t *manager, int fd, int msg) {
970 INSIST(fd >= 0 && fd < (int)manager->maxsocks);
974 INSIST(manager->fdstate[fd] == CLOSE_PENDING);
975 manager->fdstate[fd] = CLOSED;
976 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
977 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
982 LOCK(&manager->fdlock[lockid]);
983 if (manager->fdstate[fd] == CLOSE_PENDING) {
984 UNLOCK(&manager->fdlock[lockid]);
994 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
995 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
998 if (manager->fdstate[fd] != MANAGED) {
999 UNLOCK(&manager->fdlock[lockid]);
1002 UNLOCK(&manager->fdlock[lockid]);
1007 result = watch_fd(manager, fd, msg);
1099 select_poke(isc__socketmgr_t *manager, int fd, int msg) {
1103 wakeup_socket(manager, fd, msg);
1590 ev = (isc_socketevent_t *)isc_event_allocate(sock->manager->mctx,
1678 inc_stats(sock->manager->stats, \
1687 inc_stats(sock->manager->stats, \
1712 inc_stats(sock->manager->stats,
1750 if (sock->manager->maxudp != 0 && cc > sock->manager->maxudp)
1859 inc_stats(sock->manager->stats, \
1868 inc_stats(sock->manager->stats, \
1904 inc_stats(sock->manager->stats,
1910 inc_stats(sock->manager->stats,
1940 closesocket(isc__socketmgr_t *manager, isc__socket_t *sock, int fd) {
1948 LOCK(&manager->fdlock[lockid]);
1949 manager->fds[fd] = NULL;
1951 manager->fdstate[fd] = CLOSED;
1953 manager->fdstate[fd] = CLOSE_PENDING;
1954 UNLOCK(&manager->fdlock[lockid]);
1965 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
1966 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
1968 select_poke(manager, fd, SELECT_POKE_CLOSE);
1970 inc_stats(manager->stats, sock->statsindex[STATID_CLOSE]);
1973 * update manager->maxfd here (XXX: this should be implemented more
1977 LOCK(&manager->lock);
1978 if (manager->maxfd == fd) {
1981 manager->maxfd = 0;
1985 LOCK(&manager->fdlock[lockid]);
1986 if (manager->fdstate[i] == MANAGED) {
1987 manager->maxfd = i;
1988 UNLOCK(&manager->fdlock[lockid]);
1991 UNLOCK(&manager->fdlock[lockid]);
1994 if (manager->maxfd < manager->pipe_fds[0])
1995 manager->maxfd = manager->pipe_fds[0];
1998 UNLOCK(&manager->lock);
2006 isc__socketmgr_t *manager = sock->manager;
2015 REQUIRE(sock->fd == -1 || sock->fd < (int)manager->maxsocks);
2020 closesocket(manager, sock, fd);
2023 LOCK(&manager->lock);
2025 ISC_LIST_UNLINK(manager->socklist, sock, link);
2028 if (ISC_LIST_EMPTY(manager->socklist))
2029 SIGNAL(&manager->shutdown_ok);
2032 /* can't unlock manager as its memory context is still used */
2035 UNLOCK(&manager->lock);
2039 allocate_socket(isc__socketmgr_t *manager, isc_sockettype_t type,
2046 sock = isc_mem_get(manager->mctx, sizeof(*sock));
2055 sock->manager = manager;
2078 sock->recvcmsgbuf = isc_mem_get(manager->mctx, cmsgbuflen);
2098 sock->sendcmsgbuf = isc_mem_get(manager->mctx, cmsgbuflen);
2151 isc_mem_put(manager->mctx, sock->recvcmsgbuf,
2154 isc_mem_put(manager->mctx, sock->sendcmsgbuf,
2156 isc_mem_put(manager->mctx, sock, sizeof(*sock));
2184 isc_mem_put(sock->manager->mctx, sock->recvcmsgbuf,
2187 isc_mem_put(sock->manager->mctx, sock->sendcmsgbuf,
2195 isc_mem_put(sock->manager->mctx, sock, sizeof(*sock));
2239 opensocket(isc__socketmgr_t *manager, isc__socket_t *sock,
2286 if (manager->reserved != 0 && sock->type == isc_sockettype_udp &&
2287 sock->fd >= 0 && sock->fd < manager->reserved) {
2289 new = fcntl(sock->fd, F_DUPFD, manager->reserved);
2306 if (sock->fd >= (int)manager->maxsocks) {
2313 sock->fd, manager->maxsocks);
2543 inc_stats(manager->stats, sock->statsindex[STATID_OPEN]);
2550 * by 'manager'. Events will be posted to 'task' and when dispatched
2559 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
2563 REQUIRE(VALID_MANAGER(manager));
2567 result = allocate_socket(manager, type, &sock);
2589 result = opensocket(manager, sock, (isc__socket_t *)dup_socket);
2591 inc_stats(manager->stats, sock->statsindex[STATID_OPENFAIL]);
2606 LOCK(&manager->fdlock[lockid]);
2607 manager->fds[sock->fd] = sock;
2608 manager->fdstate[sock->fd] = MANAGED;
2610 INSIST(sock->manager->fdpollinfo[sock->fd].want_read == 0 &&
2611 sock->manager->fdpollinfo[sock->fd].want_write == 0);
2613 UNLOCK(&manager->fdlock[lockid]);
2615 LOCK(&manager->lock);
2616 ISC_LIST_APPEND(manager->socklist, sock, link);
2618 if (manager->maxfd < sock->fd)
2619 manager->maxfd = sock->fd;
2621 UNLOCK(&manager->lock);
2630 * Create a new 'type' socket managed by 'manager'. Events
2653 return (socket_create((isc_socketmgr_t *) sock->manager,
2676 result = opensocket(sock->manager, sock, NULL);
2683 LOCK(&sock->manager->fdlock[lockid]);
2684 sock->manager->fds[sock->fd] = sock;
2685 sock->manager->fdstate[sock->fd] = MANAGED;
2687 INSIST(sock->manager->fdpollinfo[sock->fd].want_read == 0 &&
2688 sock->manager->fdpollinfo[sock->fd].want_write == 0);
2690 UNLOCK(&sock->manager->fdlock[lockid]);
2693 LOCK(&sock->manager->lock);
2694 if (sock->manager->maxfd < sock->fd)
2695 sock->manager->maxfd = sock->fd;
2696 UNLOCK(&sock->manager->lock);
2705 * Create a new 'type' socket managed by 'manager'. Events
2715 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
2720 REQUIRE(VALID_MANAGER(manager));
2723 result = allocate_socket(manager, isc_sockettype_fdwatch, &sock);
2744 LOCK(&manager->fdlock[lockid]);
2745 manager->fds[sock->fd] = sock;
2746 manager->fdstate[sock->fd] = MANAGED;
2747 UNLOCK(&manager->fdlock[lockid]);
2749 LOCK(&manager->lock);
2750 ISC_LIST_APPEND(manager->socklist, sock, link);
2752 if (manager->maxfd < sock->fd)
2753 manager->maxfd = sock->fd;
2755 UNLOCK(&manager->lock);
2758 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
2760 select_poke(sock->manager, sock->fd, SELECT_POKE_WRITE);
2769 * Indicate to the manager that it should watch the socket again.
2791 select_poke(sock->manager, sock->fd,
2795 select_poke(sock->manager, sock->fd,
2854 isc__socketmgr_t *manager;
2863 REQUIRE(sock->fd >= 0 && sock->fd < (int)sock->manager->maxsocks);
2874 manager = sock->manager;
2888 closesocket(manager, sock, fd);
2900 * The socket and manager must be locked before calling this function.
2982 * before the manager got the socket lock?
3085 isc__socketmgr_t *manager;
3104 manager = sock->manager;
3105 INSIST(VALID_MANAGER(manager));
3224 } else if (fd >= (int)manager->maxsocks) {
3231 fd, manager->maxsocks);
3251 select_poke(sock->manager, sock->fd, SELECT_POKE_ACCEPT);
3269 LOCK(&manager->fdlock[lockid]);
3270 manager->fds[fd] = NEWCONNSOCK(dev);
3271 manager->fdstate[fd] = MANAGED;
3272 UNLOCK(&manager->fdlock[lockid]);
3274 LOCK(&manager->lock);
3275 ISC_LIST_APPEND(manager->socklist, NEWCONNSOCK(dev), link);
3287 if (manager->maxfd < fd)
3288 manager->maxfd = fd;
3296 UNLOCK(&manager->lock);
3298 inc_stats(manager->stats, sock->statsindex[STATID_ACCEPT]);
3300 inc_stats(manager->stats, sock->statsindex[STATID_ACCEPTFAIL]);
3316 select_poke(sock->manager, sock->fd, SELECT_POKE_ACCEPT);
3319 inc_stats(manager->stats, sock->statsindex[STATID_ACCEPTFAIL]);
3383 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
3438 select_poke(sock->manager, sock->fd, SELECT_POKE_WRITE);
3479 select_poke(sock->manager, sock->fd, SELECT_POKE_WRITE);
3520 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
3530 process_fd(isc__socketmgr_t *manager, int fd, isc_boolean_t readable,
3541 LOCK(&manager->fdlock[lockid]);
3542 if (manager->fdstate[fd] == CLOSE_PENDING) {
3543 UNLOCK(&manager->fdlock[lockid]);
3545 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
3546 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
3550 sock = manager->fds[fd];
3589 UNLOCK(&manager->fdlock[lockid]);
3591 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
3593 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
3599 process_fds(isc__socketmgr_t *manager, struct kevent *events, int nevents) {
3607 if (nevents == manager->nevents) {
3613 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
3620 REQUIRE(events[i].ident < manager->maxsocks);
3622 if (events[i].ident == (uintptr_t)manager->pipe_fds[0]) {
3629 process_fd(manager, events[i].ident, readable, writable);
3634 done = process_ctlfd(manager);
3641 process_fds(isc__socketmgr_t *manager, struct epoll_event *events, int nevents)
3649 if (nevents == manager->nevents) {
3650 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
3657 REQUIRE(events[i].data.fd < (int)manager->maxsocks);
3659 if (events[i].data.fd == manager->pipe_fds[0]) {
3675 process_fd(manager, events[i].data.fd,
3682 done = process_ctlfd(manager);
3689 process_fds(isc__socketmgr_t *manager, struct pollfd *events, int nevents) {
3696 if (nevents == manager->nevents) {
3697 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
3704 REQUIRE(events[i].fd < (int)manager->maxsocks);
3706 if (events[i].fd == manager->pipe_fds[0]) {
3711 process_fd(manager, events[i].fd,
3718 done = process_ctlfd(manager);
3725 process_fds(isc__socketmgr_t *manager, int maxfd, fd_set *readfds,
3730 REQUIRE(maxfd <= (int)manager->maxsocks);
3734 if (i == manager->pipe_fds[0] || i == manager->pipe_fds[1])
3737 process_fd(manager, i, FD_ISSET(i, readfds),
3745 process_ctlfd(isc__socketmgr_t *manager) {
3749 select_readmsg(manager, &fd, &msg);
3751 manager_log(manager, IOEVENT,
3778 wakeup_socket(manager, fd, msg);
3793 isc__socketmgr_t *manager = uap;
3817 ctlfd = manager->pipe_fds[0];
3823 cc = kevent(manager->kqueue_fd, NULL, 0,
3824 manager->events, manager->nevents, NULL);
3826 cc = epoll_wait(manager->epoll_fd, manager->events,
3827 manager->nevents, -1);
3829 dvp.dp_fds = manager->events;
3830 dvp.dp_nfds = manager->nevents;
3839 cc = ioctl(manager->devpoll_fd, DP_POLL, &dvp);
3841 LOCK(&manager->lock);
3842 memcpy(manager->read_fds_copy, manager->read_fds,
3843 manager->fd_bufsize);
3844 memcpy(manager->write_fds_copy, manager->write_fds,
3845 manager->fd_bufsize);
3846 maxfd = manager->maxfd + 1;
3847 UNLOCK(&manager->lock);
3849 cc = select(maxfd, manager->read_fds_copy,
3850 manager->write_fds_copy, NULL, NULL);
3879 manager_log(manager,
3891 done = process_fds(manager, manager->events, cc);
3893 process_fds(manager, maxfd, manager->read_fds_copy,
3894 manager->write_fds_copy);
3899 if (FD_ISSET(ctlfd, manager->read_fds_copy))
3900 done = process_ctlfd(manager);
3904 manager_log(manager, TRACE, "%s",
3915 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
3917 REQUIRE(VALID_MANAGER(manager));
3919 manager->reserved = reserved;
3924 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
3926 REQUIRE(VALID_MANAGER(manager));
3928 manager->maxudp = maxudp;
3933 * Create a new socket manager.
3937 setup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
3944 manager->nevents = ISC_SOCKET_MAXEVENTS;
3945 manager->events = isc_mem_get(mctx, sizeof(struct kevent) *
3946 manager->nevents);
3947 if (manager->events == NULL)
3949 manager->kqueue_fd = kqueue();
3950 if (manager->kqueue_fd == -1) {
3958 isc_mem_put(mctx, manager->events,
3959 sizeof(struct kevent) * manager->nevents);
3964 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
3966 close(manager->kqueue_fd);
3967 isc_mem_put(mctx, manager->events,
3968 sizeof(struct kevent) * manager->nevents);
3973 manager->nevents = ISC_SOCKET_MAXEVENTS;
3974 manager->events = isc_mem_get(mctx, sizeof(struct epoll_event) *
3975 manager->nevents);
3976 if (manager->events == NULL)
3978 manager->epoll_fd = epoll_create(manager->nevents);
3979 if (manager->epoll_fd == -1) {
3987 isc_mem_put(mctx, manager->events,
3988 sizeof(struct epoll_event) * manager->nevents);
3992 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
3994 close(manager->epoll_fd);
3995 isc_mem_put(mctx, manager->events,
3996 sizeof(struct epoll_event) * manager->nevents);
4005 manager->nevents = ISC_SOCKET_MAXEVENTS;
4006 manager->events = isc_mem_get(mctx, sizeof(struct pollfd) *
4007 manager->nevents);
4008 if (manager->events == NULL)
4014 manager->fdpollinfo = isc_mem_get(mctx, sizeof(pollinfo_t) *
4015 manager->maxsocks);
4016 if (manager->fdpollinfo == NULL) {
4017 isc_mem_put(mctx, manager->events,
4018 sizeof(struct pollfd) * manager->nevents);
4021 memset(manager->fdpollinfo, 0, sizeof(pollinfo_t) * manager->maxsocks);
4022 manager->devpoll_fd = open("/dev/poll", O_RDWR);
4023 if (manager->devpoll_fd == -1) {
4031 isc_mem_put(mctx, manager->events,
4032 sizeof(struct pollfd) * manager->nevents);
4033 isc_mem_put(mctx, manager->fdpollinfo,
4034 sizeof(pollinfo_t) * manager->maxsocks);
4038 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4040 close(manager->devpoll_fd);
4041 isc_mem_put(mctx, manager->events,
4042 sizeof(struct pollfd) * manager->nevents);
4043 isc_mem_put(mctx, manager->fdpollinfo,
4044 sizeof(pollinfo_t) * manager->maxsocks);
4057 manager->fd_bufsize = howmany(manager->maxsocks, NFDBITS) *
4060 manager->fd_bufsize = sizeof(fd_set);
4063 manager->read_fds = NULL;
4064 manager->read_fds_copy = NULL;
4065 manager->write_fds = NULL;
4066 manager->write_fds_copy = NULL;
4068 manager->read_fds = isc_mem_get(mctx, manager->fd_bufsize);
4069 if (manager->read_fds != NULL)
4070 manager->read_fds_copy = isc_mem_get(mctx, manager->fd_bufsize);
4071 if (manager->read_fds_copy != NULL)
4072 manager->write_fds = isc_mem_get(mctx, manager->fd_bufsize);
4073 if (manager->write_fds != NULL) {
4074 manager->write_fds_copy = isc_mem_get(mctx,
4075 manager->fd_bufsize);
4077 if (manager->write_fds_copy == NULL) {
4078 if (manager->write_fds != NULL) {
4079 isc_mem_put(mctx, manager->write_fds,
4080 manager->fd_bufsize);
4082 if (manager->read_fds_copy != NULL) {
4083 isc_mem_put(mctx, manager->read_fds_copy,
4084 manager->fd_bufsize);
4086 if (manager->read_fds != NULL) {
4087 isc_mem_put(mctx, manager->read_fds,
4088 manager->fd_bufsize);
4092 memset(manager->read_fds, 0, manager->fd_bufsize);
4093 memset(manager->write_fds, 0, manager->fd_bufsize);
4096 (void)watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4097 manager->maxfd = manager->pipe_fds[0];
4099 manager->maxfd = 0;
4107 cleanup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
4111 result = unwatch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
4121 close(manager->kqueue_fd);
4122 isc_mem_put(mctx, manager->events,
4123 sizeof(struct kevent) * manager->nevents);
4125 close(manager->epoll_fd);
4126 isc_mem_put(mctx, manager->events,
4127 sizeof(struct epoll_event) * manager->nevents);
4129 close(manager->devpoll_fd);
4130 isc_mem_put(mctx, manager->events,
4131 sizeof(struct pollfd) * manager->nevents);
4132 isc_mem_put(mctx, manager->fdpollinfo,
4133 sizeof(pollinfo_t) * manager->maxsocks);
4135 if (manager->read_fds != NULL)
4136 isc_mem_put(mctx, manager->read_fds, manager->fd_bufsize);
4137 if (manager->read_fds_copy != NULL)
4138 isc_mem_put(mctx, manager->read_fds_copy, manager->fd_bufsize);
4139 if (manager->write_fds != NULL)
4140 isc_mem_put(mctx, manager->write_fds, manager->fd_bufsize);
4141 if (manager->write_fds_copy != NULL)
4142 isc_mem_put(mctx, manager->write_fds_copy, manager->fd_bufsize);
4156 isc__socketmgr_t *manager;
4179 manager = isc_mem_get(mctx, sizeof(*manager));
4180 if (manager == NULL)
4184 memset(manager, 0, sizeof(*manager));
4185 manager->maxsocks = maxsocks;
4186 manager->reserved = 0;
4187 manager->maxudp = 0;
4188 manager->fds = isc_mem_get(mctx,
4189 manager->maxsocks * sizeof(isc__socket_t *));
4190 if (manager->fds == NULL) {
4194 manager->fdstate = isc_mem_get(mctx, manager->maxsocks * sizeof(int));
4195 if (manager->fdstate == NULL) {
4199 manager->stats = NULL;
4201 manager->common.methods = &socketmgrmethods;
4202 manager->common.magic = ISCAPI_SOCKETMGR_MAGIC;
4203 manager->common.impmagic = SOCKET_MANAGER_MAGIC;
4204 manager->mctx = NULL;
4205 memset(manager->fds, 0, manager->maxsocks * sizeof(isc_socket_t *));
4206 ISC_LIST_INIT(manager->socklist);
4207 result = isc_mutex_init(&manager->lock);
4210 manager->fdlock = isc_mem_get(mctx, FDLOCK_COUNT * sizeof(isc_mutex_t));
4211 if (manager->fdlock == NULL) {
4216 result = isc_mutex_init(&manager->fdlock[i]);
4219 DESTROYLOCK(&manager->fdlock[i]);
4220 isc_mem_put(mctx, manager->fdlock,
4222 manager->fdlock = NULL;
4228 if (isc_condition_init(&manager->shutdown_ok) != ISC_R_SUCCESS) {
4241 if (pipe(manager->pipe_fds) != 0) {
4252 RUNTIME_CHECK(make_nonblock(manager->pipe_fds[0]) == ISC_R_SUCCESS);
4254 RUNTIME_CHECK(make_nonblock(manager->pipe_fds[1]) == ISC_R_SUCCESS);
4259 manager->refs = 1;
4265 result = setup_watcher(mctx, manager);
4268 memset(manager->fdstate, 0, manager->maxsocks * sizeof(int));
4273 if (isc_thread_create(watcher, manager, &manager->watcher) !=
4279 cleanup_watcher(mctx, manager);
4284 isc_mem_attach(mctx, &manager->mctx);
4287 socketmgr = manager;
4289 *managerp = (isc_socketmgr_t *)manager;
4295 (void)close(manager->pipe_fds[0]);
4296 (void)close(manager->pipe_fds[1]);
4301 (void)isc_condition_destroy(&manager->shutdown_ok);
4306 if (manager->fdlock != NULL) {
4308 DESTROYLOCK(&manager->fdlock[i]);
4310 DESTROYLOCK(&manager->lock);
4313 if (manager->fdlock != NULL) {
4314 isc_mem_put(mctx, manager->fdlock,
4317 if (manager->fdstate != NULL) {
4318 isc_mem_put(mctx, manager->fdstate,
4319 manager->maxsocks * sizeof(int));
4321 if (manager->fds != NULL) {
4322 isc_mem_put(mctx, manager->fds,
4323 manager->maxsocks * sizeof(isc_socket_t *));
4325 isc_mem_put(mctx, manager, sizeof(*manager));
4333 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
4334 REQUIRE(VALID_MANAGER(manager));
4337 *nsockp = manager->maxsocks;
4344 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
4346 REQUIRE(VALID_MANAGER(manager));
4347 REQUIRE(ISC_LIST_EMPTY(manager->socklist));
4348 REQUIRE(manager->stats == NULL);
4351 isc_stats_attach(stats, &manager->stats);
4357 isc__socketmgr_t *manager;
4362 * Destroy a socket manager.
4366 manager = (isc__socketmgr_t *)*managerp;
4367 REQUIRE(VALID_MANAGER(manager));
4370 manager->refs--;
4371 if (manager->refs > 0) {
4378 LOCK(&manager->lock);
4383 while (!ISC_LIST_EMPTY(manager->socklist)) {
4385 manager_log(manager, CREATION, "%s",
4389 WAIT(&manager->shutdown_ok, &manager->lock);
4391 UNLOCK(&manager->lock);
4393 LOCK(&manager->lock);
4397 UNLOCK(&manager->lock);
4404 select_poke(manager, 0, SELECT_POKE_SHUTDOWN);
4410 if (isc_thread_join(manager->watcher, NULL) != ISC_R_SUCCESS)
4420 cleanup_watcher(manager->mctx, manager);
4423 (void)close(manager->pipe_fds[0]);
4424 (void)close(manager->pipe_fds[1]);
4425 (void)isc_condition_destroy(&manager->shutdown_ok);
4428 for (i = 0; i < (int)manager->maxsocks; i++)
4429 if (manager->fdstate[i] == CLOSE_PENDING) /* no need to lock */
4432 isc_mem_put(manager->mctx, manager->fds,
4433 manager->maxsocks * sizeof(isc__socket_t *));
4434 isc_mem_put(manager->mctx, manager->fdstate,
4435 manager->maxsocks * sizeof(int));
4437 if (manager->stats != NULL)
4438 isc_stats_detach(&manager->stats);
4440 if (manager->fdlock != NULL) {
4442 DESTROYLOCK(&manager->fdlock[i]);
4443 isc_mem_put(manager->mctx, manager->fdlock,
4446 DESTROYLOCK(&manager->lock);
4447 manager->common.magic = 0;
4448 manager->common.impmagic = 0;
4449 mctx= manager->mctx;
4450 isc_mem_put(mctx, manager, sizeof(*manager));
4505 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
4540 isc__socketmgr_t *manager;
4550 manager = sock->manager;
4551 REQUIRE(VALID_MANAGER(manager));
4594 isc__socketmgr_t *manager;
4599 manager = sock->manager;
4600 REQUIRE(VALID_MANAGER(manager));
4707 select_poke(sock->manager, sock->fd,
4751 isc__socketmgr_t *manager;
4758 manager = sock->manager;
4759 REQUIRE(VALID_MANAGER(manager));
4787 isc__socketmgr_t *manager;
4797 manager = sock->manager;
4798 REQUIRE(VALID_MANAGER(manager));
5067 inc_stats(sock->manager->stats,
5184 isc__socketmgr_t *manager;
5191 manager = sock->manager;
5192 REQUIRE(VALID_MANAGER(manager));
5204 isc_event_allocate(manager->mctx, task, ISC_SOCKEVENT_NEWCONN,
5212 result = allocate_socket(manager, sock->type, &nsock);
5247 select_poke(manager, sock->fd, SELECT_POKE_ACCEPT);
5260 isc__socketmgr_t *manager;
5270 manager = sock->manager;
5271 REQUIRE(VALID_MANAGER(manager));
5281 dev = (isc_socket_connev_t *)isc_event_allocate(manager->mctx, sock,
5337 inc_stats(sock->manager->stats,
5347 inc_stats(sock->manager->stats,
5364 inc_stats(sock->manager->stats,
5387 select_poke(manager, sock->fd, SELECT_POKE_CONNECT);
5458 select_poke(sock->manager, sock->fd,
5465 inc_stats(sock->manager->stats,
5498 inc_stats(sock->manager->stats,
5764 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
5781 if (manager == NULL)
5782 manager = socketmgr;
5784 if (manager == NULL)
5794 swait_private.nevents = kevent(manager->kqueue_fd, NULL, 0,
5795 manager->events, manager->nevents,
5803 swait_private.nevents = epoll_wait(manager->epoll_fd,
5804 manager->events,
5805 manager->nevents, timeout);
5808 dvp.dp_fds = manager->events;
5809 dvp.dp_nfds = manager->nevents;
5815 swait_private.nevents = ioctl(manager->devpoll_fd, DP_POLL, &dvp);
5818 memcpy(manager->read_fds_copy, manager->read_fds, manager->fd_bufsize);
5819 memcpy(manager->write_fds_copy, manager->write_fds,
5820 manager->fd_bufsize);
5822 swait_private.readset = manager->read_fds_copy;
5823 swait_private.writeset = manager->write_fds_copy;
5824 swait_private.maxfd = manager->maxfd + 1;
5836 isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
5841 if (manager == NULL)
5842 manager = socketmgr;
5844 if (manager == NULL)
5848 (void)process_fds(manager, manager->events, swait->nevents);
5851 process_fds(manager, swait->maxfd, swait->readset, swait->writeset);