From 48d42fc2f77879dc1541d8ad3c6cfcba644dbb1b Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Mon, 10 Oct 2011 13:06:10 +0000 Subject: [PATCH] use log from --- src/util/scheduler.c | 857 ++++++++++++++++++++++--------------------- 1 file changed, 440 insertions(+), 417 deletions(-) diff --git a/src/util/scheduler.c b/src/util/scheduler.c index dad924c32..b7860650e 100644 --- a/src/util/scheduler.c +++ b/src/util/scheduler.c @@ -265,7 +265,7 @@ static void *scheduler_select_cls; */ void GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select, - void *new_select_cls) + void *new_select_cls) { scheduler_select = new_select; scheduler_select_cls = new_select_cls; @@ -284,7 +284,7 @@ check_priority (enum GNUNET_SCHEDULER_Priority p) if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT)) return p; GNUNET_assert (0); - return 0; /* make compiler happy */ + return 0; /* make compiler happy */ } @@ -306,37 +306,37 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id) if (id < lowest_pending_id) return GNUNET_NO; - min = -1; /* maximum value */ + min = -1; /* maximum value */ pos = pending; while (pos != NULL) - { - if (pos->id == id) - return GNUNET_YES; - if (pos->id < min) - min = pos->id; - pos = pos->next; - } + { + if (pos->id == id) + return GNUNET_YES; + if (pos->id < min) + min = pos->id; + pos = pos->next; + } pos = pending_timeout; while (pos != NULL) - { - if (pos->id == id) - return GNUNET_YES; - if (pos->id < min) - min = pos->id; - pos = pos->next; - } - for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++) - { - pos = ready[p]; - while (pos != NULL) { if (pos->id == id) - return GNUNET_YES; + return GNUNET_YES; if (pos->id < min) - min = pos->id; + min = pos->id; pos = pos->next; } - } + for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++) + { + pos = ready[p]; + while (pos != NULL) + { + if (pos->id == id) + return GNUNET_YES; + if (pos->id < min) + min = pos->id; + pos = pos->next; + } + } lowest_pending_id = min; return GNUNET_NO; } @@ -351,7 +351,7 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id) */ static void update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws, - struct GNUNET_TIME_Relative *timeout) + struct GNUNET_TIME_Relative *timeout) { struct Task *pos; struct GNUNET_TIME_Absolute now; @@ -360,40 +360,40 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws, now = GNUNET_TIME_absolute_get (); pos = pending_timeout; if (pos != NULL) - { - to = GNUNET_TIME_absolute_get_difference (now, pos->timeout); - if (timeout->rel_value > to.rel_value) - *timeout = to; - if (pos->reason != 0) - *timeout = GNUNET_TIME_UNIT_ZERO; - } + { + to = GNUNET_TIME_absolute_get_difference (now, pos->timeout); + if (timeout->rel_value > to.rel_value) + *timeout = to; + if (pos->reason != 0) + *timeout = GNUNET_TIME_UNIT_ZERO; + } pos = pending; while (pos != NULL) - { - if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) && - (GNUNET_YES == is_pending (pos->prereq_id))) { + if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) && + (GNUNET_YES == is_pending (pos->prereq_id))) + { + pos = pos->next; + continue; + } + if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value) + { + to = GNUNET_TIME_absolute_get_difference (now, pos->timeout); + if (timeout->rel_value > to.rel_value) + *timeout = to; + } + if (pos->read_fd != -1) + GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd); + if (pos->write_fd != -1) + GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd); + if (pos->read_set != NULL) + GNUNET_NETWORK_fdset_add (rs, pos->read_set); + if (pos->write_set != NULL) + GNUNET_NETWORK_fdset_add (ws, pos->write_set); + if (pos->reason != 0) + *timeout = GNUNET_TIME_UNIT_ZERO; pos = pos->next; - continue; } - if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value) - { - to = GNUNET_TIME_absolute_get_difference (now, pos->timeout); - if (timeout->rel_value > to.rel_value) - *timeout = to; - } - if (pos->read_fd != -1) - GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd); - if (pos->write_fd != -1) - GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd); - if (pos->read_set != NULL) - GNUNET_NETWORK_fdset_add (rs, pos->read_set); - if (pos->write_set != NULL) - GNUNET_NETWORK_fdset_add (ws, pos->write_set); - if (pos->reason != 0) - *timeout = GNUNET_TIME_UNIT_ZERO; - pos = pos->next; - } } @@ -408,17 +408,17 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws, */ static int set_overlaps (const struct GNUNET_NETWORK_FDSet *ready, - struct GNUNET_NETWORK_FDSet *want) + struct GNUNET_NETWORK_FDSet *want) { if ((NULL == want) || (NULL == ready)) return GNUNET_NO; if (GNUNET_NETWORK_fdset_overlap (ready, want)) - { - /* copy all over (yes, there maybe unrelated bits, - * but this should not hurt well-written clients) */ - GNUNET_NETWORK_fdset_copy (want, ready); - return GNUNET_YES; - } + { + /* copy all over (yes, there maybe unrelated bits, + * but this should not hurt well-written clients) */ + GNUNET_NETWORK_fdset_copy (want, ready); + return GNUNET_YES; + } return GNUNET_NO; } @@ -435,8 +435,8 @@ set_overlaps (const struct GNUNET_NETWORK_FDSet *ready, */ static int is_ready (struct Task *task, struct GNUNET_TIME_Absolute now, - const struct GNUNET_NETWORK_FDSet *rs, - const struct GNUNET_NETWORK_FDSet *ws) + const struct GNUNET_NETWORK_FDSet *rs, + const struct GNUNET_NETWORK_FDSet *ws) { enum GNUNET_SCHEDULER_Reason reason; @@ -445,25 +445,25 @@ is_ready (struct Task *task, struct GNUNET_TIME_Absolute now, reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) && (((task->read_fd != -1) && - (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, task->read_fd))) || - (set_overlaps (rs, task->read_set)))) + (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, task->read_fd))) + || (set_overlaps (rs, task->read_set)))) reason |= GNUNET_SCHEDULER_REASON_READ_READY; if ((0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) && (((task->write_fd != -1) && - (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd))) + (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd))) || (set_overlaps (ws, task->write_set)))) reason |= GNUNET_SCHEDULER_REASON_WRITE_READY; if (reason == 0) - return GNUNET_NO; /* not ready */ + return GNUNET_NO; /* not ready */ if (task->prereq_id != GNUNET_SCHEDULER_NO_TASK) - { - if (GNUNET_YES == is_pending (task->prereq_id)) { - task->reason = reason; - return GNUNET_NO; /* prereq waiting */ + if (GNUNET_YES == is_pending (task->prereq_id)) + { + task->reason = reason; + return GNUNET_NO; /* prereq waiting */ + } + reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE; } - reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE; - } task->reason = reason; return GNUNET_YES; } @@ -496,7 +496,7 @@ queue_ready_task (struct Task *task) */ static void check_ready (const struct GNUNET_NETWORK_FDSet *rs, - const struct GNUNET_NETWORK_FDSet *ws) + const struct GNUNET_NETWORK_FDSet *ws) { struct Task *pos; struct Task *prev; @@ -507,40 +507,41 @@ check_ready (const struct GNUNET_NETWORK_FDSet *rs, prev = NULL; pos = pending_timeout; while (pos != NULL) - { - next = pos->next; - if (now.abs_value >= pos->timeout.abs_value) - pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; - if (0 == pos->reason) - break; - pending_timeout = next; - if (pending_timeout_last == pos) - pending_timeout_last = NULL; - queue_ready_task (pos); - pos = next; - } + { + next = pos->next; + if (now.abs_value >= pos->timeout.abs_value) + pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; + if (0 == pos->reason) + break; + pending_timeout = next; + if (pending_timeout_last == pos) + pending_timeout_last = NULL; + queue_ready_task (pos); + pos = next; + } pos = pending; while (pos != NULL) - { + { #if DEBUG_TASKS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Checking readiness of task: %llu / %p\n", pos->id, - pos->callback_cls); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Checking readiness of task: %llu / %p\n", pos->id, + pos->callback_cls); #endif - next = pos->next; - if (GNUNET_YES == is_ready (pos, now, rs, ws)) - { - if (prev == NULL) - pending = next; - else - prev->next = next; - queue_ready_task (pos); + next = pos->next; + if (GNUNET_YES == is_ready (pos, now, rs, ws)) + { + if (prev == NULL) + pending = next; + else + prev->next = next; + queue_ready_task (pos); + pos = next; + continue; + } + prev = pos; pos = next; - continue; } - prev = pos; - pos = next; - } } @@ -559,26 +560,15 @@ GNUNET_SCHEDULER_shutdown () pos = pending_timeout; while (pos != NULL) - { - pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; - /* we don't move the task into the ready queue yet; check_ready - * will do that later, possibly adding additional - * readiness-factors */ - pos = pos->next; - } + { + pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; + /* we don't move the task into the ready queue yet; check_ready + * will do that later, possibly adding additional + * readiness-factors */ + pos = pos->next; + } pos = pending; while (pos != NULL) - { - pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; - /* we don't move the task into the ready queue yet; check_ready - * will do that later, possibly adding additional - * readiness-factors */ - pos = pos->next; - } - for (i = 0; i < GNUNET_SCHEDULER_PRIORITY_COUNT; i++) - { - pos = ready[i]; - while (pos != NULL) { pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; /* we don't move the task into the ready queue yet; check_ready @@ -586,7 +576,18 @@ GNUNET_SCHEDULER_shutdown () * readiness-factors */ pos = pos->next; } - } + for (i = 0; i < GNUNET_SCHEDULER_PRIORITY_COUNT; i++) + { + pos = ready[i]; + while (pos != NULL) + { + pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; + /* we don't move the task into the ready queue yet; check_ready + * will do that later, possibly adding additional + * readiness-factors */ + pos = pos->next; + } + } } @@ -628,69 +629,74 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws) max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP; do - { - if (ready_count == 0) - return; - GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL); - /* yes, p>0 is correct, 0 is "KEEP" which should - * always be an empty queue (see assertion)! */ - for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--) { - pos = ready[p]; - if (pos != NULL) - break; - } - GNUNET_assert (pos != NULL); /* ready_count wrong? */ - ready[p] = pos->next; - ready_count--; - if (current_priority != pos->priority) - { - current_priority = pos->priority; - (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (), - pos->priority); - } - current_lifeness = pos->lifeness; - active_task = pos; + if (ready_count == 0) + return; + GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL); + /* yes, p>0 is correct, 0 is "KEEP" which should + * always be an empty queue (see assertion)! */ + for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--) + { + pos = ready[p]; + if (pos != NULL) + break; + } + GNUNET_assert (pos != NULL); /* ready_count wrong? */ + ready[p] = pos->next; + ready_count--; + if (current_priority != pos->priority) + { + current_priority = pos->priority; + (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (), + pos->priority); + } + current_lifeness = pos->lifeness; + active_task = pos; #if PROFILE_DELAYS - if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value > - DELAY_THRESHOLD.rel_value) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Task %llu took %llums to be scheduled\n", pos->id, - (unsigned long long) - GNUNET_TIME_absolute_get_duration - (pos->start_time).rel_value); - } + if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value > + DELAY_THRESHOLD.rel_value) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "util", + "Task %llu took %llums to be scheduled\n", pos->id, + (unsigned long long) + GNUNET_TIME_absolute_get_duration + (pos->start_time).rel_value); + } #endif - tc.reason = pos->reason; - tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set; - if ((pos->read_fd != -1) && - (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY))) - GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd); - tc.write_ready = (pos->write_set == NULL) ? ws : pos->write_set; - if ((pos->write_fd != -1) && - (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY))) - GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd); - if (((tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY) != 0) && - (pos->write_fd != -1) && - (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd))) - abort (); // added to ready in previous select loop! + tc.reason = pos->reason; + tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set; + if ((pos->read_fd != -1) && + (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY))) + GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd); + tc.write_ready = (pos->write_set == NULL) ? ws : pos->write_set; + if ((pos->write_fd != -1) && + (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY))) + GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd); + if (((tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY) != 0) && + (pos->write_fd != -1) && + (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd))) + abort (); // added to ready in previous select loop! #if DEBUG_TASKS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running task: %llu / %p\n", pos->id, - pos->callback_cls); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Running task: %llu / %p\n", pos->id, + pos->callback_cls); #endif - pos->callback (pos->callback_cls, &tc); + pos->callback (pos->callback_cls, &tc); #if EXECINFO - int i; + int i; - for (i = 0; i < pos->num_backtrace_strings; i++) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Task %llu trace %d: %s\n", pos->id, - i, pos->backtrace_strings[i]); + for (i = 0; i < pos->num_backtrace_strings; i++) + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "util", + "Task %llu trace %d: %s\n", pos->id, + i, pos->backtrace_strings[i]); #endif - active_task = NULL; - destroy_task (pos); - tasks_run++; - } + active_task = NULL; + destroy_task (pos); + tasks_run++; + } while ((pending == NULL) || (p >= max_priority_added)); } @@ -716,11 +722,11 @@ static void sighandler_shutdown () { static char c; - int old_errno = errno; /* backup errno */ + int old_errno = errno; /* backup errno */ GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle - (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE), - &c, sizeof (c)); + (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE), + &c, sizeof (c)); errno = old_errno; } @@ -746,10 +752,10 @@ check_lifeness () if (t->lifeness == GNUNET_YES) return GNUNET_OK; if ((NULL != pending) || (NULL != pending_timeout)) - { - GNUNET_SCHEDULER_shutdown (); - return GNUNET_OK; - } + { + GNUNET_SCHEDULER_shutdown (); + return GNUNET_OK; + } return GNUNET_NO; } @@ -795,7 +801,7 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls) shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO); GNUNET_assert (shutdown_pipe_handle != NULL); pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle, - GNUNET_DISK_PIPE_END_READ); + GNUNET_DISK_PIPE_END_READ); GNUNET_assert (pr != NULL); shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown); shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown); @@ -807,77 +813,79 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls) current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT; current_lifeness = GNUNET_YES; GNUNET_SCHEDULER_add_continuation (task, task_cls, - GNUNET_SCHEDULER_REASON_STARTUP); + GNUNET_SCHEDULER_REASON_STARTUP); #if ENABLE_WINDOWS_WORKAROUNDS - active_task = (void *) (long) -1; /* force passing of sanity check */ + active_task = (void *) (long) -1; /* force passing of sanity check */ GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO, - &GNUNET_OS_install_parent_control_handler, - NULL); + &GNUNET_OS_install_parent_control_handler, + NULL); active_task = NULL; #endif last_tr = 0; busy_wait_warning = 0; while (GNUNET_OK == check_lifeness ()) - { - GNUNET_NETWORK_fdset_zero (rs); - GNUNET_NETWORK_fdset_zero (ws); - timeout = GNUNET_TIME_UNIT_FOREVER_REL; - update_sets (rs, ws, &timeout); - GNUNET_NETWORK_fdset_handle_set (rs, pr); - if (ready_count > 0) - { - /* no blocking, more work already ready! */ - timeout = GNUNET_TIME_UNIT_ZERO; - } - if (NULL == scheduler_select) - ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout); - else - ret = scheduler_select (scheduler_select_cls, rs, ws, NULL, timeout); - if (ret == GNUNET_SYSERR) { - if (errno == EINTR) - continue; - - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select"); + GNUNET_NETWORK_fdset_zero (rs); + GNUNET_NETWORK_fdset_zero (ws); + timeout = GNUNET_TIME_UNIT_FOREVER_REL; + update_sets (rs, ws, &timeout); + GNUNET_NETWORK_fdset_handle_set (rs, pr); + if (ready_count > 0) + { + /* no blocking, more work already ready! */ + timeout = GNUNET_TIME_UNIT_ZERO; + } + if (NULL == scheduler_select) + ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout); + else + ret = scheduler_select (scheduler_select_cls, rs, ws, NULL, timeout); + if (ret == GNUNET_SYSERR) + { + if (errno == EINTR) + continue; + + GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_ERROR, "util", + "select"); #ifndef MINGW #if USE_LSOF - char lsof[512]; - - snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ()); - (void) close (1); - (void) dup2 (2, 1); - if (0 != system (lsof)) - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "system"); + char lsof[512]; + + snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ()); + (void) close (1); + (void) dup2 (2, 1); + if (0 != system (lsof)) + GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_WARNING, "util", + "system"); #endif #endif - abort (); - break; - } - if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16)) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Looks like we're busy waiting...\n")); - sleep (1); /* mitigate */ - } - check_ready (rs, ws); - run_ready (rs, ws); - if (GNUNET_NETWORK_fdset_handle_isset (rs, pr)) - { - /* consume the signal */ - GNUNET_DISK_file_read (pr, &c, sizeof (c)); - /* mark all active tasks as ready due to shutdown */ - GNUNET_SCHEDULER_shutdown (); - } - if (last_tr == tasks_run) - { - busy_wait_warning++; - } - else - { - last_tr = tasks_run; - busy_wait_warning = 0; + abort (); + break; + } + if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16)) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, + "util", _("Looks like we're busy waiting...\n")); + sleep (1); /* mitigate */ + } + check_ready (rs, ws); + run_ready (rs, ws); + if (GNUNET_NETWORK_fdset_handle_isset (rs, pr)) + { + /* consume the signal */ + GNUNET_DISK_file_read (pr, &c, sizeof (c)); + /* mark all active tasks as ready due to shutdown */ + GNUNET_SCHEDULER_shutdown (); + } + if (last_tr == tasks_run) + { + busy_wait_warning++; + } + else + { + last_tr = tasks_run; + busy_wait_warning = 0; + } } - } GNUNET_SIGNAL_handler_uninstall (shc_int); GNUNET_SIGNAL_handler_uninstall (shc_term); #ifndef MINGW @@ -930,10 +938,10 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p) ret = 0; pos = ready[check_priority (p)]; while (pos != NULL) - { - pos = pos->next; - ret++; - } + { + pos = pos->next; + ret++; + } return ret; } @@ -959,77 +967,79 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task) prev = NULL; t = pending; while (t != NULL) - { - if (t->id == task) - break; - prev = t; - t = t->next; - } - if (t == NULL) - { - prev = NULL; - to = 1; - t = pending_timeout; - while (t != NULL) { if (t->id == task) - break; + break; prev = t; t = t->next; } - if (pending_timeout_last == t) - pending_timeout_last = NULL; - } - p = 0; - while (t == NULL) - { - p++; - if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT) + if (t == NULL) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("Attempt to cancel dead task %llu!\n"), - (unsigned long long) task); - GNUNET_assert (0); + prev = NULL; + to = 1; + t = pending_timeout; + while (t != NULL) + { + if (t->id == task) + break; + prev = t; + t = t->next; + } + if (pending_timeout_last == t) + pending_timeout_last = NULL; } - prev = NULL; - t = ready[p]; - while (t != NULL) + p = 0; + while (t == NULL) { - if (t->id == task) - { - ready_count--; - break; - } - prev = t; - t = t->next; + p++; + if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "util", + _("Attempt to cancel dead task %llu!\n"), + (unsigned long long) task); + GNUNET_assert (0); + } + prev = NULL; + t = ready[p]; + while (t != NULL) + { + if (t->id == task) + { + ready_count--; + break; + } + prev = t; + t = t->next; + } } - } if (prev == NULL) - { - if (p == 0) { - if (to == 0) - { - pending = t->next; - } + if (p == 0) + { + if (to == 0) + { + pending = t->next; + } + else + { + pending_timeout = t->next; + } + } else - { - pending_timeout = t->next; - } + { + ready[p] = t->next; + } } - else + else { - ready[p] = t->next; + prev->next = t->next; } - } - else - { - prev->next = t->next; - } ret = t->callback_cls; #if DEBUG_TASKS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task, - t->callback_cls); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Canceling task: %llu / %p\n", task, t->callback_cls); #endif destroy_task (t); return ret; @@ -1047,7 +1057,7 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task) */ void GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, - enum GNUNET_SCHEDULER_Reason reason) + enum GNUNET_SCHEDULER_Reason reason) { struct Task *t; @@ -1057,12 +1067,12 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, GNUNET_assert (NULL != task); GNUNET_assert ((active_task != NULL) || - (reason == GNUNET_SCHEDULER_REASON_STARTUP)); + (reason == GNUNET_SCHEDULER_REASON_STARTUP)); t = GNUNET_malloc (sizeof (struct Task)); #if EXECINFO t->num_backtrace_strings = backtrace (backtrace_array, 50); t->backtrace_strings = - backtrace_symbols (backtrace_array, t->num_backtrace_strings); + backtrace_symbols (backtrace_array, t->num_backtrace_strings); #endif t->read_fd = -1; t->write_fd = -1; @@ -1076,8 +1086,10 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, t->priority = current_priority; t->lifeness = current_lifeness; #if DEBUG_TASKS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n", - t->id, t->callback_cls); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Adding continuation task: %llu / %p\n", + t->id, t->callback_cls); #endif queue_ready_task (t); } @@ -1102,11 +1114,12 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, - GNUNET_SCHEDULER_Task task, void *task_cls) + GNUNET_SCHEDULER_Task task, void *task_cls) { return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, - prerequisite_task, GNUNET_TIME_UNIT_ZERO, - NULL, NULL, task, task_cls); + prerequisite_task, + GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, + task_cls); } @@ -1121,11 +1134,12 @@ GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, - GNUNET_SCHEDULER_Task task, void *task_cls) + GNUNET_SCHEDULER_Task task, + void *task_cls) { return GNUNET_SCHEDULER_add_select (prio, GNUNET_SCHEDULER_NO_TASK, - GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, - task_cls); + GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, + task_cls); } @@ -1144,7 +1158,7 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, - GNUNET_SCHEDULER_Task task, void *task_cls) + GNUNET_SCHEDULER_Task task, void *task_cls) { #if 1 /* new, optimized version */ @@ -1164,7 +1178,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, #if EXECINFO t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH); t->backtrace_strings = - backtrace_symbols (backtrace_array, t->num_backtrace_strings); + backtrace_symbols (backtrace_array, t->num_backtrace_strings); #endif t->read_fd = -1; t->write_fd = -1; @@ -1179,24 +1193,24 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, * appending to a long list of tasks with timeouts) */ prev = pending_timeout_last; if (prev != NULL) - { - if (prev->timeout.abs_value > t->timeout.abs_value) - prev = NULL; - else - pos = prev->next; /* heuristic success! */ - } + { + if (prev->timeout.abs_value > t->timeout.abs_value) + prev = NULL; + else + pos = prev->next; /* heuristic success! */ + } if (prev == NULL) - { - /* heuristic failed, do traversal of timeout list */ - pos = pending_timeout; - } + { + /* heuristic failed, do traversal of timeout list */ + pos = pending_timeout; + } while ((pos != NULL) && - ((pos->timeout.abs_value <= t->timeout.abs_value) || - (pos->reason != 0))) - { - prev = pos; - pos = pos->next; - } + ((pos->timeout.abs_value <= t->timeout.abs_value) || + (pos->reason != 0))) + { + prev = pos; + pos = pos->next; + } if (prev == NULL) pending_timeout = t; else @@ -1206,23 +1220,26 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, pending_timeout_last = t; #if DEBUG_TASKS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id, - t->callback_cls); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Adding task: %llu / %p\n", t->id, t->callback_cls); #endif #if EXECINFO int i; for (i = 0; i < t->num_backtrace_strings; i++) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i, - t->backtrace_strings[i]); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Task %llu trace %d: %s\n", t->id, i, + t->backtrace_strings[i]); #endif return t->id; #else /* unoptimized version */ return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, - GNUNET_SCHEDULER_NO_TASK, delay, NULL, - NULL, task, task_cls); + GNUNET_SCHEDULER_NO_TASK, delay, NULL, + NULL, task, task_cls); #endif } @@ -1241,9 +1258,9 @@ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls) { return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, - GNUNET_SCHEDULER_NO_TASK, - GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, - task_cls); + GNUNET_SCHEDULER_NO_TASK, + GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, + task_cls); } @@ -1263,16 +1280,16 @@ GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls) */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, - GNUNET_SCHEDULER_Task task, - void *task_cls) + GNUNET_SCHEDULER_Task task, + void *task_cls) { GNUNET_SCHEDULER_TaskIdentifier ret; ret = - GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, - GNUNET_SCHEDULER_NO_TASK, - GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, - task_cls); + GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_NO_TASK, + GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, + task_cls); GNUNET_assert (pending->id == ret); pending->lifeness = lifeness; return ret; @@ -1310,7 +1327,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, #ifndef MINGW GNUNET_SCHEDULER_TaskIdentifier add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd, - GNUNET_SCHEDULER_Task task, void *task_cls) + GNUNET_SCHEDULER_Task task, void *task_cls) { struct Task *t; @@ -1326,45 +1343,45 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd, #if EXECINFO t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH); t->backtrace_strings = - backtrace_symbols (backtrace_array, t->num_backtrace_strings); + backtrace_symbols (backtrace_array, t->num_backtrace_strings); #endif #if DEBUG_FDS if (-1 != rfd) - { - int flags = fcntl (rfd, F_GETFD); - - if (flags == -1 && errno == EBADF) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", - rfd); + int flags = fcntl (rfd, F_GETFD); + + if ((flags == -1) && (errno == EBADF)) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "util", "Got invalid file descriptor %d!\n", rfd); #if EXECINFO - int i; + int i; - for (i = 0; i < t->num_backtrace_strings; i++) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", - t->backtrace_strings[i]); + for (i = 0; i < t->num_backtrace_strings; i++) + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", "Trace: %s\n", t->backtrace_strings[i]); #endif - GNUNET_assert (0); + GNUNET_assert (0); + } } - } if (-1 != wfd) - { - int flags = fcntl (wfd, F_GETFD); - - if (flags == -1 && errno == EBADF) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", - wfd); + int flags = fcntl (wfd, F_GETFD); + + if (flags == -1 && errno == EBADF) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "util", "Got invalid file descriptor %d!\n", wfd); #if EXECINFO - int i; + int i; - for (i = 0; i < t->num_backtrace_strings; i++) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", - t->backtrace_strings[i]); + for (i = 0; i < t->num_backtrace_strings; i++) + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", "Trace: %s\n", t->backtrace_strings[i]); #endif - GNUNET_assert (0); + GNUNET_assert (0); + } } - } #endif t->read_fd = rfd; GNUNET_assert (wfd >= -1); @@ -1381,15 +1398,17 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd, pending = t; max_priority_added = GNUNET_MAX (max_priority_added, t->priority); #if DEBUG_TASKS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id, - t->callback_cls); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Adding task: %llu / %p\n", t->id, t->callback_cls); #endif #if EXECINFO int i; for (i = 0; i < t->num_backtrace_strings; i++) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i, - t->backtrace_strings[i]); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "util", + "Task %llu trace %d: %s\n", t->id, i, + t->backtrace_strings[i]); #endif return t->id; } @@ -1415,8 +1434,8 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, - struct GNUNET_NETWORK_Handle *rfd, - GNUNET_SCHEDULER_Task task, void *task_cls) + struct GNUNET_NETWORK_Handle * rfd, + GNUNET_SCHEDULER_Task task, void *task_cls) { #if MINGW struct GNUNET_NETWORK_FDSet *rs; @@ -1426,14 +1445,14 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, rs = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_set (rs, rfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), - GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL, - task, task_cls); + GNUNET_SCHEDULER_add_select (check_priority (current_priority), + GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL, + task, task_cls); GNUNET_NETWORK_fdset_destroy (rs); return ret; #else return add_without_sets (delay, GNUNET_NETWORK_get_fd (rfd), -1, task, - task_cls); + task_cls); #endif } @@ -1456,8 +1475,8 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, - struct GNUNET_NETWORK_Handle *wfd, - GNUNET_SCHEDULER_Task task, void *task_cls) + struct GNUNET_NETWORK_Handle * wfd, + GNUNET_SCHEDULER_Task task, void *task_cls) { #if MINGW struct GNUNET_NETWORK_FDSet *ws; @@ -1467,15 +1486,15 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, ws = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_set (ws, wfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), - GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws, - task, task_cls); + GNUNET_SCHEDULER_add_select (check_priority (current_priority), + GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws, + task, task_cls); GNUNET_NETWORK_fdset_destroy (ws); return ret; #else GNUNET_assert (GNUNET_NETWORK_get_fd (wfd) >= 0); return add_without_sets (delay, -1, GNUNET_NETWORK_get_fd (wfd), task, - task_cls); + task_cls); #endif } @@ -1498,8 +1517,8 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, - const struct GNUNET_DISK_FileHandle *rfd, - GNUNET_SCHEDULER_Task task, void *task_cls) + const struct GNUNET_DISK_FileHandle * rfd, + GNUNET_SCHEDULER_Task task, void *task_cls) { #if MINGW struct GNUNET_NETWORK_FDSet *rs; @@ -1509,9 +1528,9 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, rs = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_handle_set (rs, rfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), - GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL, - task, task_cls); + GNUNET_SCHEDULER_add_select (check_priority (current_priority), + GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL, + task, task_cls); GNUNET_NETWORK_fdset_destroy (rs); return ret; #else @@ -1542,8 +1561,8 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, - const struct GNUNET_DISK_FileHandle *wfd, - GNUNET_SCHEDULER_Task task, void *task_cls) + const struct GNUNET_DISK_FileHandle * wfd, + GNUNET_SCHEDULER_Task task, void *task_cls) { #if MINGW struct GNUNET_NETWORK_FDSet *ws; @@ -1553,9 +1572,9 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, ws = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_handle_set (ws, wfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), - GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws, - task, task_cls); + GNUNET_SCHEDULER_add_select (check_priority (current_priority), + GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws, + task, task_cls); GNUNET_NETWORK_fdset_destroy (ws); return ret; #else @@ -1604,11 +1623,12 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, */ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio, - GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, - struct GNUNET_TIME_Relative delay, - const struct GNUNET_NETWORK_FDSet *rs, - const struct GNUNET_NETWORK_FDSet *ws, - GNUNET_SCHEDULER_Task task, void *task_cls) + GNUNET_SCHEDULER_TaskIdentifier + prerequisite_task, + struct GNUNET_TIME_Relative delay, + const struct GNUNET_NETWORK_FDSet * rs, + const struct GNUNET_NETWORK_FDSet * ws, + GNUNET_SCHEDULER_Task task, void *task_cls) { struct Task *t; @@ -1624,20 +1644,20 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio, #if EXECINFO t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH); t->backtrace_strings = - backtrace_symbols (backtrace_array, t->num_backtrace_strings); + backtrace_symbols (backtrace_array, t->num_backtrace_strings); #endif t->read_fd = -1; t->write_fd = -1; if (rs != NULL) - { - t->read_set = GNUNET_NETWORK_fdset_create (); - GNUNET_NETWORK_fdset_copy (t->read_set, rs); - } + { + t->read_set = GNUNET_NETWORK_fdset_create (); + GNUNET_NETWORK_fdset_copy (t->read_set, rs); + } if (ws != NULL) - { - t->write_set = GNUNET_NETWORK_fdset_create (); - GNUNET_NETWORK_fdset_copy (t->write_set, ws); - } + { + t->write_set = GNUNET_NETWORK_fdset_create (); + GNUNET_NETWORK_fdset_copy (t->write_set, ws); + } t->id = ++last_id; #if PROFILE_DELAYS t->start_time = GNUNET_TIME_absolute_get (); @@ -1645,23 +1665,26 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio, t->prereq_id = prerequisite_task; t->timeout = GNUNET_TIME_relative_to_absolute (delay); t->priority = - check_priority ((prio == - GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : - prio); + check_priority ((prio == + GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : + prio); t->lifeness = current_lifeness; t->next = pending; pending = t; max_priority_added = GNUNET_MAX (max_priority_added, t->priority); #if DEBUG_TASKS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id, - t->callback_cls); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Adding task: %llu / %p\n", t->id, t->callback_cls); #endif #if EXECINFO int i; for (i = 0; i < t->num_backtrace_strings; i++) - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i, - t->backtrace_strings[i]); + GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, + "util", + "Task %llu trace %d: %s\n", t->id, i, + t->backtrace_strings[i]); #endif return t->id; } -- 2.25.1