1 /* 2 * Event loop based on select() loop 3 * Copyright (c) 2002-2009, Jouni Malinen <j (at) w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9 #include "includes.h" 10 #include <assert.h> 11 12 #include "common.h" 13 #include "trace.h" 14 #include "list.h" 15 #include "eloop.h" 16 17 #if defined(CONFIG_ELOOP_POLL) && defined(CONFIG_ELOOP_EPOLL) 18 #error Do not define both of poll and epoll 19 #endif 20 21 #if defined(CONFIG_ELOOP_POLL) && defined(CONFIG_ELOOP_KQUEUE) 22 #error Do not define both of poll and kqueue 23 #endif 24 25 #if !defined(CONFIG_ELOOP_POLL) && !defined(CONFIG_ELOOP_EPOLL) && \ 26 !defined(CONFIG_ELOOP_KQUEUE) 27 #define CONFIG_ELOOP_SELECT 28 #endif 29 30 #ifdef CONFIG_ELOOP_POLL 31 #include <poll.h> 32 #endif /* CONFIG_ELOOP_POLL */ 33 34 #ifdef CONFIG_ELOOP_EPOLL 35 #include <sys/epoll.h> 36 #endif /* CONFIG_ELOOP_EPOLL */ 37 38 #ifdef CONFIG_ELOOP_KQUEUE 39 #include <sys/event.h> 40 #endif /* CONFIG_ELOOP_KQUEUE */ 41 42 struct eloop_sock { 43 int sock; 44 void *eloop_data; 45 void *user_data; 46 eloop_sock_handler handler; 47 WPA_TRACE_REF(eloop); 48 WPA_TRACE_REF(user); 49 WPA_TRACE_INFO 50 }; 51 52 struct eloop_timeout { 53 struct dl_list list; 54 struct os_reltime time; 55 void *eloop_data; 56 void *user_data; 57 eloop_timeout_handler handler; 58 WPA_TRACE_REF(eloop); 59 WPA_TRACE_REF(user); 60 WPA_TRACE_INFO 61 }; 62 63 struct eloop_signal { 64 int sig; 65 void *user_data; 66 eloop_signal_handler handler; 67 int signaled; 68 }; 69 70 struct eloop_sock_table { 71 int count; 72 struct eloop_sock *table; 73 eloop_event_type type; 74 int changed; 75 }; 76 77 struct eloop_data { 78 int max_sock; 79 80 int count; /* sum of all table counts */ 81 #ifdef CONFIG_ELOOP_POLL 82 int max_pollfd_map; /* number of pollfds_map currently allocated */ 83 int max_poll_fds; /* number of pollfds currently allocated */ 84 struct pollfd *pollfds; 85 struct pollfd **pollfds_map; 86 #endif /* CONFIG_ELOOP_POLL */ 87 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE) 88 int max_fd; 89 struct eloop_sock *fd_table; 90 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */ 91 #ifdef CONFIG_ELOOP_EPOLL 92 int epollfd; 93 int epoll_max_event_num; 94 struct epoll_event *epoll_events; 95 #endif /* CONFIG_ELOOP_EPOLL */ 96 #ifdef CONFIG_ELOOP_KQUEUE 97 int kqueuefd; 98 int kqueue_nevents; 99 struct kevent *kqueue_events; 100 #endif /* CONFIG_ELOOP_KQUEUE */ 101 struct eloop_sock_table readers; 102 struct eloop_sock_table writers; 103 struct eloop_sock_table exceptions; 104 105 struct dl_list timeout; 106 107 int signal_count; 108 struct eloop_signal *signals; 109 int signaled; 110 int pending_terminate; 111 112 int terminate; 113 }; 114 115 static struct eloop_data eloop; 116 117 118 #ifdef WPA_TRACE 119 120 static void eloop_sigsegv_handler(int sig) 121 { 122 wpa_trace_show("eloop SIGSEGV"); 123 abort(); 124 } 125 126 static void eloop_trace_sock_add_ref(struct eloop_sock_table *table) 127 { 128 int i; 129 if (table == NULL || table->table == NULL) 130 return; 131 for (i = 0; i < table->count; i++) { 132 wpa_trace_add_ref(&table->table[i], eloop, 133 table->table[i].eloop_data); 134 wpa_trace_add_ref(&table->table[i], user, 135 table->table[i].user_data); 136 } 137 } 138 139 140 static void eloop_trace_sock_remove_ref(struct eloop_sock_table *table) 141 { 142 int i; 143 if (table == NULL || table->table == NULL) 144 return; 145 for (i = 0; i < table->count; i++) { 146 wpa_trace_remove_ref(&table->table[i], eloop, 147 table->table[i].eloop_data); 148 wpa_trace_remove_ref(&table->table[i], user, 149 table->table[i].user_data); 150 } 151 } 152 153 #else /* WPA_TRACE */ 154 155 #define eloop_trace_sock_add_ref(table) do { } while (0) 156 #define eloop_trace_sock_remove_ref(table) do { } while (0) 157 158 #endif /* WPA_TRACE */ 159 160 161 int eloop_init(void) 162 { 163 os_memset(&eloop, 0, sizeof(eloop)); 164 dl_list_init(&eloop.timeout); 165 #ifdef CONFIG_ELOOP_EPOLL 166 eloop.epollfd = epoll_create1(0); 167 if (eloop.epollfd < 0) { 168 wpa_printf(MSG_ERROR, "%s: epoll_create1 failed. %s", 169 __func__, strerror(errno)); 170 return -1; 171 } 172 #endif /* CONFIG_ELOOP_EPOLL */ 173 #ifdef CONFIG_ELOOP_KQUEUE 174 eloop.kqueuefd = kqueue(); 175 if (eloop.kqueuefd < 0) { 176 wpa_printf(MSG_ERROR, "%s: kqueue failed: %s", 177 __func__, strerror(errno)); 178 return -1; 179 } 180 #endif /* CONFIG_ELOOP_KQUEUE */ 181 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE) 182 eloop.readers.type = EVENT_TYPE_READ; 183 eloop.writers.type = EVENT_TYPE_WRITE; 184 eloop.exceptions.type = EVENT_TYPE_EXCEPTION; 185 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */ 186 #ifdef WPA_TRACE 187 signal(SIGSEGV, eloop_sigsegv_handler); 188 #endif /* WPA_TRACE */ 189 return 0; 190 } 191 192 193 #ifdef CONFIG_ELOOP_EPOLL 194 static int eloop_sock_queue(int sock, eloop_event_type type) 195 { 196 struct epoll_event ev; 197 198 os_memset(&ev, 0, sizeof(ev)); 199 switch (type) { 200 case EVENT_TYPE_READ: 201 ev.events = EPOLLIN; 202 break; 203 case EVENT_TYPE_WRITE: 204 ev.events = EPOLLOUT; 205 break; 206 /* 207 * Exceptions are always checked when using epoll, but I suppose it's 208 * possible that someone registered a socket *only* for exception 209 * handling. 210 */ 211 case EVENT_TYPE_EXCEPTION: 212 ev.events = EPOLLERR | EPOLLHUP; 213 break; 214 } 215 ev.data.fd = sock; 216 if (epoll_ctl(eloop.epollfd, EPOLL_CTL_ADD, sock, &ev) < 0) { 217 wpa_printf(MSG_ERROR, "%s: epoll_ctl(ADD) for fd=%d failed: %s", 218 __func__, sock, strerror(errno)); 219 return -1; 220 } 221 return 0; 222 } 223 #endif /* CONFIG_ELOOP_EPOLL */ 224 225 226 #ifdef CONFIG_ELOOP_KQUEUE 227 static int eloop_sock_queue(int sock, eloop_event_type type) 228 { 229 int filter; 230 struct kevent ke; 231 232 switch (type) { 233 case EVENT_TYPE_READ: 234 filter = EVFILT_READ; 235 break; 236 case EVENT_TYPE_WRITE: 237 filter = EVFILT_WRITE; 238 break; 239 default: 240 filter = 0; 241 } 242 EV_SET(&ke, sock, filter, EV_ADD, 0, 0, 0); 243 if (kevent(eloop.kqueuefd, &ke, 1, NULL, 0, NULL) == -1) { 244 wpa_printf(MSG_ERROR, "%s: kevent(ADD) for fd=%d failed: %s", 245 __func__, sock, strerror(errno)); 246 return -1; 247 } 248 return 0; 249 } 250 #endif /* CONFIG_ELOOP_KQUEUE */ 251 252 253 static int eloop_sock_table_add_sock(struct eloop_sock_table *table, 254 int sock, eloop_sock_handler handler, 255 void *eloop_data, void *user_data) 256 { 257 #ifdef CONFIG_ELOOP_EPOLL 258 struct epoll_event *temp_events; 259 #endif /* CONFIG_ELOOP_EPOLL */ 260 #ifdef CONFIG_ELOOP_KQUEUE 261 struct kevent *temp_events; 262 #endif /* CONFIG_ELOOP_EPOLL */ 263 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE) 264 struct eloop_sock *temp_table; 265 int next; 266 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */ 267 struct eloop_sock *tmp; 268 int new_max_sock; 269 270 if (sock > eloop.max_sock) 271 new_max_sock = sock; 272 else 273 new_max_sock = eloop.max_sock; 274 275 if (table == NULL) 276 return -1; 277 278 #ifdef CONFIG_ELOOP_POLL 279 if (new_max_sock >= eloop.max_pollfd_map) { 280 struct pollfd **nmap; 281 nmap = os_realloc_array(eloop.pollfds_map, new_max_sock + 50, 282 sizeof(struct pollfd *)); 283 if (nmap == NULL) 284 return -1; 285 286 eloop.max_pollfd_map = new_max_sock + 50; 287 eloop.pollfds_map = nmap; 288 } 289 290 if (eloop.count + 1 > eloop.max_poll_fds) { 291 struct pollfd *n; 292 int nmax = eloop.count + 1 + 50; 293 n = os_realloc_array(eloop.pollfds, nmax, 294 sizeof(struct pollfd)); 295 if (n == NULL) 296 return -1; 297 298 eloop.max_poll_fds = nmax; 299 eloop.pollfds = n; 300 } 301 #endif /* CONFIG_ELOOP_POLL */ 302 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE) 303 if (new_max_sock >= eloop.max_fd) { 304 next = eloop.max_fd == 0 ? 16 : eloop.max_fd * 2; 305 temp_table = os_realloc_array(eloop.fd_table, next, 306 sizeof(struct eloop_sock)); 307 if (temp_table == NULL) 308 return -1; 309 310 eloop.max_fd = next; 311 eloop.fd_table = temp_table; 312 } 313 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */ 314 315 #ifdef CONFIG_ELOOP_EPOLL 316 if (eloop.count + 1 > eloop.epoll_max_event_num) { 317 next = eloop.epoll_max_event_num == 0 ? 8 : 318 eloop.epoll_max_event_num * 2; 319 temp_events = os_realloc_array(eloop.epoll_events, next, 320 sizeof(struct epoll_event)); 321 if (temp_events == NULL) { 322 wpa_printf(MSG_ERROR, "%s: malloc for epoll failed: %s", 323 __func__, strerror(errno)); 324 return -1; 325 } 326 327 eloop.epoll_max_event_num = next; 328 eloop.epoll_events = temp_events; 329 } 330 #endif /* CONFIG_ELOOP_EPOLL */ 331 #ifdef CONFIG_ELOOP_KQUEUE 332 if (eloop.count + 1 > eloop.kqueue_nevents) { 333 next = eloop.kqueue_nevents == 0 ? 8 : eloop.kqueue_nevents * 2; 334 temp_events = os_malloc(next * sizeof(*temp_events)); 335 if (!temp_events) { 336 wpa_printf(MSG_ERROR, 337 "%s: malloc for kqueue failed: %s", 338 __func__, strerror(errno)); 339 return -1; 340 } 341 342 os_free(eloop.kqueue_events); 343 eloop.kqueue_events = temp_events; 344 eloop.kqueue_nevents = next; 345 } 346 #endif /* CONFIG_ELOOP_KQUEUE */ 347 348 eloop_trace_sock_remove_ref(table); 349 tmp = os_realloc_array(table->table, table->count + 1, 350 sizeof(struct eloop_sock)); 351 if (tmp == NULL) { 352 eloop_trace_sock_add_ref(table); 353 return -1; 354 } 355 356 tmp[table->count].sock = sock; 357 tmp[table->count].eloop_data = eloop_data; 358 tmp[table->count].user_data = user_data; 359 tmp[table->count].handler = handler; 360 wpa_trace_record(&tmp[table->count]); 361 table->count++; 362 table->table = tmp; 363 eloop.max_sock = new_max_sock; 364 eloop.count++; 365 table->changed = 1; 366 eloop_trace_sock_add_ref(table); 367 368 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE) 369 if (eloop_sock_queue(sock, table->type) < 0) 370 return -1; 371 os_memcpy(&eloop.fd_table[sock], &table->table[table->count - 1], 372 sizeof(struct eloop_sock)); 373 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */ 374 return 0; 375 } 376 377 378 static void eloop_sock_table_remove_sock(struct eloop_sock_table *table, 379 int sock) 380 { 381 #ifdef CONFIG_ELOOP_KQUEUE 382 struct kevent ke; 383 #endif /* CONFIG_ELOOP_KQUEUE */ 384 int i; 385 386 if (table == NULL || table->table == NULL || table->count == 0) 387 return; 388 389 for (i = 0; i < table->count; i++) { 390 if (table->table[i].sock == sock) 391 break; 392 } 393 if (i == table->count) 394 return; 395 eloop_trace_sock_remove_ref(table); 396 if (i != table->count - 1) { 397 os_memmove(&table->table[i], &table->table[i + 1], 398 (table->count - i - 1) * 399 sizeof(struct eloop_sock)); 400 } 401 table->count--; 402 eloop.count--; 403 table->changed = 1; 404 eloop_trace_sock_add_ref(table); 405 #ifdef CONFIG_ELOOP_EPOLL 406 if (epoll_ctl(eloop.epollfd, EPOLL_CTL_DEL, sock, NULL) < 0) { 407 wpa_printf(MSG_ERROR, "%s: epoll_ctl(DEL) for fd=%d failed: %s", 408 __func__, sock, strerror(errno)); 409 return; 410 } 411 os_memset(&eloop.fd_table[sock], 0, sizeof(struct eloop_sock)); 412 #endif /* CONFIG_ELOOP_EPOLL */ 413 #ifdef CONFIG_ELOOP_KQUEUE 414 EV_SET(&ke, sock, 0, EV_DELETE, 0, 0, 0); 415 if (kevent(eloop.kqueuefd, &ke, 1, NULL, 0, NULL) < 0) { 416 wpa_printf(MSG_ERROR, "%s: kevent(DEL) for fd=%d failed: %s", 417 __func__, sock, strerror(errno)); 418 return; 419 } 420 os_memset(&eloop.fd_table[sock], 0, sizeof(struct eloop_sock)); 421 #endif /* CONFIG_ELOOP_KQUEUE */ 422 } 423 424 425 #ifdef CONFIG_ELOOP_POLL 426 427 static struct pollfd * find_pollfd(struct pollfd **pollfds_map, int fd, int mx) 428 { 429 if (fd < mx && fd >= 0) 430 return pollfds_map[fd]; 431 return NULL; 432 } 433 434 435 static int eloop_sock_table_set_fds(struct eloop_sock_table *readers, 436 struct eloop_sock_table *writers, 437 struct eloop_sock_table *exceptions, 438 struct pollfd *pollfds, 439 struct pollfd **pollfds_map, 440 int max_pollfd_map) 441 { 442 int i; 443 int nxt = 0; 444 int fd; 445 struct pollfd *pfd; 446 447 /* Clear pollfd lookup map. It will be re-populated below. */ 448 os_memset(pollfds_map, 0, sizeof(struct pollfd *) * max_pollfd_map); 449 450 if (readers && readers->table) { 451 for (i = 0; i < readers->count; i++) { 452 fd = readers->table[i].sock; 453 assert(fd >= 0 && fd < max_pollfd_map); 454 pollfds[nxt].fd = fd; 455 pollfds[nxt].events = POLLIN; 456 pollfds[nxt].revents = 0; 457 pollfds_map[fd] = &(pollfds[nxt]); 458 nxt++; 459 } 460 } 461 462 if (writers && writers->table) { 463 for (i = 0; i < writers->count; i++) { 464 /* 465 * See if we already added this descriptor, update it 466 * if so. 467 */ 468 fd = writers->table[i].sock; 469 assert(fd >= 0 && fd < max_pollfd_map); 470 pfd = pollfds_map[fd]; 471 if (!pfd) { 472 pfd = &(pollfds[nxt]); 473 pfd->events = 0; 474 pfd->fd = fd; 475 pollfds[i].revents = 0; 476 pollfds_map[fd] = pfd; 477 nxt++; 478 } 479 pfd->events |= POLLOUT; 480 } 481 } 482 483 /* 484 * Exceptions are always checked when using poll, but I suppose it's 485 * possible that someone registered a socket *only* for exception 486 * handling. Set the POLLIN bit in this case. 487 */ 488 if (exceptions && exceptions->table) { 489 for (i = 0; i < exceptions->count; i++) { 490 /* 491 * See if we already added this descriptor, just use it 492 * if so. 493 */ 494 fd = exceptions->table[i].sock; 495 assert(fd >= 0 && fd < max_pollfd_map); 496 pfd = pollfds_map[fd]; 497 if (!pfd) { 498 pfd = &(pollfds[nxt]); 499 pfd->events = POLLIN; 500 pfd->fd = fd; 501 pollfds[i].revents = 0; 502 pollfds_map[fd] = pfd; 503 nxt++; 504 } 505 } 506 } 507 508 return nxt; 509 } 510 511 512 static int eloop_sock_table_dispatch_table(struct eloop_sock_table *table, 513 struct pollfd **pollfds_map, 514 int max_pollfd_map, 515 short int revents) 516 { 517 int i; 518 struct pollfd *pfd; 519 520 if (!table || !table->table) 521 return 0; 522 523 table->changed = 0; 524 for (i = 0; i < table->count; i++) { 525 pfd = find_pollfd(pollfds_map, table->table[i].sock, 526 max_pollfd_map); 527 if (!pfd) 528 continue; 529 530 if (!(pfd->revents & revents)) 531 continue; 532 533 table->table[i].handler(table->table[i].sock, 534 table->table[i].eloop_data, 535 table->table[i].user_data); 536 if (table->changed) 537 return 1; 538 } 539 540 return 0; 541 } 542 543 544 static void eloop_sock_table_dispatch(struct eloop_sock_table *readers, 545 struct eloop_sock_table *writers, 546 struct eloop_sock_table *exceptions, 547 struct pollfd **pollfds_map, 548 int max_pollfd_map) 549 { 550 if (eloop_sock_table_dispatch_table(readers, pollfds_map, 551 max_pollfd_map, POLLIN | POLLERR | 552 POLLHUP)) 553 return; /* pollfds may be invalid at this point */ 554 555 if (eloop_sock_table_dispatch_table(writers, pollfds_map, 556 max_pollfd_map, POLLOUT)) 557 return; /* pollfds may be invalid at this point */ 558 559 eloop_sock_table_dispatch_table(exceptions, pollfds_map, 560 max_pollfd_map, POLLERR | POLLHUP); 561 } 562 563 #endif /* CONFIG_ELOOP_POLL */ 564 565 #ifdef CONFIG_ELOOP_SELECT 566 567 static void eloop_sock_table_set_fds(struct eloop_sock_table *table, 568 fd_set *fds) 569 { 570 int i; 571 572 FD_ZERO(fds); 573 574 if (table->table == NULL) 575 return; 576 577 for (i = 0; i < table->count; i++) { 578 assert(table->table[i].sock >= 0); 579 FD_SET(table->table[i].sock, fds); 580 } 581 } 582 583 584 static void eloop_sock_table_dispatch(struct eloop_sock_table *table, 585 fd_set *fds) 586 { 587 int i; 588 589 if (table == NULL || table->table == NULL) 590 return; 591 592 table->changed = 0; 593 for (i = 0; i < table->count; i++) { 594 if (FD_ISSET(table->table[i].sock, fds)) { 595 table->table[i].handler(table->table[i].sock, 596 table->table[i].eloop_data, 597 table->table[i].user_data); 598 if (table->changed) 599 break; 600 } 601 } 602 } 603 604 #endif /* CONFIG_ELOOP_SELECT */ 605 606 607 #ifdef CONFIG_ELOOP_EPOLL 608 static void eloop_sock_table_dispatch(struct epoll_event *events, int nfds) 609 { 610 struct eloop_sock *table; 611 int i; 612 613 for (i = 0; i < nfds; i++) { 614 table = &eloop.fd_table[events[i].data.fd]; 615 if (table->handler == NULL) 616 continue; 617 table->handler(table->sock, table->eloop_data, 618 table->user_data); 619 if (eloop.readers.changed || 620 eloop.writers.changed || 621 eloop.exceptions.changed) 622 break; 623 } 624 } 625 #endif /* CONFIG_ELOOP_EPOLL */ 626 627 628 #ifdef CONFIG_ELOOP_KQUEUE 629 630 static void eloop_sock_table_dispatch(struct kevent *events, int nfds) 631 { 632 struct eloop_sock *table; 633 int i; 634 635 for (i = 0; i < nfds; i++) { 636 table = &eloop.fd_table[events[i].ident]; 637 if (table->handler == NULL) 638 continue; 639 table->handler(table->sock, table->eloop_data, 640 table->user_data); 641 if (eloop.readers.changed || 642 eloop.writers.changed || 643 eloop.exceptions.changed) 644 break; 645 } 646 } 647 648 649 static int eloop_sock_table_requeue(struct eloop_sock_table *table) 650 { 651 int i, r; 652 653 r = 0; 654 for (i = 0; i < table->count && table->table; i++) { 655 if (eloop_sock_queue(table->table[i].sock, table->type) == -1) 656 r = -1; 657 } 658 return r; 659 } 660 661 #endif /* CONFIG_ELOOP_KQUEUE */ 662 663 664 int eloop_sock_requeue(void) 665 { 666 int r = 0; 667 668 #ifdef CONFIG_ELOOP_KQUEUE 669 close(eloop.kqueuefd); 670 eloop.kqueuefd = kqueue(); 671 if (eloop.kqueuefd < 0) { 672 wpa_printf(MSG_ERROR, "%s: kqueue failed: %s", 673 __func__, strerror(errno)); 674 return -1; 675 } 676 677 if (eloop_sock_table_requeue(&eloop.readers) < 0) 678 r = -1; 679 if (eloop_sock_table_requeue(&eloop.writers) < 0) 680 r = -1; 681 if (eloop_sock_table_requeue(&eloop.exceptions) < 0) 682 r = -1; 683 #endif /* CONFIG_ELOOP_KQUEUE */ 684 685 return r; 686 } 687 688 689 static void eloop_sock_table_destroy(struct eloop_sock_table *table) 690 { 691 if (table) { 692 int i; 693 for (i = 0; i < table->count && table->table; i++) { 694 wpa_printf(MSG_INFO, "ELOOP: remaining socket: " 695 "sock=%d eloop_data=%p user_data=%p " 696 "handler=%p", 697 table->table[i].sock, 698 table->table[i].eloop_data, 699 table->table[i].user_data, 700 table->table[i].handler); 701 wpa_trace_dump_funcname("eloop unregistered socket " 702 "handler", 703 table->table[i].handler); 704 wpa_trace_dump("eloop sock", &table->table[i]); 705 } 706 os_free(table->table); 707 } 708 } 709 710 711 int eloop_register_read_sock(int sock, eloop_sock_handler handler, 712 void *eloop_data, void *user_data) 713 { 714 return eloop_register_sock(sock, EVENT_TYPE_READ, handler, 715 eloop_data, user_data); 716 } 717 718 719 void eloop_unregister_read_sock(int sock) 720 { 721 eloop_unregister_sock(sock, EVENT_TYPE_READ); 722 } 723 724 725 static struct eloop_sock_table *eloop_get_sock_table(eloop_event_type type) 726 { 727 switch (type) { 728 case EVENT_TYPE_READ: 729 return &eloop.readers; 730 case EVENT_TYPE_WRITE: 731 return &eloop.writers; 732 case EVENT_TYPE_EXCEPTION: 733 return &eloop.exceptions; 734 } 735 736 return NULL; 737 } 738 739 740 int eloop_register_sock(int sock, eloop_event_type type, 741 eloop_sock_handler handler, 742 void *eloop_data, void *user_data) 743 { 744 struct eloop_sock_table *table; 745 746 assert(sock >= 0); 747 table = eloop_get_sock_table(type); 748 return eloop_sock_table_add_sock(table, sock, handler, 749 eloop_data, user_data); 750 } 751 752 753 void eloop_unregister_sock(int sock, eloop_event_type type) 754 { 755 struct eloop_sock_table *table; 756 757 table = eloop_get_sock_table(type); 758 eloop_sock_table_remove_sock(table, sock); 759 } 760 761 762 int eloop_register_timeout(unsigned int secs, unsigned int usecs, 763 eloop_timeout_handler handler, 764 void *eloop_data, void *user_data) 765 { 766 struct eloop_timeout *timeout, *tmp; 767 os_time_t now_sec; 768 769 timeout = os_zalloc(sizeof(*timeout)); 770 if (timeout == NULL) 771 return -1; 772 if (os_get_reltime(&timeout->time) < 0) { 773 os_free(timeout); 774 return -1; 775 } 776 now_sec = timeout->time.sec; 777 timeout->time.sec += secs; 778 if (timeout->time.sec < now_sec) { 779 /* 780 * Integer overflow - assume long enough timeout to be assumed 781 * to be infinite, i.e., the timeout would never happen. 782 */ 783 wpa_printf(MSG_DEBUG, "ELOOP: Too long timeout (secs=%u) to " 784 "ever happen - ignore it", secs); 785 os_free(timeout); 786 return 0; 787 } 788 timeout->time.usec += usecs; 789 while (timeout->time.usec >= 1000000) { 790 timeout->time.sec++; 791 timeout->time.usec -= 1000000; 792 } 793 timeout->eloop_data = eloop_data; 794 timeout->user_data = user_data; 795 timeout->handler = handler; 796 wpa_trace_add_ref(timeout, eloop, eloop_data); 797 wpa_trace_add_ref(timeout, user, user_data); 798 wpa_trace_record(timeout); 799 800 /* Maintain timeouts in order of increasing time */ 801 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) { 802 if (os_reltime_before(&timeout->time, &tmp->time)) { 803 dl_list_add(tmp->list.prev, &timeout->list); 804 return 0; 805 } 806 } 807 dl_list_add_tail(&eloop.timeout, &timeout->list); 808 809 return 0; 810 } 811 812 813 static void eloop_remove_timeout(struct eloop_timeout *timeout) 814 { 815 dl_list_del(&timeout->list); 816 wpa_trace_remove_ref(timeout, eloop, timeout->eloop_data); 817 wpa_trace_remove_ref(timeout, user, timeout->user_data); 818 os_free(timeout); 819 } 820 821 822 int eloop_cancel_timeout(eloop_timeout_handler handler, 823 void *eloop_data, void *user_data) 824 { 825 struct eloop_timeout *timeout, *prev; 826 int removed = 0; 827 828 dl_list_for_each_safe(timeout, prev, &eloop.timeout, 829 struct eloop_timeout, list) { 830 if (timeout->handler == handler && 831 (timeout->eloop_data == eloop_data || 832 eloop_data == ELOOP_ALL_CTX) && 833 (timeout->user_data == user_data || 834 user_data == ELOOP_ALL_CTX)) { 835 eloop_remove_timeout(timeout); 836 removed++; 837 } 838 } 839 840 return removed; 841 } 842 843 844 int eloop_cancel_timeout_one(eloop_timeout_handler handler, 845 void *eloop_data, void *user_data, 846 struct os_reltime *remaining) 847 { 848 struct eloop_timeout *timeout, *prev; 849 int removed = 0; 850 struct os_reltime now; 851 852 os_get_reltime(&now); 853 remaining->sec = remaining->usec = 0; 854 855 dl_list_for_each_safe(timeout, prev, &eloop.timeout, 856 struct eloop_timeout, list) { 857 if (timeout->handler == handler && 858 (timeout->eloop_data == eloop_data) && 859 (timeout->user_data == user_data)) { 860 removed = 1; 861 if (os_reltime_before(&now, &timeout->time)) 862 os_reltime_sub(&timeout->time, &now, remaining); 863 eloop_remove_timeout(timeout); 864 break; 865 } 866 } 867 return removed; 868 } 869 870 871 int eloop_is_timeout_registered(eloop_timeout_handler handler, 872 void *eloop_data, void *user_data) 873 { 874 struct eloop_timeout *tmp; 875 876 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) { 877 if (tmp->handler == handler && 878 tmp->eloop_data == eloop_data && 879 tmp->user_data == user_data) 880 return 1; 881 } 882 883 return 0; 884 } 885 886 887 int eloop_deplete_timeout(unsigned int req_secs, unsigned int req_usecs, 888 eloop_timeout_handler handler, void *eloop_data, 889 void *user_data) 890 { 891 struct os_reltime now, requested, remaining; 892 struct eloop_timeout *tmp; 893 894 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) { 895 if (tmp->handler == handler && 896 tmp->eloop_data == eloop_data && 897 tmp->user_data == user_data) { 898 requested.sec = req_secs; 899 requested.usec = req_usecs; 900 os_get_reltime(&now); 901 os_reltime_sub(&tmp->time, &now, &remaining); 902 if (os_reltime_before(&requested, &remaining)) { 903 eloop_cancel_timeout(handler, eloop_data, 904 user_data); 905 eloop_register_timeout(requested.sec, 906 requested.usec, 907 handler, eloop_data, 908 user_data); 909 return 1; 910 } 911 return 0; 912 } 913 } 914 915 return -1; 916 } 917 918 919 int eloop_replenish_timeout(unsigned int req_secs, unsigned int req_usecs, 920 eloop_timeout_handler handler, void *eloop_data, 921 void *user_data) 922 { 923 struct os_reltime now, requested, remaining; 924 struct eloop_timeout *tmp; 925 926 dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) { 927 if (tmp->handler == handler && 928 tmp->eloop_data == eloop_data && 929 tmp->user_data == user_data) { 930 requested.sec = req_secs; 931 requested.usec = req_usecs; 932 os_get_reltime(&now); 933 os_reltime_sub(&tmp->time, &now, &remaining); 934 if (os_reltime_before(&remaining, &requested)) { 935 eloop_cancel_timeout(handler, eloop_data, 936 user_data); 937 eloop_register_timeout(requested.sec, 938 requested.usec, 939 handler, eloop_data, 940 user_data); 941 return 1; 942 } 943 return 0; 944 } 945 } 946 947 return -1; 948 } 949 950 951 #ifndef CONFIG_NATIVE_WINDOWS 952 static void eloop_handle_alarm(int sig) 953 { 954 wpa_printf(MSG_ERROR, "eloop: could not process SIGINT or SIGTERM in " 955 "two seconds. Looks like there\n" 956 "is a bug that ends up in a busy loop that " 957 "prevents clean shutdown.\n" 958 "Killing program forcefully.\n"); 959 exit(1); 960 } 961 #endif /* CONFIG_NATIVE_WINDOWS */ 962 963 964 static void eloop_handle_signal(int sig) 965 { 966 int i; 967 968 #ifndef CONFIG_NATIVE_WINDOWS 969 if ((sig == SIGINT || sig == SIGTERM) && !eloop.pending_terminate) { 970 /* Use SIGALRM to break out from potential busy loops that 971 * would not allow the program to be killed. */ 972 eloop.pending_terminate = 1; 973 signal(SIGALRM, eloop_handle_alarm); 974 alarm(2); 975 } 976 #endif /* CONFIG_NATIVE_WINDOWS */ 977 978 eloop.signaled++; 979 for (i = 0; i < eloop.signal_count; i++) { 980 if (eloop.signals[i].sig == sig) { 981 eloop.signals[i].signaled++; 982 break; 983 } 984 } 985 } 986 987 988 static void eloop_process_pending_signals(void) 989 { 990 int i; 991 992 if (eloop.signaled == 0) 993 return; 994 eloop.signaled = 0; 995 996 if (eloop.pending_terminate) { 997 #ifndef CONFIG_NATIVE_WINDOWS 998 alarm(0); 999 #endif /* CONFIG_NATIVE_WINDOWS */ 1000 eloop.pending_terminate = 0; 1001 } 1002 1003 for (i = 0; i < eloop.signal_count; i++) { 1004 if (eloop.signals[i].signaled) { 1005 eloop.signals[i].signaled = 0; 1006 eloop.signals[i].handler(eloop.signals[i].sig, 1007 eloop.signals[i].user_data); 1008 } 1009 } 1010 } 1011 1012 1013 int eloop_register_signal(int sig, eloop_signal_handler handler, 1014 void *user_data) 1015 { 1016 struct eloop_signal *tmp; 1017 1018 tmp = os_realloc_array(eloop.signals, eloop.signal_count + 1, 1019 sizeof(struct eloop_signal)); 1020 if (tmp == NULL) 1021 return -1; 1022 1023 tmp[eloop.signal_count].sig = sig; 1024 tmp[eloop.signal_count].user_data = user_data; 1025 tmp[eloop.signal_count].handler = handler; 1026 tmp[eloop.signal_count].signaled = 0; 1027 eloop.signal_count++; 1028 eloop.signals = tmp; 1029 signal(sig, eloop_handle_signal); 1030 1031 return 0; 1032 } 1033 1034 1035 int eloop_register_signal_terminate(eloop_signal_handler handler, 1036 void *user_data) 1037 { 1038 int ret = eloop_register_signal(SIGINT, handler, user_data); 1039 if (ret == 0) 1040 ret = eloop_register_signal(SIGTERM, handler, user_data); 1041 return ret; 1042 } 1043 1044 1045 int eloop_register_signal_reconfig(eloop_signal_handler handler, 1046 void *user_data) 1047 { 1048 #ifdef CONFIG_NATIVE_WINDOWS 1049 return 0; 1050 #else /* CONFIG_NATIVE_WINDOWS */ 1051 return eloop_register_signal(SIGHUP, handler, user_data); 1052 #endif /* CONFIG_NATIVE_WINDOWS */ 1053 } 1054 1055 1056 void eloop_run(void) 1057 { 1058 #ifdef CONFIG_ELOOP_POLL 1059 int num_poll_fds; 1060 int timeout_ms = 0; 1061 #endif /* CONFIG_ELOOP_POLL */ 1062 #ifdef CONFIG_ELOOP_SELECT 1063 fd_set *rfds, *wfds, *efds; 1064 struct timeval _tv; 1065 #endif /* CONFIG_ELOOP_SELECT */ 1066 #ifdef CONFIG_ELOOP_EPOLL 1067 int timeout_ms = -1; 1068 #endif /* CONFIG_ELOOP_EPOLL */ 1069 #ifdef CONFIG_ELOOP_KQUEUE 1070 struct timespec ts; 1071 #endif /* CONFIG_ELOOP_KQUEUE */ 1072 int res; 1073 struct os_reltime tv, now; 1074 1075 #ifdef CONFIG_ELOOP_SELECT 1076 rfds = os_malloc(sizeof(*rfds)); 1077 wfds = os_malloc(sizeof(*wfds)); 1078 efds = os_malloc(sizeof(*efds)); 1079 if (rfds == NULL || wfds == NULL || efds == NULL) 1080 goto out; 1081 #endif /* CONFIG_ELOOP_SELECT */ 1082 1083 while (!eloop.terminate && 1084 (!dl_list_empty(&eloop.timeout) || eloop.readers.count > 0 || 1085 eloop.writers.count > 0 || eloop.exceptions.count > 0)) { 1086 struct eloop_timeout *timeout; 1087 1088 if (eloop.pending_terminate) { 1089 /* 1090 * This may happen in some corner cases where a signal 1091 * is received during a blocking operation. We need to 1092 * process the pending signals and exit if requested to 1093 * avoid hitting the SIGALRM limit if the blocking 1094 * operation took more than two seconds. 1095 */ 1096 eloop_process_pending_signals(); 1097 if (eloop.terminate) 1098 break; 1099 } 1100 1101 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout, 1102 list); 1103 if (timeout) { 1104 os_get_reltime(&now); 1105 if (os_reltime_before(&now, &timeout->time)) 1106 os_reltime_sub(&timeout->time, &now, &tv); 1107 else 1108 tv.sec = tv.usec = 0; 1109 #if defined(CONFIG_ELOOP_POLL) || defined(CONFIG_ELOOP_EPOLL) 1110 timeout_ms = tv.sec * 1000 + tv.usec / 1000; 1111 #endif /* defined(CONFIG_ELOOP_POLL) || defined(CONFIG_ELOOP_EPOLL) */ 1112 #ifdef CONFIG_ELOOP_SELECT 1113 _tv.tv_sec = tv.sec; 1114 _tv.tv_usec = tv.usec; 1115 #endif /* CONFIG_ELOOP_SELECT */ 1116 #ifdef CONFIG_ELOOP_KQUEUE 1117 ts.tv_sec = tv.sec; 1118 ts.tv_nsec = tv.usec * 1000L; 1119 #endif /* CONFIG_ELOOP_KQUEUE */ 1120 } 1121 1122 #ifdef CONFIG_ELOOP_POLL 1123 num_poll_fds = eloop_sock_table_set_fds( 1124 &eloop.readers, &eloop.writers, &eloop.exceptions, 1125 eloop.pollfds, eloop.pollfds_map, 1126 eloop.max_pollfd_map); 1127 res = poll(eloop.pollfds, num_poll_fds, 1128 timeout ? timeout_ms : -1); 1129 #endif /* CONFIG_ELOOP_POLL */ 1130 #ifdef CONFIG_ELOOP_SELECT 1131 eloop_sock_table_set_fds(&eloop.readers, rfds); 1132 eloop_sock_table_set_fds(&eloop.writers, wfds); 1133 eloop_sock_table_set_fds(&eloop.exceptions, efds); 1134 res = select(eloop.max_sock + 1, rfds, wfds, efds, 1135 timeout ? &_tv : NULL); 1136 #endif /* CONFIG_ELOOP_SELECT */ 1137 #ifdef CONFIG_ELOOP_EPOLL 1138 if (eloop.count == 0) { 1139 res = 0; 1140 } else { 1141 res = epoll_wait(eloop.epollfd, eloop.epoll_events, 1142 eloop.count, timeout_ms); 1143 } 1144 #endif /* CONFIG_ELOOP_EPOLL */ 1145 #ifdef CONFIG_ELOOP_KQUEUE 1146 if (eloop.count == 0) { 1147 res = 0; 1148 } else { 1149 res = kevent(eloop.kqueuefd, NULL, 0, 1150 eloop.kqueue_events, eloop.kqueue_nevents, 1151 timeout ? &ts : NULL); 1152 } 1153 #endif /* CONFIG_ELOOP_KQUEUE */ 1154 if (res < 0 && errno != EINTR && errno != 0) { 1155 wpa_printf(MSG_ERROR, "eloop: %s: %s", 1156 #ifdef CONFIG_ELOOP_POLL 1157 "poll" 1158 #endif /* CONFIG_ELOOP_POLL */ 1159 #ifdef CONFIG_ELOOP_SELECT 1160 "select" 1161 #endif /* CONFIG_ELOOP_SELECT */ 1162 #ifdef CONFIG_ELOOP_EPOLL 1163 "epoll" 1164 #endif /* CONFIG_ELOOP_EPOLL */ 1165 #ifdef CONFIG_ELOOP_KQUEUE 1166 "kqueue" 1167 #endif /* CONFIG_ELOOP_EKQUEUE */ 1168 1169 , strerror(errno)); 1170 goto out; 1171 } 1172 1173 eloop.readers.changed = 0; 1174 eloop.writers.changed = 0; 1175 eloop.exceptions.changed = 0; 1176 1177 eloop_process_pending_signals(); 1178 1179 1180 /* check if some registered timeouts have occurred */ 1181 timeout = dl_list_first(&eloop.timeout, struct eloop_timeout, 1182 list); 1183 if (timeout) { 1184 os_get_reltime(&now); 1185 if (!os_reltime_before(&now, &timeout->time)) { 1186 void *eloop_data = timeout->eloop_data; 1187 void *user_data = timeout->user_data; 1188 eloop_timeout_handler handler = 1189 timeout->handler; 1190 eloop_remove_timeout(timeout); 1191 handler(eloop_data, user_data); 1192 } 1193 1194 } 1195 1196 if (res <= 0) 1197 continue; 1198 1199 if (eloop.readers.changed || 1200 eloop.writers.changed || 1201 eloop.exceptions.changed) { 1202 /* 1203 * Sockets may have been closed and reopened with the 1204 * same FD in the signal or timeout handlers, so we 1205 * must skip the previous results and check again 1206 * whether any of the currently registered sockets have 1207 * events. 1208 */ 1209 continue; 1210 } 1211 1212 #ifdef CONFIG_ELOOP_POLL 1213 eloop_sock_table_dispatch(&eloop.readers, &eloop.writers, 1214 &eloop.exceptions, eloop.pollfds_map, 1215 eloop.max_pollfd_map); 1216 #endif /* CONFIG_ELOOP_POLL */ 1217 #ifdef CONFIG_ELOOP_SELECT 1218 eloop_sock_table_dispatch(&eloop.readers, rfds); 1219 eloop_sock_table_dispatch(&eloop.writers, wfds); 1220 eloop_sock_table_dispatch(&eloop.exceptions, efds); 1221 #endif /* CONFIG_ELOOP_SELECT */ 1222 #ifdef CONFIG_ELOOP_EPOLL 1223 eloop_sock_table_dispatch(eloop.epoll_events, res); 1224 #endif /* CONFIG_ELOOP_EPOLL */ 1225 #ifdef CONFIG_ELOOP_KQUEUE 1226 eloop_sock_table_dispatch(eloop.kqueue_events, res); 1227 #endif /* CONFIG_ELOOP_KQUEUE */ 1228 } 1229 1230 eloop.terminate = 0; 1231 out: 1232 #ifdef CONFIG_ELOOP_SELECT 1233 os_free(rfds); 1234 os_free(wfds); 1235 os_free(efds); 1236 #endif /* CONFIG_ELOOP_SELECT */ 1237 return; 1238 } 1239 1240 1241 void eloop_terminate(void) 1242 { 1243 eloop.terminate = 1; 1244 } 1245 1246 1247 void eloop_destroy(void) 1248 { 1249 struct eloop_timeout *timeout, *prev; 1250 struct os_reltime now; 1251 1252 os_get_reltime(&now); 1253 dl_list_for_each_safe(timeout, prev, &eloop.timeout, 1254 struct eloop_timeout, list) { 1255 int sec, usec; 1256 sec = timeout->time.sec - now.sec; 1257 usec = timeout->time.usec - now.usec; 1258 if (timeout->time.usec < now.usec) { 1259 sec--; 1260 usec += 1000000; 1261 } 1262 wpa_printf(MSG_INFO, "ELOOP: remaining timeout: %d.%06d " 1263 "eloop_data=%p user_data=%p handler=%p", 1264 sec, usec, timeout->eloop_data, timeout->user_data, 1265 timeout->handler); 1266 wpa_trace_dump_funcname("eloop unregistered timeout handler", 1267 timeout->handler); 1268 wpa_trace_dump("eloop timeout", timeout); 1269 eloop_remove_timeout(timeout); 1270 } 1271 eloop_sock_table_destroy(&eloop.readers); 1272 eloop_sock_table_destroy(&eloop.writers); 1273 eloop_sock_table_destroy(&eloop.exceptions); 1274 os_free(eloop.signals); 1275 1276 #ifdef CONFIG_ELOOP_POLL 1277 os_free(eloop.pollfds); 1278 os_free(eloop.pollfds_map); 1279 #endif /* CONFIG_ELOOP_POLL */ 1280 #if defined(CONFIG_ELOOP_EPOLL) || defined(CONFIG_ELOOP_KQUEUE) 1281 os_free(eloop.fd_table); 1282 #endif /* CONFIG_ELOOP_EPOLL || CONFIG_ELOOP_KQUEUE */ 1283 #ifdef CONFIG_ELOOP_EPOLL 1284 os_free(eloop.epoll_events); 1285 close(eloop.epollfd); 1286 #endif /* CONFIG_ELOOP_EPOLL */ 1287 #ifdef CONFIG_ELOOP_KQUEUE 1288 os_free(eloop.kqueue_events); 1289 close(eloop.kqueuefd); 1290 #endif /* CONFIG_ELOOP_KQUEUE */ 1291 } 1292 1293 1294 int eloop_terminated(void) 1295 { 1296 return eloop.terminate || eloop.pending_terminate; 1297 } 1298 1299 1300 void eloop_wait_for_read_sock(int sock) 1301 { 1302 #ifdef CONFIG_ELOOP_POLL 1303 struct pollfd pfd; 1304 1305 if (sock < 0) 1306 return; 1307 1308 os_memset(&pfd, 0, sizeof(pfd)); 1309 pfd.fd = sock; 1310 pfd.events = POLLIN; 1311 1312 poll(&pfd, 1, -1); 1313 #endif /* CONFIG_ELOOP_POLL */ 1314 #if defined(CONFIG_ELOOP_SELECT) || defined(CONFIG_ELOOP_EPOLL) 1315 /* 1316 * We can use epoll() here. But epoll() requres 4 system calls. 1317 * epoll_create1(), epoll_ctl() for ADD, epoll_wait, and close() for 1318 * epoll fd. So select() is better for performance here. 1319 */ 1320 fd_set rfds; 1321 1322 if (sock < 0) 1323 return; 1324 1325 FD_ZERO(&rfds); 1326 FD_SET(sock, &rfds); 1327 select(sock + 1, &rfds, NULL, NULL, NULL); 1328 #endif /* defined(CONFIG_ELOOP_SELECT) || defined(CONFIG_ELOOP_EPOLL) */ 1329 #ifdef CONFIG_ELOOP_KQUEUE 1330 int kfd; 1331 struct kevent ke1, ke2; 1332 1333 kfd = kqueue(); 1334 if (kfd == -1) 1335 return; 1336 EV_SET(&ke1, sock, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, 0); 1337 kevent(kfd, &ke1, 1, &ke2, 1, NULL); 1338 close(kfd); 1339 #endif /* CONFIG_ELOOP_KQUEUE */ 1340 } 1341 1342 #ifdef CONFIG_ELOOP_SELECT 1343 #undef CONFIG_ELOOP_SELECT 1344 #endif /* CONFIG_ELOOP_SELECT */ 1345
