aboutsummaryrefslogtreecommitdiff
path: root/src/util/scheduler.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/scheduler.c')
-rw-r--r--src/util/scheduler.c825
1 files changed, 407 insertions, 418 deletions
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 7c5077fab7..0c43744713 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -269,7 +269,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;
@@ -288,7 +288,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 */
}
@@ -310,37 +310,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;
}
@@ -355,7 +355,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;
@@ -364,40 +364,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;
+ }
}
@@ -412,17 +412,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;
}
@@ -439,8 +439,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;
@@ -449,25 +449,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))
{
- if (GNUNET_YES == is_pending (task->prereq_id))
- {
- task->reason = reason;
- return GNUNET_NO; /* prereq waiting */
- }
- reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
+ task->reason = reason;
+ return GNUNET_NO; /* prereq waiting */
}
+ reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
+ }
task->reason = reason;
return GNUNET_YES;
}
@@ -500,7 +500,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;
@@ -511,40 +511,39 @@ 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
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Checking readiness of task: %llu / %p\n", pos->id,
- pos->callback_cls);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "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);
- pos = next;
- continue;
- }
- prev = 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;
+ }
}
@@ -563,15 +562,26 @@ 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
@@ -579,18 +589,7 @@ 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;
- }
- }
+ }
}
@@ -632,69 +631,68 @@ 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--)
{
- 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;
+ 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)
- {
- 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)
+ {
+ 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);
+ }
#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
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Running task: %llu / %p\n", pos->id, pos->callback_cls);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "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++)
- 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++)
+ LOG (GNUNET_ERROR_TYPE_ERROR, "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));
}
@@ -720,11 +718,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;
}
@@ -750,10 +748,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;
}
@@ -799,7 +797,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);
@@ -811,77 +809,76 @@ 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)
{
- 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;
+ /* 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;
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "select");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "select");
#ifndef MINGW
#if USE_LSOF
- char lsof[512];
+ char lsof[512];
- snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
- (void) close (1);
- (void) dup2 (2, 1);
- if (0 != system (lsof))
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "system");
+ snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
+ (void) close (1);
+ (void) dup2 (2, 1);
+ if (0 != system (lsof))
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "system");
#endif
#endif
- abort ();
- break;
- }
- if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
- {
- 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))
+ {
+ 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;
}
+ }
GNUNET_SIGNAL_handler_uninstall (shc_int);
GNUNET_SIGNAL_handler_uninstall (shc_term);
#ifndef MINGW
@@ -934,10 +931,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;
}
@@ -963,77 +960,76 @@ 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 (t == NULL)
- {
- 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;
- }
+ if (pending_timeout_last == t)
+ pending_timeout_last = NULL;
+ }
p = 0;
while (t == NULL)
+ {
+ p++;
+ if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT)
{
- p++;
- if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT)
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("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;
- }
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("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 (p == 0)
- {
- if (to == 0)
- {
- pending = t->next;
- }
- else
- {
- pending_timeout = t->next;
- }
- }
+ if (to == 0)
+ {
+ pending = t->next;
+ }
else
- {
- ready[p] = t->next;
- }
+ {
+ pending_timeout = t->next;
+ }
}
- else
+ else
{
- prev->next = t->next;
+ ready[p] = t->next;
}
+ }
+ else
+ {
+ prev->next = t->next;
+ }
ret = t->callback_cls;
#if DEBUG_TASKS
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Canceling task: %llu / %p\n", task, t->callback_cls);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task,
+ t->callback_cls);
#endif
destroy_task (t);
return ret;
@@ -1051,7 +1047,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;
@@ -1061,12 +1057,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;
@@ -1080,8 +1076,8 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
t->priority = current_priority;
t->lifeness = current_lifeness;
#if DEBUG_TASKS
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Adding continuation task: %llu / %p\n", t->id, t->callback_cls);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n", t->id,
+ t->callback_cls);
#endif
queue_ready_task (t);
}
@@ -1106,12 +1102,11 @@ 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);
}
@@ -1126,12 +1121,11 @@ 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);
}
@@ -1150,7 +1144,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 */
@@ -1170,7 +1164,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;
@@ -1185,24 +1179,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
@@ -1212,23 +1206,23 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
pending_timeout_last = t;
#if DEBUG_TASKS
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Adding task: %llu / %p\n", t->id, t->callback_cls);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+ t->callback_cls);
#endif
#if EXECINFO
int i;
for (i = 0; i < t->num_backtrace_strings; i++)
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "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
}
@@ -1247,9 +1241,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);
}
@@ -1269,16 +1263,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;
@@ -1316,7 +1310,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;
@@ -1332,45 +1326,41 @@ 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);
+ {
+ int flags = fcntl (rfd, F_GETFD);
- if ((flags == -1) && (errno == EBADF))
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Got invalid file descriptor %d!\n", rfd);
+ if ((flags == -1) && (errno == EBADF))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", rfd);
#if EXECINFO
- int i;
+ int i;
- for (i = 0; i < t->num_backtrace_strings; i++)
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Trace: %s\n", t->backtrace_strings[i]);
+ for (i = 0; i < t->num_backtrace_strings; i++)
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", t->backtrace_strings[i]);
#endif
- GNUNET_assert (0);
- }
+ GNUNET_assert (0);
}
+ }
if (-1 != wfd)
- {
- int flags = fcntl (wfd, F_GETFD);
+ {
+ int flags = fcntl (wfd, F_GETFD);
- if (flags == -1 && errno == EBADF)
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Got invalid file descriptor %d!\n", wfd);
+ if (flags == -1 && errno == EBADF)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", wfd);
#if EXECINFO
- int i;
+ int i;
- for (i = 0; i < t->num_backtrace_strings; i++)
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Trace: %s\n", t->backtrace_strings[i]);
+ for (i = 0; i < t->num_backtrace_strings; i++)
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", t->backtrace_strings[i]);
#endif
- GNUNET_assert (0);
- }
+ GNUNET_assert (0);
}
+ }
#endif
t->read_fd = rfd;
GNUNET_assert (wfd >= -1);
@@ -1387,15 +1377,15 @@ 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
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Adding task: %llu / %p\n", t->id, t->callback_cls);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+ t->callback_cls);
#endif
#if EXECINFO
int i;
for (i = 0; i < t->num_backtrace_strings; i++)
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+ t->backtrace_strings[i]);
#endif
return t->id;
}
@@ -1421,8 +1411,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;
@@ -1432,14 +1422,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
}
@@ -1462,8 +1452,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;
@@ -1473,15 +1463,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
}
@@ -1504,8 +1494,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;
@@ -1515,9 +1505,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
@@ -1548,8 +1538,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;
@@ -1559,9 +1549,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
@@ -1610,12 +1600,11 @@ 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;
@@ -1631,20 +1620,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 ();
@@ -1652,23 +1641,23 @@ 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
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Adding task: %llu / %p\n", t->id, t->callback_cls);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+ t->callback_cls);
#endif
#if EXECINFO
int i;
for (i = 0; i < t->num_backtrace_strings; i++)
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+ t->backtrace_strings[i]);
#endif
return t->id;
}
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2024-11-22 14:12:17 +0000