2 * Event loop based on select() loop
3 * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
17 #if defined(CONFIG_ELOOP_POLL) && defined(CONFIG_ELOOP_EPOLL)
18 #error Do not define both of poll and epoll
21 #if !defined(CONFIG_ELOOP_POLL) && !defined(CONFIG_ELOOP_EPOLL)
22 #define CONFIG_ELOOP_SELECT
25 #ifdef CONFIG_ELOOP_POLL
27 #endif /* CONFIG_ELOOP_POLL */
29 #ifdef CONFIG_ELOOP_EPOLL
30 #include <sys/epoll.h>
31 #endif /* CONFIG_ELOOP_EPOLL */
37 eloop_sock_handler handler;
43 struct eloop_timeout {
45 struct os_reltime time;
48 eloop_timeout_handler handler;
57 eloop_signal_handler handler;
61 struct eloop_sock_table {
63 struct eloop_sock *table;
64 #ifdef CONFIG_ELOOP_EPOLL
65 eloop_event_type type;
66 #else /* CONFIG_ELOOP_EPOLL */
68 #endif /* CONFIG_ELOOP_EPOLL */
74 int count; /* sum of all table counts */
75 #ifdef CONFIG_ELOOP_POLL
76 int max_pollfd_map; /* number of pollfds_map currently allocated */
77 int max_poll_fds; /* number of pollfds currently allocated */
78 struct pollfd *pollfds;
79 struct pollfd **pollfds_map;
80 #endif /* CONFIG_ELOOP_POLL */
81 #ifdef CONFIG_ELOOP_EPOLL
83 int epoll_max_event_num;
85 struct eloop_sock *epoll_table;
86 struct epoll_event *epoll_events;
87 #endif /* CONFIG_ELOOP_EPOLL */
88 struct eloop_sock_table readers;
89 struct eloop_sock_table writers;
90 struct eloop_sock_table exceptions;
92 struct dl_list timeout;
95 struct eloop_signal *signals;
97 int pending_terminate;
102 static struct eloop_data eloop;
107 static void eloop_sigsegv_handler(int sig)
109 wpa_trace_show("eloop SIGSEGV");
113 static void eloop_trace_sock_add_ref(struct eloop_sock_table *table)
116 if (table == NULL || table->table == NULL)
118 for (i = 0; i < table->count; i++) {
119 wpa_trace_add_ref(&table->table[i], eloop,
120 table->table[i].eloop_data);
121 wpa_trace_add_ref(&table->table[i], user,
122 table->table[i].user_data);
127 static void eloop_trace_sock_remove_ref(struct eloop_sock_table *table)
130 if (table == NULL || table->table == NULL)
132 for (i = 0; i < table->count; i++) {
133 wpa_trace_remove_ref(&table->table[i], eloop,
134 table->table[i].eloop_data);
135 wpa_trace_remove_ref(&table->table[i], user,
136 table->table[i].user_data);
140 #else /* WPA_TRACE */
142 #define eloop_trace_sock_add_ref(table) do { } while (0)
143 #define eloop_trace_sock_remove_ref(table) do { } while (0)
145 #endif /* WPA_TRACE */
150 os_memset(&eloop, 0, sizeof(eloop));
151 dl_list_init(&eloop.timeout);
152 #ifdef CONFIG_ELOOP_EPOLL
153 eloop.epollfd = epoll_create1(0);
154 if (eloop.epollfd < 0) {
155 wpa_printf(MSG_ERROR, "%s: epoll_create1 failed. %s\n",
156 __func__, strerror(errno));
159 eloop.readers.type = EVENT_TYPE_READ;
160 eloop.writers.type = EVENT_TYPE_WRITE;
161 eloop.exceptions.type = EVENT_TYPE_EXCEPTION;
162 #endif /* CONFIG_ELOOP_EPOLL */
164 signal(SIGSEGV, eloop_sigsegv_handler);
165 #endif /* WPA_TRACE */
170 static int eloop_sock_table_add_sock(struct eloop_sock_table *table,
171 int sock, eloop_sock_handler handler,
172 void *eloop_data, void *user_data)
174 #ifdef CONFIG_ELOOP_EPOLL
175 struct eloop_sock *temp_table;
176 struct epoll_event ev, *temp_events;
178 #endif /* CONFIG_ELOOP_EPOLL */
179 struct eloop_sock *tmp;
182 if (sock > eloop.max_sock)
185 new_max_sock = eloop.max_sock;
190 #ifdef CONFIG_ELOOP_POLL
191 if (new_max_sock >= eloop.max_pollfd_map) {
192 struct pollfd **nmap;
193 nmap = os_realloc_array(eloop.pollfds_map, new_max_sock + 50,
194 sizeof(struct pollfd *));
198 eloop.max_pollfd_map = new_max_sock + 50;
199 eloop.pollfds_map = nmap;
202 if (eloop.count + 1 > eloop.max_poll_fds) {
204 int nmax = eloop.count + 1 + 50;
205 n = os_realloc_array(eloop.pollfds, nmax,
206 sizeof(struct pollfd));
210 eloop.max_poll_fds = nmax;
213 #endif /* CONFIG_ELOOP_POLL */
214 #ifdef CONFIG_ELOOP_EPOLL
215 if (new_max_sock >= eloop.epoll_max_fd) {
216 next = eloop.epoll_max_fd == 0 ? 16 : eloop.epoll_max_fd * 2;
217 temp_table = os_realloc_array(eloop.epoll_table, next,
218 sizeof(struct eloop_sock));
219 if (temp_table == NULL)
222 eloop.epoll_max_fd = next;
223 eloop.epoll_table = temp_table;
226 if (eloop.count + 1 > eloop.epoll_max_event_num) {
227 next = eloop.epoll_max_event_num == 0 ? 8 :
228 eloop.epoll_max_event_num * 2;
229 temp_events = os_realloc_array(eloop.epoll_events, next,
230 sizeof(struct epoll_event));
231 if (temp_events == NULL) {
232 wpa_printf(MSG_ERROR, "%s: malloc for epoll failed. "
233 "%s\n", __func__, strerror(errno));
237 eloop.epoll_max_event_num = next;
238 eloop.epoll_events = temp_events;
240 #endif /* CONFIG_ELOOP_EPOLL */
242 eloop_trace_sock_remove_ref(table);
243 tmp = os_realloc_array(table->table, table->count + 1,
244 sizeof(struct eloop_sock));
246 eloop_trace_sock_add_ref(table);
250 tmp[table->count].sock = sock;
251 tmp[table->count].eloop_data = eloop_data;
252 tmp[table->count].user_data = user_data;
253 tmp[table->count].handler = handler;
254 wpa_trace_record(&tmp[table->count]);
257 eloop.max_sock = new_max_sock;
259 #ifndef CONFIG_ELOOP_EPOLL
261 #endif /* CONFIG_ELOOP_EPOLL */
262 eloop_trace_sock_add_ref(table);
264 #ifdef CONFIG_ELOOP_EPOLL
265 os_memset(&ev, 0, sizeof(ev));
266 switch (table->type) {
267 case EVENT_TYPE_READ:
270 case EVENT_TYPE_WRITE:
271 ev.events = EPOLLOUT;
274 * Exceptions are always checked when using epoll, but I suppose it's
275 * possible that someone registered a socket *only* for exception
278 case EVENT_TYPE_EXCEPTION:
279 ev.events = EPOLLERR | EPOLLHUP;
283 if (epoll_ctl(eloop.epollfd, EPOLL_CTL_ADD, sock, &ev) < 0) {
284 wpa_printf(MSG_ERROR, "%s: epoll_ctl(ADD) for fd=%d "
285 "failed. %s\n", __func__, sock, strerror(errno));
288 os_memcpy(&eloop.epoll_table[sock], &table->table[table->count - 1],
289 sizeof(struct eloop_sock));
290 #endif /* CONFIG_ELOOP_EPOLL */
295 static void eloop_sock_table_remove_sock(struct eloop_sock_table *table,
300 if (table == NULL || table->table == NULL || table->count == 0)
303 for (i = 0; i < table->count; i++) {
304 if (table->table[i].sock == sock)
307 if (i == table->count)
309 eloop_trace_sock_remove_ref(table);
310 if (i != table->count - 1) {
311 os_memmove(&table->table[i], &table->table[i + 1],
312 (table->count - i - 1) *
313 sizeof(struct eloop_sock));
317 #ifndef CONFIG_ELOOP_EPOLL
319 #endif /* CONFIG_ELOOP_EPOLL */
320 eloop_trace_sock_add_ref(table);
321 #ifdef CONFIG_ELOOP_EPOLL
322 if (epoll_ctl(eloop.epollfd, EPOLL_CTL_DEL, sock, NULL) < 0) {
323 wpa_printf(MSG_ERROR, "%s: epoll_ctl(DEL) for fd=%d "
324 "failed. %s\n", __func__, sock, strerror(errno));
327 os_memset(&eloop.epoll_table[sock], 0, sizeof(struct eloop_sock));
328 #endif /* CONFIG_ELOOP_EPOLL */
332 #ifdef CONFIG_ELOOP_POLL
334 static struct pollfd * find_pollfd(struct pollfd **pollfds_map, int fd, int mx)
336 if (fd < mx && fd >= 0)
337 return pollfds_map[fd];
342 static int eloop_sock_table_set_fds(struct eloop_sock_table *readers,
343 struct eloop_sock_table *writers,
344 struct eloop_sock_table *exceptions,
345 struct pollfd *pollfds,
346 struct pollfd **pollfds_map,
354 /* Clear pollfd lookup map. It will be re-populated below. */
355 os_memset(pollfds_map, 0, sizeof(struct pollfd *) * max_pollfd_map);
357 if (readers && readers->table) {
358 for (i = 0; i < readers->count; i++) {
359 fd = readers->table[i].sock;
360 assert(fd >= 0 && fd < max_pollfd_map);
361 pollfds[nxt].fd = fd;
362 pollfds[nxt].events = POLLIN;
363 pollfds[nxt].revents = 0;
364 pollfds_map[fd] = &(pollfds[nxt]);
369 if (writers && writers->table) {
370 for (i = 0; i < writers->count; i++) {
372 * See if we already added this descriptor, update it
375 fd = writers->table[i].sock;
376 assert(fd >= 0 && fd < max_pollfd_map);
377 pfd = pollfds_map[fd];
379 pfd = &(pollfds[nxt]);
382 pollfds[i].revents = 0;
383 pollfds_map[fd] = pfd;
386 pfd->events |= POLLOUT;
391 * Exceptions are always checked when using poll, but I suppose it's
392 * possible that someone registered a socket *only* for exception
393 * handling. Set the POLLIN bit in this case.
395 if (exceptions && exceptions->table) {
396 for (i = 0; i < exceptions->count; i++) {
398 * See if we already added this descriptor, just use it
401 fd = exceptions->table[i].sock;
402 assert(fd >= 0 && fd < max_pollfd_map);
403 pfd = pollfds_map[fd];
405 pfd = &(pollfds[nxt]);
406 pfd->events = POLLIN;
408 pollfds[i].revents = 0;
409 pollfds_map[fd] = pfd;
419 static int eloop_sock_table_dispatch_table(struct eloop_sock_table *table,
420 struct pollfd **pollfds_map,
427 if (!table || !table->table)
431 for (i = 0; i < table->count; i++) {
432 pfd = find_pollfd(pollfds_map, table->table[i].sock,
437 if (!(pfd->revents & revents))
440 table->table[i].handler(table->table[i].sock,
441 table->table[i].eloop_data,
442 table->table[i].user_data);
451 static void eloop_sock_table_dispatch(struct eloop_sock_table *readers,
452 struct eloop_sock_table *writers,
453 struct eloop_sock_table *exceptions,
454 struct pollfd **pollfds_map,
457 if (eloop_sock_table_dispatch_table(readers, pollfds_map,
458 max_pollfd_map, POLLIN | POLLERR |
460 return; /* pollfds may be invalid at this point */
462 if (eloop_sock_table_dispatch_table(writers, pollfds_map,
463 max_pollfd_map, POLLOUT))
464 return; /* pollfds may be invalid at this point */
466 eloop_sock_table_dispatch_table(exceptions, pollfds_map,
467 max_pollfd_map, POLLERR | POLLHUP);
470 #endif /* CONFIG_ELOOP_POLL */
472 #ifdef CONFIG_ELOOP_SELECT
474 static void eloop_sock_table_set_fds(struct eloop_sock_table *table,
481 if (table->table == NULL)
484 for (i = 0; i < table->count; i++) {
485 assert(table->table[i].sock >= 0);
486 FD_SET(table->table[i].sock, fds);
491 static void eloop_sock_table_dispatch(struct eloop_sock_table *table,
496 if (table == NULL || table->table == NULL)
500 for (i = 0; i < table->count; i++) {
501 if (FD_ISSET(table->table[i].sock, fds)) {
502 table->table[i].handler(table->table[i].sock,
503 table->table[i].eloop_data,
504 table->table[i].user_data);
511 #endif /* CONFIG_ELOOP_SELECT */
514 #ifdef CONFIG_ELOOP_EPOLL
515 static void eloop_sock_table_dispatch(struct epoll_event *events, int nfds)
517 struct eloop_sock *table;
520 for (i = 0; i < nfds; i++) {
521 table = &eloop.epoll_table[events[i].data.fd];
522 if (table->handler == NULL)
524 table->handler(table->sock, table->eloop_data,
528 #endif /* CONFIG_ELOOP_EPOLL */
531 static void eloop_sock_table_destroy(struct eloop_sock_table *table)
535 for (i = 0; i < table->count && table->table; i++) {
536 wpa_printf(MSG_INFO, "ELOOP: remaining socket: "
537 "sock=%d eloop_data=%p user_data=%p "
539 table->table[i].sock,
540 table->table[i].eloop_data,
541 table->table[i].user_data,
542 table->table[i].handler);
543 wpa_trace_dump_funcname("eloop unregistered socket "
545 table->table[i].handler);
546 wpa_trace_dump("eloop sock", &table->table[i]);
548 os_free(table->table);
553 int eloop_register_read_sock(int sock, eloop_sock_handler handler,
554 void *eloop_data, void *user_data)
556 return eloop_register_sock(sock, EVENT_TYPE_READ, handler,
557 eloop_data, user_data);
561 void eloop_unregister_read_sock(int sock)
563 eloop_unregister_sock(sock, EVENT_TYPE_READ);
567 static struct eloop_sock_table *eloop_get_sock_table(eloop_event_type type)
570 case EVENT_TYPE_READ:
571 return &eloop.readers;
572 case EVENT_TYPE_WRITE:
573 return &eloop.writers;
574 case EVENT_TYPE_EXCEPTION:
575 return &eloop.exceptions;
582 int eloop_register_sock(int sock, eloop_event_type type,
583 eloop_sock_handler handler,
584 void *eloop_data, void *user_data)
586 struct eloop_sock_table *table;
589 table = eloop_get_sock_table(type);
590 return eloop_sock_table_add_sock(table, sock, handler,
591 eloop_data, user_data);
595 void eloop_unregister_sock(int sock, eloop_event_type type)
597 struct eloop_sock_table *table;
599 table = eloop_get_sock_table(type);
600 eloop_sock_table_remove_sock(table, sock);
604 int eloop_register_timeout(unsigned int secs, unsigned int usecs,
605 eloop_timeout_handler handler,
606 void *eloop_data, void *user_data)
608 struct eloop_timeout *timeout, *tmp;
611 timeout = os_zalloc(sizeof(*timeout));
614 if (os_get_reltime(&timeout->time) < 0) {
618 now_sec = timeout->time.sec;
619 timeout->time.sec += secs;
620 if (timeout->time.sec < now_sec) {
622 * Integer overflow - assume long enough timeout to be assumed
623 * to be infinite, i.e., the timeout would never happen.
625 wpa_printf(MSG_DEBUG, "ELOOP: Too long timeout (secs=%u) to "
626 "ever happen - ignore it", secs);
630 timeout->time.usec += usecs;
631 while (timeout->time.usec >= 1000000) {
633 timeout->time.usec -= 1000000;
635 timeout->eloop_data = eloop_data;
636 timeout->user_data = user_data;
637 timeout->handler = handler;
638 wpa_trace_add_ref(timeout, eloop, eloop_data);
639 wpa_trace_add_ref(timeout, user, user_data);
640 wpa_trace_record(timeout);
642 /* Maintain timeouts in order of increasing time */
643 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
644 if (os_reltime_before(&timeout->time, &tmp->time)) {
645 dl_list_add(tmp->list.prev, &timeout->list);
649 dl_list_add_tail(&eloop.timeout, &timeout->list);
655 static void eloop_remove_timeout(struct eloop_timeout *timeout)
657 dl_list_del(&timeout->list);
658 wpa_trace_remove_ref(timeout, eloop, timeout->eloop_data);
659 wpa_trace_remove_ref(timeout, user, timeout->user_data);
664 int eloop_cancel_timeout(eloop_timeout_handler handler,
665 void *eloop_data, void *user_data)
667 struct eloop_timeout *timeout, *prev;
670 dl_list_for_each_safe(timeout, prev, &eloop.timeout,
671 struct eloop_timeout, list) {
672 if (timeout->handler == handler &&
673 (timeout->eloop_data == eloop_data ||
674 eloop_data == ELOOP_ALL_CTX) &&
675 (timeout->user_data == user_data ||
676 user_data == ELOOP_ALL_CTX)) {
677 eloop_remove_timeout(timeout);
686 int eloop_cancel_timeout_one(eloop_timeout_handler handler,
687 void *eloop_data, void *user_data,
688 struct os_reltime *remaining)
690 struct eloop_timeout *timeout, *prev;
692 struct os_reltime now;
694 os_get_reltime(&now);
695 remaining->sec = remaining->usec = 0;
697 dl_list_for_each_safe(timeout, prev, &eloop.timeout,
698 struct eloop_timeout, list) {
699 if (timeout->handler == handler &&
700 (timeout->eloop_data == eloop_data) &&
701 (timeout->user_data == user_data)) {
703 if (os_reltime_before(&now, &timeout->time))
704 os_reltime_sub(&timeout->time, &now, remaining);
705 eloop_remove_timeout(timeout);
713 int eloop_is_timeout_registered(eloop_timeout_handler handler,
714 void *eloop_data, void *user_data)
716 struct eloop_timeout *tmp;
718 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
719 if (tmp->handler == handler &&
720 tmp->eloop_data == eloop_data &&
721 tmp->user_data == user_data)
729 int eloop_deplete_timeout(unsigned int req_secs, unsigned int req_usecs,
730 eloop_timeout_handler handler, void *eloop_data,
733 struct os_reltime now, requested, remaining;
734 struct eloop_timeout *tmp;
736 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
737 if (tmp->handler == handler &&
738 tmp->eloop_data == eloop_data &&
739 tmp->user_data == user_data) {
740 requested.sec = req_secs;
741 requested.usec = req_usecs;
742 os_get_reltime(&now);
743 os_reltime_sub(&tmp->time, &now, &remaining);
744 if (os_reltime_before(&requested, &remaining)) {
745 eloop_cancel_timeout(handler, eloop_data,
747 eloop_register_timeout(requested.sec,
761 int eloop_replenish_timeout(unsigned int req_secs, unsigned int req_usecs,
762 eloop_timeout_handler handler, void *eloop_data,
765 struct os_reltime now, requested, remaining;
766 struct eloop_timeout *tmp;
768 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
769 if (tmp->handler == handler &&
770 tmp->eloop_data == eloop_data &&
771 tmp->user_data == user_data) {
772 requested.sec = req_secs;
773 requested.usec = req_usecs;
774 os_get_reltime(&now);
775 os_reltime_sub(&tmp->time, &now, &remaining);
776 if (os_reltime_before(&remaining, &requested)) {
777 eloop_cancel_timeout(handler, eloop_data,
779 eloop_register_timeout(requested.sec,
793 #ifndef CONFIG_NATIVE_WINDOWS
794 static void eloop_handle_alarm(int sig)
796 wpa_printf(MSG_ERROR, "eloop: could not process SIGINT or SIGTERM in "
797 "two seconds. Looks like there\n"
798 "is a bug that ends up in a busy loop that "
799 "prevents clean shutdown.\n"
800 "Killing program forcefully.\n");
803 #endif /* CONFIG_NATIVE_WINDOWS */
806 static void eloop_handle_signal(int sig)
810 #ifndef CONFIG_NATIVE_WINDOWS
811 if ((sig == SIGINT || sig == SIGTERM) && !eloop.pending_terminate) {
812 /* Use SIGALRM to break out from potential busy loops that
813 * would not allow the program to be killed. */
814 eloop.pending_terminate = 1;
815 signal(SIGALRM, eloop_handle_alarm);
818 #endif /* CONFIG_NATIVE_WINDOWS */
821 for (i = 0; i < eloop.signal_count; i++) {
822 if (eloop.signals[i].sig == sig) {
823 eloop.signals[i].signaled++;
830 static void eloop_process_pending_signals(void)
834 if (eloop.signaled == 0)
838 if (eloop.pending_terminate) {
839 #ifndef CONFIG_NATIVE_WINDOWS
841 #endif /* CONFIG_NATIVE_WINDOWS */
842 eloop.pending_terminate = 0;
845 for (i = 0; i < eloop.signal_count; i++) {
846 if (eloop.signals[i].signaled) {
847 eloop.signals[i].signaled = 0;
848 eloop.signals[i].handler(eloop.signals[i].sig,
849 eloop.signals[i].user_data);
855 int eloop_register_signal(int sig, eloop_signal_handler handler,
858 struct eloop_signal *tmp;
860 tmp = os_realloc_array(eloop.signals, eloop.signal_count + 1,
861 sizeof(struct eloop_signal));
865 tmp[eloop.signal_count].sig = sig;
866 tmp[eloop.signal_count].user_data = user_data;
867 tmp[eloop.signal_count].handler = handler;
868 tmp[eloop.signal_count].signaled = 0;
869 eloop.signal_count++;
871 signal(sig, eloop_handle_signal);
877 int eloop_register_signal_terminate(eloop_signal_handler handler,
880 int ret = eloop_register_signal(SIGINT, handler, user_data);
882 ret = eloop_register_signal(SIGTERM, handler, user_data);
887 int eloop_register_signal_reconfig(eloop_signal_handler handler,
890 #ifdef CONFIG_NATIVE_WINDOWS
892 #else /* CONFIG_NATIVE_WINDOWS */
893 return eloop_register_signal(SIGHUP, handler, user_data);
894 #endif /* CONFIG_NATIVE_WINDOWS */
900 #ifdef CONFIG_ELOOP_POLL
903 #endif /* CONFIG_ELOOP_POLL */
904 #ifdef CONFIG_ELOOP_SELECT
905 fd_set *rfds, *wfds, *efds;
907 #endif /* CONFIG_ELOOP_SELECT */
908 #ifdef CONFIG_ELOOP_EPOLL
910 #endif /* CONFIG_ELOOP_EPOLL */
912 struct os_reltime tv, now;
914 #ifdef CONFIG_ELOOP_SELECT
915 rfds = os_malloc(sizeof(*rfds));
916 wfds = os_malloc(sizeof(*wfds));
917 efds = os_malloc(sizeof(*efds));
918 if (rfds == NULL || wfds == NULL || efds == NULL)
920 #endif /* CONFIG_ELOOP_SELECT */
922 while (!eloop.terminate &&
923 (!dl_list_empty(&eloop.timeout) || eloop.readers.count > 0 ||
924 eloop.writers.count > 0 || eloop.exceptions.count > 0)) {
925 struct eloop_timeout *timeout;
926 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
929 os_get_reltime(&now);
930 if (os_reltime_before(&now, &timeout->time))
931 os_reltime_sub(&timeout->time, &now, &tv);
933 tv.sec = tv.usec = 0;
934 #if defined(CONFIG_ELOOP_POLL) || defined(CONFIG_ELOOP_EPOLL)
935 timeout_ms = tv.sec * 1000 + tv.usec / 1000;
936 #endif /* defined(CONFIG_ELOOP_POLL) || defined(CONFIG_ELOOP_EPOLL) */
937 #ifdef CONFIG_ELOOP_SELECT
939 _tv.tv_usec = tv.usec;
940 #endif /* CONFIG_ELOOP_SELECT */
943 #ifdef CONFIG_ELOOP_POLL
944 num_poll_fds = eloop_sock_table_set_fds(
945 &eloop.readers, &eloop.writers, &eloop.exceptions,
946 eloop.pollfds, eloop.pollfds_map,
947 eloop.max_pollfd_map);
948 res = poll(eloop.pollfds, num_poll_fds,
949 timeout ? timeout_ms : -1);
950 #endif /* CONFIG_ELOOP_POLL */
951 #ifdef CONFIG_ELOOP_SELECT
952 eloop_sock_table_set_fds(&eloop.readers, rfds);
953 eloop_sock_table_set_fds(&eloop.writers, wfds);
954 eloop_sock_table_set_fds(&eloop.exceptions, efds);
955 res = select(eloop.max_sock + 1, rfds, wfds, efds,
956 timeout ? &_tv : NULL);
957 #endif /* CONFIG_ELOOP_SELECT */
958 #ifdef CONFIG_ELOOP_EPOLL
959 if (eloop.count == 0) {
962 res = epoll_wait(eloop.epollfd, eloop.epoll_events,
963 eloop.count, timeout_ms);
965 #endif /* CONFIG_ELOOP_EPOLL */
966 if (res < 0 && errno != EINTR && errno != 0) {
967 wpa_printf(MSG_ERROR, "eloop: %s: %s",
968 #ifdef CONFIG_ELOOP_POLL
970 #endif /* CONFIG_ELOOP_POLL */
971 #ifdef CONFIG_ELOOP_SELECT
973 #endif /* CONFIG_ELOOP_SELECT */
974 #ifdef CONFIG_ELOOP_EPOLL
976 #endif /* CONFIG_ELOOP_EPOLL */
980 eloop_process_pending_signals();
982 /* check if some registered timeouts have occurred */
983 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
986 os_get_reltime(&now);
987 if (!os_reltime_before(&now, &timeout->time)) {
988 void *eloop_data = timeout->eloop_data;
989 void *user_data = timeout->user_data;
990 eloop_timeout_handler handler =
992 eloop_remove_timeout(timeout);
993 handler(eloop_data, user_data);
1001 #ifdef CONFIG_ELOOP_POLL
1002 eloop_sock_table_dispatch(&eloop.readers, &eloop.writers,
1003 &eloop.exceptions, eloop.pollfds_map,
1004 eloop.max_pollfd_map);
1005 #endif /* CONFIG_ELOOP_POLL */
1006 #ifdef CONFIG_ELOOP_SELECT
1007 eloop_sock_table_dispatch(&eloop.readers, rfds);
1008 eloop_sock_table_dispatch(&eloop.writers, wfds);
1009 eloop_sock_table_dispatch(&eloop.exceptions, efds);
1010 #endif /* CONFIG_ELOOP_SELECT */
1011 #ifdef CONFIG_ELOOP_EPOLL
1012 eloop_sock_table_dispatch(eloop.epoll_events, res);
1013 #endif /* CONFIG_ELOOP_EPOLL */
1016 eloop.terminate = 0;
1018 #ifdef CONFIG_ELOOP_SELECT
1022 #endif /* CONFIG_ELOOP_SELECT */
1027 void eloop_terminate(void)
1029 eloop.terminate = 1;
1033 void eloop_destroy(void)
1035 struct eloop_timeout *timeout, *prev;
1036 struct os_reltime now;
1038 os_get_reltime(&now);
1039 dl_list_for_each_safe(timeout, prev, &eloop.timeout,
1040 struct eloop_timeout, list) {
1042 sec = timeout->time.sec - now.sec;
1043 usec = timeout->time.usec - now.usec;
1044 if (timeout->time.usec < now.usec) {
1048 wpa_printf(MSG_INFO, "ELOOP: remaining timeout: %d.%06d "
1049 "eloop_data=%p user_data=%p handler=%p",
1050 sec, usec, timeout->eloop_data, timeout->user_data,
1052 wpa_trace_dump_funcname("eloop unregistered timeout handler",
1054 wpa_trace_dump("eloop timeout", timeout);
1055 eloop_remove_timeout(timeout);
1057 eloop_sock_table_destroy(&eloop.readers);
1058 eloop_sock_table_destroy(&eloop.writers);
1059 eloop_sock_table_destroy(&eloop.exceptions);
1060 os_free(eloop.signals);
1062 #ifdef CONFIG_ELOOP_POLL
1063 os_free(eloop.pollfds);
1064 os_free(eloop.pollfds_map);
1065 #endif /* CONFIG_ELOOP_POLL */
1066 #ifdef CONFIG_ELOOP_EPOLL
1067 os_free(eloop.epoll_table);
1068 os_free(eloop.epoll_events);
1069 close(eloop.epollfd);
1070 #endif /* CONFIG_ELOOP_EPOLL */
1074 int eloop_terminated(void)
1076 return eloop.terminate;
1080 void eloop_wait_for_read_sock(int sock)
1082 #ifdef CONFIG_ELOOP_POLL
1088 os_memset(&pfd, 0, sizeof(pfd));
1090 pfd.events = POLLIN;
1093 #endif /* CONFIG_ELOOP_POLL */
1094 #if defined(CONFIG_ELOOP_SELECT) || defined(CONFIG_ELOOP_EPOLL)
1096 * We can use epoll() here. But epoll() requres 4 system calls.
1097 * epoll_create1(), epoll_ctl() for ADD, epoll_wait, and close() for
1098 * epoll fd. So select() is better for performance here.
1106 FD_SET(sock, &rfds);
1107 select(sock + 1, &rfds, NULL, NULL, NULL);
1108 #endif /* defined(CONFIG_ELOOP_SELECT) || defined(CONFIG_ELOOP_EPOLL) */
1111 #ifdef CONFIG_ELOOP_SELECT
1112 #undef CONFIG_ELOOP_SELECT
1113 #endif /* CONFIG_ELOOP_SELECT */