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