jeltz/hostap
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

eloop: Use struct dl_list for timeouts

Browse source
This commit is contained in:
Jouni Malinen 2009-12-19 20:26:22 +02:00
parent 0456ea16d8
commit eaa3f04b97
1 changed files with 44 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

115
src/utils/eloop.c
View file

@ -16,6 +16,7 @@
#include "common.h" #include "common.h"
#include "trace.h" #include "trace.h"
#include "list.h"
#include "eloop.h" #include "eloop.h"
@ -28,11 +29,11 @@ struct eloop_sock {
}; };
struct eloop_timeout { struct eloop_timeout {
struct dl_list list;
struct os_time time; struct os_time time;
void *eloop_data; void *eloop_data;
void *user_data; void *user_data;
eloop_timeout_handler handler; eloop_timeout_handler handler;
struct eloop_timeout *next;
WPA_TRACE_INFO WPA_TRACE_INFO
}; };
@ -56,7 +57,7 @@ struct eloop_data {
struct eloop_sock_table writers; struct eloop_sock_table writers;
struct eloop_sock_table exceptions; struct eloop_sock_table exceptions;
struct eloop_timeout *timeout; struct dl_list timeout;
int signal_count; int signal_count;
struct eloop_signal *signals; struct eloop_signal *signals;
@ -82,6 +83,7 @@ static void eloop_sigsegv_handler(int sig)
int eloop_init(void) int eloop_init(void)
{ {
os_memset(&eloop, 0, sizeof(eloop)); os_memset(&eloop, 0, sizeof(eloop));
dl_list_init(&eloop.timeout);
#ifdef WPA_TRACE #ifdef WPA_TRACE
signal(SIGSEGV, eloop_sigsegv_handler); signal(SIGSEGV, eloop_sigsegv_handler);
#endif /* WPA_TRACE */ #endif /* WPA_TRACE */
@ -251,7 +253,7 @@ int eloop_register_timeout(unsigned int secs, unsigned int usecs,
eloop_timeout_handler handler, eloop_timeout_handler handler,
void *eloop_data, void *user_data) void *eloop_data, void *user_data)
{ {
struct eloop_timeout *timeout, *tmp, *prev; struct eloop_timeout *timeout, *tmp;
timeout = os_malloc(sizeof(*timeout)); timeout = os_malloc(sizeof(*timeout));
if (timeout == NULL) if (timeout == NULL)
@ -269,30 +271,16 @@ int eloop_register_timeout(unsigned int secs, unsigned int usecs,
timeout->eloop_data = eloop_data; timeout->eloop_data = eloop_data;
timeout->user_data = user_data; timeout->user_data = user_data;
timeout->handler = handler; timeout->handler = handler;
timeout->next = NULL;
wpa_trace_record(timeout); wpa_trace_record(timeout);
if (eloop.timeout == NULL) { /* Maintain timeouts in order of increasing time */
eloop.timeout = timeout; dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
return 0; if (os_time_before(&timeout->time, &tmp->time)) {
} dl_list_add(tmp->list.prev, &timeout->list);
return 0;
prev = NULL; }
tmp = eloop.timeout;
while (tmp != NULL) {
if (os_time_before(&timeout->time, &tmp->time))
break;
prev = tmp;
tmp = tmp->next;
}
if (prev == NULL) {
timeout->next = eloop.timeout;
eloop.timeout = timeout;
} else {
timeout->next = prev->next;
prev->next = timeout;
} }
dl_list_add_tail(&eloop.timeout, &timeout->list);
return 0; return 0;
} }
@ -301,29 +289,20 @@ int eloop_register_timeout(unsigned int secs, unsigned int usecs,
int eloop_cancel_timeout(eloop_timeout_handler handler, int eloop_cancel_timeout(eloop_timeout_handler handler,
void *eloop_data, void *user_data) void *eloop_data, void *user_data)
{ {
struct eloop_timeout *timeout, *prev, *next; struct eloop_timeout *timeout, *prev;
int removed = 0; int removed = 0;
prev = NULL; dl_list_for_each_safe(timeout, prev, &eloop.timeout,
timeout = eloop.timeout; struct eloop_timeout, list) {
while (timeout != NULL) {
next = timeout->next;
if (timeout->handler == handler && if (timeout->handler == handler &&
(timeout->eloop_data == eloop_data || (timeout->eloop_data == eloop_data ||
eloop_data == ELOOP_ALL_CTX) && eloop_data == ELOOP_ALL_CTX) &&
(timeout->user_data == user_data || (timeout->user_data == user_data ||
user_data == ELOOP_ALL_CTX)) { user_data == ELOOP_ALL_CTX)) {
if (prev == NULL) dl_list_del(&timeout->list);
eloop.timeout = next;
else
prev->next = next;
os_free(timeout); os_free(timeout);
removed++; removed++;
} else }
prev = timeout;
timeout = next;
} }
return removed; return removed;
@ -335,14 +314,11 @@ int eloop_is_timeout_registered(eloop_timeout_handler handler,
{ {
struct eloop_timeout *tmp; struct eloop_timeout *tmp;
tmp = eloop.timeout; dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) {
while (tmp != NULL) {
if (tmp->handler == handler && if (tmp->handler == handler &&
tmp->eloop_data == eloop_data && tmp->eloop_data == eloop_data &&
tmp->user_data == user_data) tmp->user_data == user_data)
return 1; return 1;
tmp = tmp->next;
} }
return 0; return 0;
@ -472,12 +448,15 @@ void eloop_run(void)
} }
while (!eloop.terminate && while (!eloop.terminate &&
(eloop.timeout || eloop.readers.count > 0 || (!dl_list_empty(&eloop.timeout) || eloop.readers.count > 0 ||
eloop.writers.count > 0 || eloop.exceptions.count > 0)) { eloop.writers.count > 0 || eloop.exceptions.count > 0)) {
if (eloop.timeout) { struct eloop_timeout *timeout;
timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
list);
if (timeout) {
os_get_time(&now); os_get_time(&now);
if (os_time_before(&now, &eloop.timeout->time)) if (os_time_before(&now, &timeout->time))
os_time_sub(&eloop.timeout->time, &now, &tv); os_time_sub(&timeout->time, &now, &tv);
else else
tv.sec = tv.usec = 0; tv.sec = tv.usec = 0;
#if 0 #if 0
@ -492,7 +471,7 @@ void eloop_run(void)
eloop_sock_table_set_fds(&eloop.writers, wfds); eloop_sock_table_set_fds(&eloop.writers, wfds);
eloop_sock_table_set_fds(&eloop.exceptions, efds); eloop_sock_table_set_fds(&eloop.exceptions, efds);
res = select(eloop.max_sock + 1, rfds, wfds, efds, res = select(eloop.max_sock + 1, rfds, wfds, efds,
eloop.timeout ? &_tv : NULL); timeout ? &_tv : NULL);
if (res < 0 && errno != EINTR && errno != 0) { if (res < 0 && errno != EINTR && errno != 0) {
perror("select"); perror("select");
goto out; goto out;
@ -500,16 +479,13 @@ void eloop_run(void)
eloop_process_pending_signals(); eloop_process_pending_signals();
/* check if some registered timeouts have occurred */ /* check if some registered timeouts have occurred */
if (eloop.timeout) { if (timeout) {
struct eloop_timeout *tmp;
os_get_time(&now); os_get_time(&now);
if (!os_time_before(&now, &eloop.timeout->time)) { if (!os_time_before(&now, &timeout->time)) {
tmp = eloop.timeout; dl_list_del(&timeout->list);
eloop.timeout = eloop.timeout->next; timeout->handler(timeout->eloop_data,
tmp->handler(tmp->eloop_data, timeout->user_data);
tmp->user_data); os_free(timeout);
os_free(tmp);
} }
} }
@ -540,25 +516,22 @@ void eloop_destroy(void)
struct eloop_timeout *timeout, *prev; struct eloop_timeout *timeout, *prev;
struct os_time now; struct os_time now;
timeout = eloop.timeout; os_get_time(&now);
if (timeout) dl_list_for_each_safe(timeout, prev, &eloop.timeout,
os_get_time(&now); struct eloop_timeout, list) {
while (timeout != NULL) {
int sec, usec; int sec, usec;
prev = timeout; sec = timeout->time.sec - now.sec;
timeout = timeout->next; usec = timeout->time.usec - now.usec;
sec = prev->time.sec - now.sec; if (timeout->time.usec < now.usec) {
usec = prev->time.usec - now.usec;
if (prev->time.usec < now.usec) {
sec--; sec--;
usec += 1000000; usec += 1000000;
} }
printf("ELOOP: remaining timeout: %d.%06d eloop_data=%p " wpa_printf(MSG_INFO, "ELOOP: remaining timeout: %d.%06d "
"user_data=%p handler=%p\n", "eloop_data=%p user_data=%p handler=%p",
sec, usec, prev->eloop_data, prev->user_data, sec, usec, timeout->eloop_data, timeout->user_data,
prev->handler); timeout->handler);
wpa_trace_dump("eloop timeout", prev); wpa_trace_dump("eloop timeout", timeout);
os_free(prev); os_free(timeout);
} }
eloop_sock_table_destroy(&eloop.readers); eloop_sock_table_destroy(&eloop.readers);
eloop_sock_table_destroy(&eloop.writers); eloop_sock_table_destroy(&eloop.writers);