This file is part of GNUnet
Copyright (C) 2009-2017 GNUnet e.V.
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ Affero General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
* @file util/scheduler.c
#include "platform.h"
#include "gnunet_util_lib.h"
#include "disk.h"
+// DEBUG
+#include <inttypes.h>
-#define LOG(kind,...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)
-#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-scheduler", syscall)
+#define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror (kind, \
+ "util-scheduler", \
+ syscall)
#if HAVE_EXECINFO_H
/**
* Argument to be passed from the driver to
- * #GNUNET_SCHEDULER_run_from_driver(). Contains the
+ * #GNUNET_SCHEDULER_do_work(). Contains the
* scheduler's internal state.
*/
struct GNUNET_SCHEDULER_Handle
struct GNUNET_NETWORK_FDSet *ws;
/**
- * Driver we used for the event loop.
+ * context of the SIGINT handler
+ */
+ struct GNUNET_SIGNAL_Context *shc_int;
+
+ /**
+ * context of the SIGTERM handler
+ */
+ struct GNUNET_SIGNAL_Context *shc_term;
+
+#if (SIGTERM != GNUNET_TERM_SIG)
+ /**
+ * context of the TERM_SIG handler
+ */
+ struct GNUNET_SIGNAL_Context *shc_gterm;
+#endif
+
+ /**
+ * context of the SIGQUIT handler
+ */
+ struct GNUNET_SIGNAL_Context *shc_quit;
+
+ /**
+ * context of the SIGHUP handler
*/
- const struct GNUNET_SCHEDULER_Driver *driver;
+ struct GNUNET_SIGNAL_Context *shc_hup;
+ /**
+ * context of hte SIGPIPE handler
+ */
+ struct GNUNET_SIGNAL_Context *shc_pipe;
};
void *callback_cls;
/**
- * Handle to the scheduler's state.
- */
- const struct GNUNET_SCHEDULER_Handle *sh;
-
- /**
- * Set of file descriptors this task is waiting
- * for for reading. Once ready, this is updated
- * to reflect the set of file descriptors ready
- * for operation.
+ * Information about which FDs are ready for this task (and why).
*/
- struct GNUNET_NETWORK_FDSet *read_set;
+ struct GNUNET_SCHEDULER_FdInfo *fds;
/**
- * Set of file descriptors this task is waiting for for writing.
- * Once ready, this is updated to reflect the set of file
- * descriptors ready for operation.
+ * Storage location used for @e fds if we want to avoid
+ * a separate malloc() call in the common case that this
+ * task is only about a single FD.
*/
- struct GNUNET_NETWORK_FDSet *write_set;
+ struct GNUNET_SCHEDULER_FdInfo fdx;
/**
- * Information about which FDs are ready for this task (and why).
+ * Size of the @e fds array.
*/
- const struct GNUNET_SCHEDULER_FdInfo *fds;
+ unsigned int fds_len;
/**
- * Storage location used for @e fds if we want to avoid
- * a separate malloc() call in the common case that this
- * task is only about a single FD.
+ * Do we own the network and file handles referenced by the FdInfo
+ * structs in the fds array. This will only be GNUNET_YES if the
+ * task was created by the #GNUNET_SCHEDULER_add_select function.
*/
- struct GNUNET_SCHEDULER_FdInfo fdx;
+ int own_handles;
/**
* Absolute timeout value for the task, or
struct GNUNET_TIME_Absolute start_time;
#endif
- /**
- * Size of the @e fds array.
- */
- unsigned int fds_len;
-
/**
* Why is the task ready? Set after task is added to ready queue.
* Initially set to zero. All reasons that have already been
int num_backtrace_strings;
#endif
+ /**
+ * Asynchronous scope of the task that scheduled this scope,
+ */
+ struct GNUNET_AsyncScopeSave scope;
+};
+
+
+/**
+ * A struct representing an event the select driver is waiting for
+ */
+struct Scheduled
+{
+ struct Scheduled *prev;
+
+ struct Scheduled *next;
+
+ /**
+ * the task, the event is related to
+ */
+ struct GNUNET_SCHEDULER_Task *task;
+
+ /**
+ * information about the network socket / file descriptor where
+ * the event is expected to occur
+ */
+ struct GNUNET_SCHEDULER_FdInfo *fdi;
+
+ /**
+ * the event types (multiple event types can be ORed) the select
+ * driver is expected to wait for
+ */
+ enum GNUNET_SCHEDULER_EventType et;
+};
+
+
+/**
+ * Driver context used by GNUNET_SCHEDULER_run
+ */
+struct DriverContext
+{
+ /**
+ * the head of a DLL containing information about the events the
+ * select driver is waiting for
+ */
+ struct Scheduled *scheduled_head;
+
+ /**
+ * the tail of a DLL containing information about the events the
+ * select driver is waiting for
+ */
+ struct Scheduled *scheduled_tail;
+ /**
+ * the time when the select driver will wake up again (after
+ * calling select)
+ */
+ struct GNUNET_TIME_Absolute timeout;
};
+/**
+ * The driver used for the event loop. Will be handed over to
+ * the scheduler in #GNUNET_SCHEDULER_do_work(), persisted
+ * there in this variable for later use in functions like
+ * #GNUNET_SCHEDULER_add_select(), #add_without_sets() and
+ * #GNUNET_SCHEDULER_cancel().
+ */
+static const struct GNUNET_SCHEDULER_Driver *scheduler_driver;
+
/**
* Head of list of tasks waiting for an event.
*/
/**
* Head of list of tasks ready to run right now, grouped by importance.
*/
-static struct GNUNET_SCHEDULER_Task *ready_head[GNUNET_SCHEDULER_PRIORITY_COUNT];
+static struct
+GNUNET_SCHEDULER_Task *ready_head[GNUNET_SCHEDULER_PRIORITY_COUNT];
/**
* Tail of list of tasks ready to run right now, grouped by importance.
*/
-static struct GNUNET_SCHEDULER_Task *ready_tail[GNUNET_SCHEDULER_PRIORITY_COUNT];
+static struct
+GNUNET_SCHEDULER_Task *ready_tail[GNUNET_SCHEDULER_PRIORITY_COUNT];
/**
- * Number of tasks on the ready list.
+ * Task for installing parent control handlers (it might happen that the
+ * scheduler is shutdown before this task is executed, so
+ * GNUNET_SCHEDULER_shutdown must cancel it in that case)
*/
-static unsigned int ready_count;
+static struct GNUNET_SCHEDULER_Task *install_parent_control_task;
/**
- * How many tasks have we run so far?
+ * Task for reading from a pipe that signal handlers will use to initiate
+ * shutdown
*/
-static unsigned long long tasks_run;
+static struct GNUNET_SCHEDULER_Task *shutdown_pipe_task;
+
+/**
+ * Number of tasks on the ready list.
+ */
+static unsigned int ready_count;
/**
* Priority of the task running right now. Only
/**
- * Update all sets and timeout for select.
- *
- * @param rs read-set, set to all FDs we would like to read (updated)
- * @param ws write-set, set to all FDs we would like to write (updated)
- * @param timeout next timeout (updated)
+ * chooses the nearest timeout from all pending tasks, to be used
+ * to tell the driver the next wakeup time (using its set_wakeup
+ * callback)
*/
-static void
-update_sets (struct GNUNET_NETWORK_FDSet *rs,
- struct GNUNET_NETWORK_FDSet *ws,
- struct GNUNET_TIME_Relative *timeout)
+struct GNUNET_TIME_Absolute
+get_timeout ()
{
struct GNUNET_SCHEDULER_Task *pos;
struct GNUNET_TIME_Absolute now;
- struct GNUNET_TIME_Relative to;
+ struct GNUNET_TIME_Absolute timeout;
- now = GNUNET_TIME_absolute_get ();
pos = pending_timeout_head;
+ now = GNUNET_TIME_absolute_get ();
+ timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
if (NULL != pos)
{
- to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
- if (timeout->rel_value_us > to.rel_value_us)
- *timeout = to;
if (0 != pos->reason)
- *timeout = GNUNET_TIME_UNIT_ZERO;
+ {
+ return now;
+ }
+ else
+ {
+ timeout = pos->timeout;
+ }
}
for (pos = pending_head; NULL != pos; pos = pos->next)
{
- if (pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
+ if (0 != pos->reason)
{
- to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
- if (timeout->rel_value_us > to.rel_value_us)
- *timeout = to;
+ return now;
+ }
+ else if ((pos->timeout.abs_value_us !=
+ GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) &&
+ (timeout.abs_value_us > pos->timeout.abs_value_us))
+ {
+ timeout = pos->timeout;
}
- if (-1 != pos->read_fd)
- GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
- if (-1 != pos->write_fd)
- GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
- if (NULL != pos->read_set)
- GNUNET_NETWORK_fdset_add (rs, pos->read_set);
- if (NULL != pos->write_set)
- GNUNET_NETWORK_fdset_add (ws, pos->write_set);
- if (0 != pos->reason)
- *timeout = GNUNET_TIME_UNIT_ZERO;
- }
-}
-
-
-/**
- * Check if the ready set overlaps with the set we want to have ready.
- * If so, update the want set (set all FDs that are ready). If not,
- * return #GNUNET_NO.
- *
- * @param ready set that is ready
- * @param want set that we want to be ready
- * @return #GNUNET_YES if there was some overlap
- */
-static int
-set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
- 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;
}
- return GNUNET_NO;
-}
-
-
-/**
- * Check if the given task is eligible to run now.
- * Also set the reason why it is eligible.
- *
- * @param task task to check if it is ready
- * @param now the current time
- * @param rs set of FDs ready for reading
- * @param ws set of FDs ready for writing
- * @return #GNUNET_YES if we can run it, #GNUNET_NO if not.
- */
-static int
-is_ready (struct GNUNET_SCHEDULER_Task *task,
- struct GNUNET_TIME_Absolute now,
- const struct GNUNET_NETWORK_FDSet *rs,
- const struct GNUNET_NETWORK_FDSet *ws)
-{
- enum GNUNET_SCHEDULER_Reason reason;
-
- reason = task->reason;
- if (now.abs_value_us >= task->timeout.abs_value_us)
- 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))))
- 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)))
- || (set_overlaps (ws, task->write_set))))
- reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
- if (0 == reason)
- return GNUNET_NO; /* not ready */
- reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
- task->reason = reason;
- return GNUNET_YES;
+ return timeout;
}
}
-/**
- * Check which tasks are ready and move them
- * to the respective ready queue.
- *
- * @param rs FDs ready for reading
- * @param ws FDs ready for writing
- */
-static void
-check_ready (const struct GNUNET_NETWORK_FDSet *rs,
- const struct GNUNET_NETWORK_FDSet *ws)
-{
- struct GNUNET_SCHEDULER_Task *pos;
- struct GNUNET_SCHEDULER_Task *next;
- struct GNUNET_TIME_Absolute now;
-
- now = GNUNET_TIME_absolute_get ();
- while (NULL != (pos = pending_timeout_head))
- {
- if (now.abs_value_us >= pos->timeout.abs_value_us)
- pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
- if (0 == pos->reason)
- break;
- GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
- pending_timeout_tail,
- pos);
- if (pending_timeout_last == pos)
- pending_timeout_last = NULL;
- queue_ready_task (pos);
- }
- pos = pending_head;
- while (NULL != pos)
- {
- next = pos->next;
- if (GNUNET_YES == is_ready (pos, now, rs, ws))
- {
- GNUNET_CONTAINER_DLL_remove (pending_head,
- pending_tail,
- pos);
- queue_ready_task (pos);
- }
- pos = next;
- }
-}
-
-
/**
* Request the shutdown of a scheduler. Marks all tasks
* awaiting shutdown as ready. Note that tasks
{
struct GNUNET_SCHEDULER_Task *pos;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "GNUNET_SCHEDULER_shutdown\n");
+ if (NULL != install_parent_control_task)
+ {
+ GNUNET_SCHEDULER_cancel (install_parent_control_task);
+ install_parent_control_task = NULL;
+ }
+ if (NULL != shutdown_pipe_task)
+ {
+ GNUNET_SCHEDULER_cancel (shutdown_pipe_task);
+ shutdown_pipe_task = NULL;
+ }
while (NULL != (pos = shutdown_head))
{
GNUNET_CONTAINER_DLL_remove (shutdown_head,
}
-/**
- * Destroy a task (release associated resources)
- *
- * @param t task to destroy
- */
-static void
-destroy_task (struct GNUNET_SCHEDULER_Task *t)
-{
- if (NULL != t->read_set)
- GNUNET_NETWORK_fdset_destroy (t->read_set);
- if (NULL != t->write_set)
- GNUNET_NETWORK_fdset_destroy (t->write_set);
-#if EXECINFO
- GNUNET_free (t->backtrace_strings);
-#endif
- GNUNET_free (t);
-}
-
-
/**
* Output stack trace of task @a t.
*
dump_backtrace (struct GNUNET_SCHEDULER_Task *t)
{
#if EXECINFO
- unsigned int i;
-
- for (i = 0; i < t->num_backtrace_strings; i++)
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %p trace %u: %s\n",
- t,
- i,
- t->backtrace_strings[i]);
+ for (unsigned int i = 0; i < t->num_backtrace_strings; i++)
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Task %p trace %u: %s\n",
+ t,
+ i,
+ t->backtrace_strings[i]);
+#else
+ (void) t;
#endif
}
/**
- * Run at least one task in the highest-priority queue that is not
- * empty. Keep running tasks until we are either no longer running
- * "URGENT" tasks or until we have at least one "pending" task (which
- * may become ready, hence we should select on it). Naturally, if
- * there are no more ready tasks, we also return.
+ * Destroy a task (release associated resources)
*
- * @param rs FDs ready for reading
- * @param ws FDs ready for writing
+ * @param t task to destroy
*/
static void
-run_ready (struct GNUNET_NETWORK_FDSet *rs,
- struct GNUNET_NETWORK_FDSet *ws)
+destroy_task (struct GNUNET_SCHEDULER_Task *t)
{
- enum GNUNET_SCHEDULER_Priority p;
- struct GNUNET_SCHEDULER_Task *pos;
+ unsigned int i;
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "destroying task %p\n",
+ t);
- max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
- do
+ if (GNUNET_YES == t->own_handles)
{
- if (0 == ready_count)
- return;
- GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
- /* 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_head[p];
- if (NULL != pos)
- break;
- }
- GNUNET_assert (NULL != pos); /* ready_count wrong? */
- GNUNET_CONTAINER_DLL_remove (ready_head[p],
- ready_tail[p],
- pos);
- ready_count--;
- current_priority = pos->priority;
- current_lifeness = pos->lifeness;
- active_task = pos;
-#if PROFILE_DELAYS
- if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
- DELAY_THRESHOLD.rel_value_us)
+ for (i = 0; i != t->fds_len; ++i)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %p took %s to be scheduled\n",
- pos,
- GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
- GNUNET_YES));
+ const struct GNUNET_NETWORK_Handle *fd = t->fds[i].fd;
+ const struct GNUNET_DISK_FileHandle *fh = t->fds[i].fh;
+ if (fd)
+ {
+ GNUNET_NETWORK_socket_free_memory_only_ ((struct
+ GNUNET_NETWORK_Handle *) fd);
+ }
+ if (fh)
+ {
+ // FIXME: on WIN32 this is not enough! A function
+ // GNUNET_DISK_file_free_memory_only would be nice
+ GNUNET_free ((void *) fh);
+ }
}
-#endif
- tc.reason = pos->reason;
- tc.read_ready = (NULL == pos->read_set) ? rs : pos->read_set;
- if ((-1 != pos->read_fd) &&
- (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)))
- GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
- tc.write_ready = (NULL == pos->write_set) ? ws : pos->write_set;
- if ((-1 != pos->write_fd) &&
- (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
- GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
- if ((0 != (tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
- (-1 != pos->write_fd) &&
- (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
- GNUNET_assert (0); // added to ready in previous select loop!
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Running task: %p\n",
- pos);
- pos->callback (pos->callback_cls);
- dump_backtrace (pos);
- active_task = NULL;
- destroy_task (pos);
- tasks_run++;
}
- while ((NULL == pending_head) || (p >= max_priority_added));
+ if (t->fds_len > 1)
+ {
+ GNUNET_array_grow (t->fds, t->fds_len, 0);
+ }
+#if EXECINFO
+ GNUNET_free (t->backtrace_strings);
+#endif
+ GNUNET_free (t);
}
/**
* Signal handler called for SIGPIPE.
*/
-#ifndef MINGW
static void
sighandler_pipe ()
{
return;
}
-#endif
-
-/**
- * Wait for a short time.
- * Sleeps for @a ms ms (as that should be long enough for virtually all
- * modern systems to context switch and allow another process to do
- * some 'real' work).
- *
- * @param ms how many ms to wait
- */
-static void
-short_wait (unsigned int ms)
-{
- struct GNUNET_TIME_Relative timeout;
- timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, ms);
- (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
-}
+///**
+// * Wait for a short time.
+// * Sleeps for @a ms ms (as that should be long enough for virtually all
+// * modern systems to context switch and allow another process to do
+// * some 'real' work).
+// *
+// * @param ms how many ms to wait
+// */
+// static void
+// short_wait (unsigned int ms)
+// {
+// struct GNUNET_TIME_Relative timeout;
+//
+// timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, ms);
+// (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
+// }
/**
int old_errno = errno; /* backup errno */
if (getpid () != my_pid)
- exit (1); /* we have fork'ed since the signal handler was created,
- * ignore the signal, see https://gnunet.org/vfork discussion */
+ _exit (1); /* we have fork'ed since the signal handler was created,
+ * ignore the signal, see https://gnunet.org/vfork discussion */
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;
}
-/**
- * Check if the system is still alive. Trigger shutdown if we
- * have tasks, but none of them give us lifeness.
- *
- * @return #GNUNET_OK to continue the main loop,
- * #GNUNET_NO to exit
- */
-static int
-check_lifeness ()
+static void
+shutdown_if_no_lifeness ()
{
struct GNUNET_SCHEDULER_Task *t;
if (ready_count > 0)
- return GNUNET_OK;
+ return;
for (t = pending_head; NULL != t; t = t->next)
- if (t->lifeness == GNUNET_YES)
- return GNUNET_OK;
+ if (GNUNET_YES == t->lifeness)
+ return;
for (t = shutdown_head; NULL != t; t = t->next)
- if (t->lifeness == GNUNET_YES)
- return GNUNET_OK;
+ if (GNUNET_YES == t->lifeness)
+ return;
for (t = pending_timeout_head; NULL != t; t = t->next)
- if (t->lifeness == GNUNET_YES)
- return GNUNET_OK;
- if (NULL != shutdown_head)
- {
- GNUNET_SCHEDULER_shutdown ();
- return GNUNET_OK;
- }
- return GNUNET_NO;
+ if (GNUNET_YES == t->lifeness)
+ return;
+ /* No lifeness! */
+ GNUNET_SCHEDULER_shutdown ();
}
+static int
+select_loop (struct GNUNET_SCHEDULER_Handle *sh,
+ struct DriverContext *context);
+
+
/**
* Initialize and run scheduler. This function will return when all
* tasks have completed. On systems with signals, receiving a SIGTERM
GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
void *task_cls)
{
- struct GNUNET_NETWORK_FDSet *rs;
- struct GNUNET_NETWORK_FDSet *ws;
- struct GNUNET_TIME_Relative timeout;
- int ret;
- struct GNUNET_SIGNAL_Context *shc_int;
- struct GNUNET_SIGNAL_Context *shc_term;
-#if (SIGTERM != GNUNET_TERM_SIG)
- struct GNUNET_SIGNAL_Context *shc_gterm;
-#endif
-
-#ifndef MINGW
- struct GNUNET_SIGNAL_Context *shc_quit;
- struct GNUNET_SIGNAL_Context *shc_hup;
- struct GNUNET_SIGNAL_Context *shc_pipe;
-#endif
- unsigned long long last_tr;
- unsigned int busy_wait_warning;
- const struct GNUNET_DISK_FileHandle *pr;
- char c;
-
- GNUNET_assert (NULL == active_task);
- rs = GNUNET_NETWORK_fdset_create ();
- ws = GNUNET_NETWORK_fdset_create ();
- GNUNET_assert (NULL == shutdown_pipe_handle);
- shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
- GNUNET_NO,
- GNUNET_NO,
- GNUNET_NO);
- GNUNET_assert (NULL != shutdown_pipe_handle);
- pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
- GNUNET_DISK_PIPE_END_READ);
- GNUNET_assert (NULL != pr);
- my_pid = getpid ();
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Registering signal handlers\n");
- shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
- &sighandler_shutdown);
- shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
- &sighandler_shutdown);
-#if (SIGTERM != GNUNET_TERM_SIG)
- shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
- &sighandler_shutdown);
-#endif
-#ifndef MINGW
- shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
- &sighandler_pipe);
- shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
- &sighandler_shutdown);
- shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
- &sighandler_shutdown);
-#endif
- current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
- current_lifeness = GNUNET_YES;
+ struct GNUNET_SCHEDULER_Handle *sh;
+ struct GNUNET_SCHEDULER_Driver *driver;
+ struct DriverContext context = { .scheduled_head = NULL,
+ .scheduled_tail = NULL,
+ .timeout = GNUNET_TIME_absolute_get () };
+
+ driver = GNUNET_SCHEDULER_driver_select ();
+ driver->cls = &context;
+ sh = GNUNET_SCHEDULER_driver_init (driver);
GNUNET_SCHEDULER_add_with_reason_and_priority (task,
task_cls,
GNUNET_SCHEDULER_REASON_STARTUP,
GNUNET_SCHEDULER_PRIORITY_DEFAULT);
- 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);
- active_task = NULL;
- 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;
-
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "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))
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
- "system");
-#endif
-#endif
-#if DEBUG_FDS
- struct GNUNET_SCHEDULER_Task *t;
-
- for (t = pending_head; NULL != t; t = t->next)
- {
- if (-1 != t->read_fd)
- {
- int flags = fcntl (t->read_fd, F_GETFD);
- if ((flags == -1) && (errno == EBADF))
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Got invalid file descriptor %d!\n",
- t->read_fd);
- dump_backtrace (t);
- }
- }
- if (-1 != t->write_fd)
- {
- int flags = fcntl (t->write_fd, F_GETFD);
- if ((flags == -1) && (errno == EBADF))
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Got invalid file descriptor %d!\n",
- t->write_fd);
- dump_backtrace (t);
- }
- }
- }
-#endif
- GNUNET_assert (0);
- break;
- }
-
- if ( (0 == ret) &&
- (0 == timeout.rel_value_us) &&
- (busy_wait_warning > 16) )
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Looks like we're busy waiting...\n");
- short_wait (100); /* 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)
- {
- short_wait (1);
- busy_wait_warning++;
- }
- else
- {
- last_tr = tasks_run;
- busy_wait_warning = 0;
- }
- }
- GNUNET_SIGNAL_handler_uninstall (shc_int);
- GNUNET_SIGNAL_handler_uninstall (shc_term);
-#if (SIGTERM != GNUNET_TERM_SIG)
- GNUNET_SIGNAL_handler_uninstall (shc_gterm);
-#endif
-#ifndef MINGW
- GNUNET_SIGNAL_handler_uninstall (shc_pipe);
- GNUNET_SIGNAL_handler_uninstall (shc_quit);
- GNUNET_SIGNAL_handler_uninstall (shc_hup);
-#endif
- GNUNET_DISK_pipe_close (shutdown_pipe_handle);
- shutdown_pipe_handle = NULL;
- GNUNET_NETWORK_fdset_destroy (rs);
- GNUNET_NETWORK_fdset_destroy (ws);
+ select_loop (sh,
+ &context);
+ GNUNET_SCHEDULER_driver_done (sh);
+ GNUNET_free (driver);
}
}
+void
+init_fd_info (struct GNUNET_SCHEDULER_Task *t,
+ const struct GNUNET_NETWORK_Handle *const *read_nh,
+ unsigned int read_nh_len,
+ const struct GNUNET_NETWORK_Handle *const *write_nh,
+ unsigned int write_nh_len,
+ const struct GNUNET_DISK_FileHandle *const *read_fh,
+ unsigned int read_fh_len,
+ const struct GNUNET_DISK_FileHandle *const *write_fh,
+ unsigned int write_fh_len)
+{
+ // FIXME: if we have exactly two network handles / exactly two file handles
+ // and they are equal, we can make one FdInfo with both
+ // GNUNET_SCHEDULER_ET_IN and GNUNET_SCHEDULER_ET_OUT set.
+ struct GNUNET_SCHEDULER_FdInfo *fdi;
+
+ t->fds_len = read_nh_len + write_nh_len + read_fh_len + write_fh_len;
+ if (1 == t->fds_len)
+ {
+ fdi = &t->fdx;
+ t->fds = fdi;
+ if (1 == read_nh_len)
+ {
+ GNUNET_assert (NULL != read_nh);
+ GNUNET_assert (NULL != *read_nh);
+ fdi->fd = *read_nh;
+ fdi->et = GNUNET_SCHEDULER_ET_IN;
+ fdi->sock = GNUNET_NETWORK_get_fd (*read_nh);
+ t->read_fd = fdi->sock;
+ t->write_fd = -1;
+ }
+ else if (1 == write_nh_len)
+ {
+ GNUNET_assert (NULL != write_nh);
+ GNUNET_assert (NULL != *write_nh);
+ fdi->fd = *write_nh;
+ fdi->et = GNUNET_SCHEDULER_ET_OUT;
+ fdi->sock = GNUNET_NETWORK_get_fd (*write_nh);
+ t->read_fd = -1;
+ t->write_fd = fdi->sock;
+ }
+ else if (1 == read_fh_len)
+ {
+ GNUNET_assert (NULL != read_fh);
+ GNUNET_assert (NULL != *read_fh);
+ fdi->fh = *read_fh;
+ fdi->et = GNUNET_SCHEDULER_ET_IN;
+ fdi->sock = (*read_fh)->fd; // FIXME: does not work under WIN32
+ t->read_fd = fdi->sock;
+ t->write_fd = -1;
+ }
+ else
+ {
+ GNUNET_assert (NULL != write_fh);
+ GNUNET_assert (NULL != *write_fh);
+ fdi->fh = *write_fh;
+ fdi->et = GNUNET_SCHEDULER_ET_OUT;
+ fdi->sock = (*write_fh)->fd; // FIXME: does not work under WIN32
+ t->read_fd = -1;
+ t->write_fd = fdi->sock;
+ }
+ }
+ else
+ {
+ fdi = GNUNET_new_array (t->fds_len, struct GNUNET_SCHEDULER_FdInfo);
+ t->fds = fdi;
+ t->read_fd = -1;
+ t->write_fd = -1;
+ unsigned int i;
+ for (i = 0; i != read_nh_len; ++i)
+ {
+ fdi->fd = read_nh[i];
+ GNUNET_assert (NULL != fdi->fd);
+ fdi->et = GNUNET_SCHEDULER_ET_IN;
+ fdi->sock = GNUNET_NETWORK_get_fd (read_nh[i]);
+ ++fdi;
+ }
+ for (i = 0; i != write_nh_len; ++i)
+ {
+ fdi->fd = write_nh[i];
+ GNUNET_assert (NULL != fdi->fd);
+ fdi->et = GNUNET_SCHEDULER_ET_OUT;
+ fdi->sock = GNUNET_NETWORK_get_fd (write_nh[i]);
+ ++fdi;
+ }
+ for (i = 0; i != read_fh_len; ++i)
+ {
+ fdi->fh = read_fh[i];
+ GNUNET_assert (NULL != fdi->fh);
+ fdi->et = GNUNET_SCHEDULER_ET_IN;
+ fdi->sock = (read_fh[i])->fd; // FIXME: does not work under WIN32
+ ++fdi;
+ }
+ for (i = 0; i != write_fh_len; ++i)
+ {
+ fdi->fh = write_fh[i];
+ GNUNET_assert (NULL != fdi->fh);
+ fdi->et = GNUNET_SCHEDULER_ET_OUT;
+ fdi->sock = (write_fh[i])->fd; // FIXME: does not work under WIN32
+ ++fdi;
+ }
+ }
+}
+
+
+/**
+ * calls the given function @a func on each FdInfo related to @a t.
+ * Optionally updates the event type field in each FdInfo after calling
+ * @a func.
+ *
+ * @param t the task
+ * @param driver_func the function to call with each FdInfo contained in
+ * in @a t
+ * @param if_not_ready only call @a driver_func on FdInfos that are not
+ * ready
+ * @param et the event type to be set in each FdInfo after calling
+ * @a driver_func on it, or -1 if no updating not desired.
+ */
+static void
+driver_add_multiple (struct GNUNET_SCHEDULER_Task *t)
+{
+ struct GNUNET_SCHEDULER_FdInfo *fdi;
+ int success = GNUNET_YES;
+
+ for (unsigned int i = 0; i != t->fds_len; ++i)
+ {
+ fdi = &t->fds[i];
+ success = scheduler_driver->add (scheduler_driver->cls,
+ t,
+ fdi) && success;
+ fdi->et = GNUNET_SCHEDULER_ET_NONE;
+ }
+ if (GNUNET_YES != success)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "driver could not add task\n");
+ }
+}
+
+
+static void
+install_parent_control_handler (void *cls)
+{
+ (void) cls;
+ install_parent_control_task = NULL;
+ GNUNET_OS_install_parent_control_handler (NULL);
+}
+
+
+static void
+shutdown_pipe_cb (void *cls)
+{
+ char c;
+ const struct GNUNET_DISK_FileHandle *pr;
+
+ (void) cls;
+ shutdown_pipe_task = NULL;
+ pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
+ GNUNET_DISK_PIPE_END_READ);
+ GNUNET_assert (! GNUNET_DISK_handle_invalid (pr));
+ /* consume the signal */
+ GNUNET_DISK_file_read (pr, &c, sizeof(c));
+ /* mark all active tasks as ready due to shutdown */
+ GNUNET_SCHEDULER_shutdown ();
+ shutdown_pipe_task =
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+ pr,
+ &shutdown_pipe_cb,
+ NULL);
+}
+
+
/**
* Cancel the task with the specified identifier.
- * The task must not yet have run.
+ * The task must not yet have run. Only allowed to be called as long as the
+ * scheduler is running, that is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param task id of the task to cancel
* @return original closure of the task
GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
{
enum GNUNET_SCHEDULER_Priority p;
+ int is_fd_task;
void *ret;
- GNUNET_assert ( (NULL != active_task) ||
- (GNUNET_NO == task->lifeness) );
- if (! task->in_ready_list)
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "canceling task %p\n",
+ task);
+
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
+ is_fd_task = (NULL != task->fds);
+ if (is_fd_task)
{
- if ( (-1 == task->read_fd) &&
- (-1 == task->write_fd) &&
- (NULL == task->read_set) &&
- (NULL == task->write_set) )
+ int del_result = scheduler_driver->del (scheduler_driver->cls, task);
+ if (GNUNET_OK != del_result)
{
- if (GNUNET_YES == task->on_shutdown)
- GNUNET_CONTAINER_DLL_remove (shutdown_head,
- shutdown_tail,
- task);
- else
- GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
- pending_timeout_tail,
- task);
- if (task == pending_timeout_last)
- pending_timeout_last = NULL;
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "driver could not delete task\n");
+ GNUNET_assert (0);
}
- else
+ }
+ if (! task->in_ready_list)
+ {
+ if (is_fd_task)
{
GNUNET_CONTAINER_DLL_remove (pending_head,
pending_tail,
task);
}
+ else if (GNUNET_YES == task->on_shutdown)
+ {
+ GNUNET_CONTAINER_DLL_remove (shutdown_head,
+ shutdown_tail,
+ task);
+ }
+ else
+ {
+ GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
+ pending_timeout_tail,
+ task);
+ if (pending_timeout_last == task)
+ pending_timeout_last = NULL;
+ }
}
else
{
ready_count--;
}
ret = task->callback_cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Canceling task %p\n",
- task);
destroy_task (task);
return ret;
}
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);
dump_backtrace (t);
+#else
+ (void) t;
#endif
}
* @param priority priority to use for the task
*/
void
-GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback task,
+GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback
+ task,
void *task_cls,
- enum GNUNET_SCHEDULER_Reason reason,
- enum GNUNET_SCHEDULER_Priority priority)
+ enum GNUNET_SCHEDULER_Reason
+ reason,
+ enum GNUNET_SCHEDULER_Priority
+ priority)
{
struct GNUNET_SCHEDULER_Task *t;
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
GNUNET_assert (NULL != task);
- GNUNET_assert ((NULL != active_task) ||
- (GNUNET_SCHEDULER_REASON_STARTUP == reason));
t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
t->read_fd = -1;
t->write_fd = -1;
t->start_time = GNUNET_TIME_absolute_get ();
#endif
t->reason = reason;
- t->priority = priority;
+ t->priority = check_priority (priority);
t->lifeness = current_lifeness;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding continuation task %p\n",
struct GNUNET_SCHEDULER_Task *pos;
struct GNUNET_SCHEDULER_Task *prev;
- GNUNET_assert (NULL != active_task);
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
GNUNET_assert (NULL != task);
t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+ GNUNET_async_scope_get (&t->scope);
t->callback = task;
t->callback_cls = task_cls;
t->read_fd = -1;
t->start_time = GNUNET_TIME_absolute_get ();
#endif
t->timeout = at;
- t->priority = priority;
+ t->priority = check_priority (priority);
t->lifeness = current_lifeness;
/* try tail first (optimization in case we are
* appending to a long list of tasks with timeouts) */
- if ( (NULL == pending_timeout_head) ||
- (at.abs_value_us < pending_timeout_head->timeout.abs_value_us) )
+ if ((NULL == pending_timeout_head) ||
+ (at.abs_value_us < pending_timeout_head->timeout.abs_value_us))
{
GNUNET_CONTAINER_DLL_insert (pending_timeout_head,
pending_timeout_tail,
{
/* first move from heuristic start backwards to before start time */
prev = pending_timeout_last;
- while ( (NULL != prev) &&
- (prev->timeout.abs_value_us > t->timeout.abs_value_us) )
+ while ((NULL != prev) &&
+ (prev->timeout.abs_value_us > t->timeout.abs_value_us))
prev = prev->prev;
/* now, move from heuristic start (or head of list) forward to insertion point */
if (NULL == prev)
pos = pending_timeout_head;
else
pos = prev->next;
- while ( (NULL != pos) &&
- ( (pos->timeout.abs_value_us <= t->timeout.abs_value_us) ||
- (0 != pos->reason) ) )
+ while ((NULL != pos) && (pos->timeout.abs_value_us <=
+ t->timeout.abs_value_us))
{
prev = pos;
pos = pos->next;
pending_timeout_last = t;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Adding task: %p\n",
+ "Adding task %p\n",
t);
init_backtrace (t);
return t;
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- GNUNET_SCHEDULER_TaskCallback task,
+ enum GNUNET_SCHEDULER_Priority
+ priority,
+ GNUNET_SCHEDULER_TaskCallback task,
void *task_cls)
{
- return GNUNET_SCHEDULER_add_at_with_priority (GNUNET_TIME_relative_to_absolute (delay),
- priority,
- task,
- task_cls);
+ return GNUNET_SCHEDULER_add_at_with_priority (
+ GNUNET_TIME_relative_to_absolute (delay),
+ priority,
+ task,
+ task_cls);
}
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+ void *task_cls)
{
return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- task,
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ task,
task_cls);
}
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+ void *task_cls)
{
return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO,
- task,
- task_cls);
+ task,
+ task_cls);
}
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+ void *task_cls)
{
struct GNUNET_SCHEDULER_Task *t;
- GNUNET_assert (NULL != active_task);
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
GNUNET_assert (NULL != task);
t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+ GNUNET_async_scope_get (&t->scope);
t->callback = task;
t->callback_cls = task_cls;
t->read_fd = -1;
t->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
t->priority = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
t->on_shutdown = GNUNET_YES;
- t->lifeness = GNUNET_YES;
+ t->lifeness = GNUNET_NO;
GNUNET_CONTAINER_DLL_insert (shutdown_head,
- shutdown_tail,
- t);
+ shutdown_tail,
+ t);
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Adding task: %p\n",
+ "Adding shutdown task %p\n",
t);
init_backtrace (t);
return t;
}
+#if DEBUG_FDS
+/**
+ * check a raw file descriptor and abort if it is bad (for debugging purposes)
+ *
+ * @param t the task related to the file descriptor
+ * @param raw_fd the raw file descriptor to check
+ */
+void
+check_fd (struct GNUNET_SCHEDULER_Task *t, int raw_fd)
+{
+ if (-1 != raw_fd)
+ {
+ int flags = fcntl (raw_fd, F_GETFD);
+
+ if ((flags == -1) && (errno == EBADF))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Got invalid file descriptor %d!\n",
+ raw_fd);
+ init_backtrace (t);
+ GNUNET_assert (0);
+ }
+ }
+}
+
+
+#endif
+
+
/**
* Schedule a new task to be run with a specified delay or when any of
* the specified file descriptor sets is ready. The delay can be used
* @return unique task identifier for the job
* only valid until @a task is started!
*/
-#ifndef MINGW
static struct GNUNET_SCHEDULER_Task *
add_without_sets (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- int rfd,
- int wfd,
+ enum GNUNET_SCHEDULER_Priority priority,
+ const struct GNUNET_NETWORK_Handle *read_nh,
+ const struct GNUNET_NETWORK_Handle *write_nh,
+ const struct GNUNET_DISK_FileHandle *read_fh,
+ const struct GNUNET_DISK_FileHandle *write_fh,
GNUNET_SCHEDULER_TaskCallback task,
void *task_cls)
{
struct GNUNET_SCHEDULER_Task *t;
- GNUNET_assert (NULL != active_task);
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
GNUNET_assert (NULL != task);
t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+ GNUNET_async_scope_get (&t->scope);
+ init_fd_info (t,
+ &read_nh,
+ read_nh ? 1 : 0,
+ &write_nh,
+ write_nh ? 1 : 0,
+ &read_fh,
+ read_fh ? 1 : 0,
+ &write_fh,
+ write_fh ? 1 : 0);
t->callback = task;
t->callback_cls = task_cls;
#if DEBUG_FDS
- if (-1 != rfd)
- {
- int flags = fcntl (rfd, F_GETFD);
-
- if ((flags == -1) && (errno == EBADF))
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Got invalid file descriptor %d!\n",
- rfd);
- init_backtrace (t);
- GNUNET_assert (0);
- }
- }
- if (-1 != wfd)
- {
- int flags = fcntl (wfd, F_GETFD);
-
- if (flags == -1 && errno == EBADF)
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Got invalid file descriptor %d!\n",
- wfd);
- init_backtrace (t);
- GNUNET_assert (0);
- }
- }
+ check_fd (t, NULL != read_nh ? GNUNET_NETWORK_get_fd (read_nh) : -1);
+ check_fd (t, NULL != write_nh ? GNUNET_NETWORK_get_fd (write_nh) : -1);
+ check_fd (t, NULL != read_fh ? read_fh->fd : -1);
+ check_fd (t, NULL != write_fh ? write_fh->fd : -1);
#endif
- t->read_fd = rfd;
- GNUNET_assert (wfd >= -1);
- t->write_fd = wfd;
#if PROFILE_DELAYS
t->start_time = GNUNET_TIME_absolute_get ();
#endif
t->timeout = GNUNET_TIME_relative_to_absolute (delay);
- t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority);
+ t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ?
+ current_priority : priority);
t->lifeness = current_lifeness;
GNUNET_CONTAINER_DLL_insert (pending_head,
pending_tail,
t);
+ driver_add_multiple (t);
max_priority_added = GNUNET_MAX (max_priority_added,
t->priority);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Adding task %p\n",
- t);
init_backtrace (t);
return t;
}
-#endif
/**
* used as a timeout on the socket being ready. The task will be
* scheduled for execution once either the delay has expired or the
* socket operation is ready. It will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param delay when should this operation time out?
* @param rfd read file-descriptor
void *task_cls)
{
return GNUNET_SCHEDULER_add_read_net_with_priority (delay,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- rfd, task, task_cls);
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ rfd, task, task_cls);
}
* socket being ready. The task will be scheduled for execution once
* either the delay has expired or the socket operation is ready. It
* will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param delay when should this operation time out?
* @param priority priority to use for the task
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- struct GNUNET_NETWORK_Handle *rfd,
- GNUNET_SCHEDULER_TaskCallback task,
+ enum GNUNET_SCHEDULER_Priority
+ priority,
+ struct GNUNET_NETWORK_Handle *rfd,
+ GNUNET_SCHEDULER_TaskCallback task,
void *task_cls)
{
return GNUNET_SCHEDULER_add_net_with_priority (delay, priority,
* scheduled for execution once either the delay has expired or the
* socket operation is ready. It will be run with the priority of
* the calling task.
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param delay when should this operation time out?
* @param wfd write file-descriptor
task, task_cls);
}
+
/**
* Schedule a new task to be run with a specified delay or when the
* specified file descriptor is ready. The delay can be
* used as a timeout on the socket being ready. The task will be
* scheduled for execution once either the delay has expired or the
* socket operation is ready.
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param delay when should this operation time out?
* @param priority priority of the task
* only valid until "task" is started!
*/
struct GNUNET_SCHEDULER_Task *
-GNUNET_SCHEDULER_add_net_with_priority (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- struct GNUNET_NETWORK_Handle *fd,
- int on_read,
- int on_write,
- GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+GNUNET_SCHEDULER_add_net_with_priority (struct GNUNET_TIME_Relative delay,
+ enum GNUNET_SCHEDULER_Priority priority,
+ struct GNUNET_NETWORK_Handle *fd,
+ int on_read,
+ int on_write,
+ GNUNET_SCHEDULER_TaskCallback task,
+ void *task_cls)
{
-#if MINGW
- struct GNUNET_NETWORK_FDSet *s;
- struct GNUNET_SCHEDULER_Task * ret;
-
- GNUNET_assert (NULL != fd);
- s = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_set (s, fd);
- ret = GNUNET_SCHEDULER_add_select (
- priority, delay,
- on_read ? s : NULL,
- on_write ? s : NULL,
- task, task_cls);
- GNUNET_NETWORK_fdset_destroy (s);
- return ret;
-#else
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
+ GNUNET_assert (on_read || on_write);
GNUNET_assert (GNUNET_NETWORK_get_fd (fd) >= 0);
return add_without_sets (delay, priority,
- on_read ? GNUNET_NETWORK_get_fd (fd) : -1,
- on_write ? GNUNET_NETWORK_get_fd (fd) : -1,
+ on_read ? fd : NULL,
+ on_write ? fd : NULL,
+ NULL,
+ NULL,
task, task_cls);
-#endif
}
* used as a timeout on the socket being ready. The task will be
* scheduled for execution once either the delay has expired or the
* socket operation is ready. It will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param delay when should this operation time out?
* @param rfd read file-descriptor
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
const struct GNUNET_DISK_FileHandle *rfd,
- GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
+ GNUNET_SCHEDULER_TaskCallback task,
+ void *task_cls)
{
return GNUNET_SCHEDULER_add_file_with_priority (
- delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- rfd, GNUNET_YES, GNUNET_NO,
- task, task_cls);
+ delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ rfd, GNUNET_YES, GNUNET_NO,
+ task, task_cls);
}
* used as a timeout on the socket being ready. The task will be
* scheduled for execution once either the delay has expired or the
* socket operation is ready. It will be run with the DEFAULT priority.
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param delay when should this operation time out?
* @param wfd write file-descriptor
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
const struct GNUNET_DISK_FileHandle *wfd,
- GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
+ GNUNET_SCHEDULER_TaskCallback task,
+ void *task_cls)
{
return GNUNET_SCHEDULER_add_file_with_priority (
- delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- wfd, GNUNET_NO, GNUNET_YES,
- task, task_cls);
+ delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ wfd, GNUNET_NO, GNUNET_YES,
+ task, task_cls);
}
* used as a timeout on the socket being ready. The task will be
* scheduled for execution once either the delay has expired or the
* socket operation is ready.
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param delay when should this operation time out?
* @param priority priority of the task
*/
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
- enum GNUNET_SCHEDULER_Priority priority,
- const struct GNUNET_DISK_FileHandle *fd,
+ enum GNUNET_SCHEDULER_Priority
+ priority,
+ const struct
+ GNUNET_DISK_FileHandle *fd,
int on_read, int on_write,
- GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
+ GNUNET_SCHEDULER_TaskCallback task,
+ void *task_cls)
{
-#if MINGW
- struct GNUNET_NETWORK_FDSet *s;
- struct GNUNET_SCHEDULER_Task * ret;
-
- GNUNET_assert (NULL != fd);
- s = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_handle_set (s, fd);
- ret = GNUNET_SCHEDULER_add_select (
- priority, delay,
- on_read ? s : NULL,
- on_write ? s : NULL,
- task, task_cls);
- GNUNET_NETWORK_fdset_destroy (s);
- return ret;
-#else
- int real_fd;
-
- GNUNET_DISK_internal_file_handle_ (fd, &real_fd, sizeof (int));
- GNUNET_assert (real_fd >= 0);
- return add_without_sets (
- delay, priority,
- on_read ? real_fd : -1,
- on_write ? real_fd : -1,
- task, task_cls);
-#endif
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
+ GNUNET_assert (on_read || on_write);
+ GNUNET_assert (fd->fd >= 0);
+ return add_without_sets (delay, priority,
+ NULL,
+ NULL,
+ on_read ? fd : NULL,
+ on_write ? fd : NULL,
+ task, task_cls);
+}
+
+
+void
+extract_handles (const struct GNUNET_NETWORK_FDSet *fdset,
+ const struct GNUNET_NETWORK_Handle ***ntarget,
+ unsigned int *extracted_nhandles,
+ const struct GNUNET_DISK_FileHandle ***ftarget,
+ unsigned int *extracted_fhandles)
+{
+ // FIXME: this implementation only works for unix, for WIN32 the file handles
+ // in fdset must be handled separately
+ const struct GNUNET_NETWORK_Handle **nhandles;
+ const struct GNUNET_DISK_FileHandle **fhandles;
+ unsigned int nhandles_len;
+ unsigned int fhandles_len;
+
+ nhandles = NULL;
+ fhandles = NULL;
+ nhandles_len = 0;
+ fhandles_len = 0;
+ for (int sock = 0; sock != fdset->nsds; ++sock)
+ {
+ if (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (fdset, sock))
+ {
+ struct GNUNET_NETWORK_Handle *nhandle;
+ struct GNUNET_DISK_FileHandle *fhandle;
+
+ nhandle = GNUNET_NETWORK_socket_box_native (sock);
+ if (NULL != nhandle)
+ {
+ GNUNET_array_append (nhandles, nhandles_len, nhandle);
+ }
+ else
+ {
+ fhandle = GNUNET_DISK_get_handle_from_int_fd (sock);
+ if (NULL != fhandle)
+ {
+ GNUNET_array_append (fhandles, fhandles_len, fhandle);
+ }
+ else
+ {
+ GNUNET_assert (0);
+ }
+ }
+ }
+ }
+ *ntarget = nhandles_len > 0 ? nhandles : NULL;
+ *ftarget = fhandles_len > 0 ? fhandles : NULL;
+ *extracted_nhandles = nhandles_len;
+ *extracted_fhandles = fhandles_len;
}
* || any-rs-ready
* || any-ws-ready) )
* </code>
+ * Only allowed to be called as long as the scheduler is running, that
+ * is one of the following conditions is met:
+ *
+ * - #GNUNET_SCHEDULER_run has been called and has not returned yet
+ * - #GNUNET_SCHEDULER_driver_init has been run and
+ * #GNUNET_SCHEDULER_driver_done has not been called yet
*
* @param prio how important is this task?
* @param delay how long should we wait?
void *task_cls)
{
struct GNUNET_SCHEDULER_Task *t;
-
- if ( (NULL == rs) &&
- (NULL == ws) )
+ const struct GNUNET_NETWORK_Handle **read_nhandles = NULL;
+ const struct GNUNET_NETWORK_Handle **write_nhandles = NULL;
+ const struct GNUNET_DISK_FileHandle **read_fhandles = NULL;
+ const struct GNUNET_DISK_FileHandle **write_fhandles = NULL;
+ unsigned int read_nhandles_len = 0;
+ unsigned int write_nhandles_len = 0;
+ unsigned int read_fhandles_len = 0;
+ unsigned int write_fhandles_len = 0;
+
+ /* scheduler must be running */
+ GNUNET_assert (NULL != scheduler_driver);
+ GNUNET_assert (NULL != task);
+ int no_rs = (NULL == rs);
+ int no_ws = (NULL == ws);
+ int empty_rs = (NULL != rs) && (0 == rs->nsds);
+ int empty_ws = (NULL != ws) && (0 == ws->nsds);
+ int no_fds = (no_rs && no_ws) ||
+ (empty_rs && empty_ws) ||
+ (no_rs && empty_ws) ||
+ (no_ws && empty_rs);
+ if (! no_fds)
+ {
+ if (NULL != rs)
+ {
+ extract_handles (rs,
+ &read_nhandles,
+ &read_nhandles_len,
+ &read_fhandles,
+ &read_fhandles_len);
+ }
+ if (NULL != ws)
+ {
+ extract_handles (ws,
+ &write_nhandles,
+ &write_nhandles_len,
+ &write_fhandles,
+ &write_fhandles_len);
+ }
+ }
+ /**
+ * here we consider the case that a GNUNET_NETWORK_FDSet might be empty
+ * although its maximum FD number (nsds) is greater than 0. We handle
+ * this case gracefully because some libraries such as libmicrohttpd
+ * only provide a hint what the maximum FD number in an FD set might be
+ * and not the exact FD number (see e.g. gnunet-rest-service.c)
+ */int no_fds_extracted = (0 == read_nhandles_len) &&
+ (0 == read_fhandles_len) &&
+ (0 == write_nhandles_len) &&
+ (0 == write_fhandles_len);
+ if (no_fds || no_fds_extracted)
return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
prio,
task,
task_cls);
- GNUNET_assert (NULL != active_task);
- GNUNET_assert (NULL != task);
t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+ GNUNET_async_scope_get (&t->scope);
+ init_fd_info (t,
+ read_nhandles,
+ read_nhandles_len,
+ write_nhandles,
+ write_nhandles_len,
+ read_fhandles,
+ read_fhandles_len,
+ write_fhandles,
+ write_fhandles_len);
t->callback = task;
t->callback_cls = task_cls;
- t->read_fd = -1;
- t->write_fd = -1;
- if (NULL != rs)
- {
- t->read_set = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_copy (t->read_set, rs);
- }
- if (NULL != ws)
- {
- t->write_set = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_copy (t->write_set, ws);
- }
+ t->own_handles = GNUNET_YES;
+ /* free the arrays of pointers to network / file handles, the actual
+ * handles will be freed in destroy_task */
+ GNUNET_array_grow (read_nhandles, read_nhandles_len, 0);
+ GNUNET_array_grow (write_nhandles, write_nhandles_len, 0);
+ GNUNET_array_grow (read_fhandles, read_fhandles_len, 0);
+ GNUNET_array_grow (write_fhandles, write_fhandles_len, 0);
#if PROFILE_DELAYS
t->start_time = GNUNET_TIME_absolute_get ();
#endif
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;
GNUNET_CONTAINER_DLL_insert (pending_head,
pending_tail,
t);
+ driver_add_multiple (t);
max_priority_added = GNUNET_MAX (max_priority_added,
- t->priority);
+ t->priority);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Adding task %p\n",
t);
/**
* Function used by event-loop implementations to signal the scheduler
- * that a particular @a task is ready due to an event of type @a et.
+ * that a particular @a task is ready due to an event specified in the
+ * et field of @a fdi.
*
* This function will then queue the task to notify the application
* that the task is ready (with the respective priority).
*
- * @param task the task that is ready, NULL for wake up calls
- * @param et information about why the task is ready
+ * @param task the task that is ready
+ * @param fdi information about the related FD
*/
void
GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
- enum GNUNET_SCHEDULER_EventType et)
+ struct GNUNET_SCHEDULER_FdInfo *fdi)
{
enum GNUNET_SCHEDULER_Reason reason;
- struct GNUNET_TIME_Absolute now;
- now = GNUNET_TIME_absolute_get ();
reason = task->reason;
- if (now.abs_value_us >= task->timeout.abs_value_us)
- reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
- if ( (0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
- (0 != (GNUNET_SCHEDULER_ET_IN & et)) )
+ if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
+ (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et)))
reason |= GNUNET_SCHEDULER_REASON_READ_READY;
- if ( (0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
- (0 != (GNUNET_SCHEDULER_ET_OUT & et)) )
+ if ((0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
+ (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et)))
reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
task->reason = reason;
- task->fds = &task->fdx;
- task->fdx.et = et;
- task->fds_len = 1;
- queue_ready_task (task);
+ if (GNUNET_NO == task->in_ready_list)
+ {
+ GNUNET_CONTAINER_DLL_remove (pending_head,
+ pending_tail,
+ task);
+ queue_ready_task (task);
+ }
}
/**
- * Function called by the driver to tell the scheduler to run some of
- * the tasks that are ready. This function may return even though
- * there are tasks left to run just to give other tasks a chance as
- * well. If we return #GNUNET_YES, the driver should call this
- * function again as soon as possible, while if we return #GNUNET_NO
- * it must block until the operating system has more work as the
- * scheduler has no more work to do right now.
+ * Function called by external event loop implementations to tell the
+ * scheduler to run some of the tasks that are ready. Must be called
+ * only after #GNUNET_SCHEDULER_driver_init has been called and before
+ * #GNUNET_SCHEDULER_driver_done is called.
+ * This function may return even though there are tasks left to run
+ * just to give other tasks a chance as well. If we return #GNUNET_YES,
+ * the event loop implementation should call this function again as
+ * soon as possible, while if we return #GNUNET_NO it must block until
+ * either the operating system has more work (the scheduler has no more
+ * work to do right now) or the timeout set by the scheduler (using the
+ * set_wakeup callback) is reached.
*
- * @param sh scheduler handle that was given to the `loop`
- * @return #GNUNET_OK if there are more tasks that are ready,
- * and thus we would like to run more (yield to avoid
- * blocking other activities for too long)
- * #GNUNET_NO if we are done running tasks (yield to block)
- * #GNUNET_SYSERR on error
+ * @param sh scheduler handle that was returned by
+ * #GNUNET_SCHEDULER_driver_init
+ * @return #GNUNET_YES if there are more tasks that are ready,
+ * and thus we would like to run more (yield to avoid
+ * blocking other activities for too long) #GNUNET_NO
+ * if we are done running tasks (yield to block)
*/
int
-GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
+GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh)
{
enum GNUNET_SCHEDULER_Priority p;
struct GNUNET_SCHEDULER_Task *pos;
/* check for tasks that reached the timeout! */
now = GNUNET_TIME_absolute_get ();
- while (NULL != (pos = pending_timeout_head))
+ pos = pending_timeout_head;
+ while (NULL != pos)
{
+ struct GNUNET_SCHEDULER_Task *next = pos->next;
if (now.abs_value_us >= pos->timeout.abs_value_us)
pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
if (0 == pos->reason)
if (pending_timeout_last == pos)
pending_timeout_last = NULL;
queue_ready_task (pos);
+ pos = next;
+ }
+ pos = pending_head;
+ while (NULL != pos)
+ {
+ struct GNUNET_SCHEDULER_Task *next = pos->next;
+ if (now.abs_value_us >= pos->timeout.abs_value_us)
+ {
+ pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+ GNUNET_CONTAINER_DLL_remove (pending_head,
+ pending_tail,
+ pos);
+ queue_ready_task (pos);
+ }
+ pos = next;
}
if (0 == ready_count)
- return GNUNET_NO;
-
- /* find out which task priority level we are going to
- process this time */
- max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
- GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
- /* 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_head[p];
- if (NULL != pos)
- break;
- }
- GNUNET_assert (NULL != pos); /* ready_count wrong? */
+ struct GNUNET_TIME_Absolute timeout = get_timeout ();
- /* process all tasks at this priority level, then yield */
- while (NULL != (pos = ready_head[p]))
+ if (timeout.abs_value_us > now.abs_value_us)
+ {
+ /**
+ * The event loop called this function before the current timeout was
+ * reached (and no FD tasks are ready). This is acceptable if
+ *
+ * - the system time was changed while the driver was waiting for
+ * the timeout
+ * - an external event loop called GNUnet API functions outside of
+ * the callbacks called in GNUNET_SCHEDULER_do_work and thus
+ * wasn't notified about the new timeout
+ *
+ * It might also mean we are busy-waiting because of a programming
+ * error in the external event loop.
+ */LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "GNUNET_SCHEDULER_do_work did not find any ready "
+ "tasks and timeout has not been reached yet.\n");
+ }
+ else
+ {
+ /**
+ * the current timeout was reached but no ready tasks were found,
+ * internal scheduler error!
+ */
+ GNUNET_assert (0);
+ }
+ }
+ else
{
- GNUNET_CONTAINER_DLL_remove (ready_head[p],
- ready_tail[p],
- pos);
- ready_count--;
- current_priority = pos->priority;
- current_lifeness = pos->lifeness;
- active_task = pos;
-#if PROFILE_DELAYS
- if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
- DELAY_THRESHOLD.rel_value_us)
+ /* find out which task priority level we are going to
+ process this time */
+ max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
+ GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
+ /* 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--)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Task %p took %s to be scheduled\n",
- pos,
- GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
- GNUNET_YES));
+ pos = ready_head[p];
+ if (NULL != pos)
+ break;
}
+ GNUNET_assert (NULL != pos); /* ready_count wrong? */
+
+ /* process all tasks at this priority level, then yield */
+ while (NULL != (pos = ready_head[p]))
+ {
+ GNUNET_CONTAINER_DLL_remove (ready_head[p],
+ ready_tail[p],
+ pos);
+ ready_count--;
+ current_priority = pos->priority;
+ current_lifeness = pos->lifeness;
+ active_task = pos;
+#if PROFILE_DELAYS
+ if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
+ DELAY_THRESHOLD.rel_value_us)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Task %p took %s to be scheduled\n",
+ pos,
+ GNUNET_STRINGS_relative_time_to_string (
+ GNUNET_TIME_absolute_get_duration (pos->start_time),
+ GNUNET_YES));
+ }
#endif
- tc.reason = pos->reason;
- GNUNET_NETWORK_fdset_zero (sh->rs);
- GNUNET_NETWORK_fdset_zero (sh->ws);
- tc.fds_len = pos->fds_len;
- tc.fds = pos->fds;
- tc.read_ready = (NULL == pos->read_set) ? sh->rs : pos->read_set;
- if ( (-1 != pos->read_fd) &&
- (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)) )
- GNUNET_NETWORK_fdset_set_native (sh->rs,
- pos->read_fd);
- tc.write_ready = (NULL == pos->write_set) ? sh->ws : pos->write_set;
- if ((-1 != pos->write_fd) &&
- (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
- GNUNET_NETWORK_fdset_set_native (sh->ws,
- pos->write_fd);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Running task: %p\n",
- pos);
- pos->callback (pos->callback_cls);
- active_task = NULL;
- dump_backtrace (pos);
- destroy_task (pos);
- tasks_run++;
+ tc.reason = pos->reason;
+ GNUNET_NETWORK_fdset_zero (sh->rs);
+ GNUNET_NETWORK_fdset_zero (sh->ws);
+ // FIXME: do we have to remove FdInfos from fds if they are not ready?
+ tc.fds_len = pos->fds_len;
+ tc.fds = pos->fds;
+ for (unsigned int i = 0; i != pos->fds_len; ++i)
+ {
+ struct GNUNET_SCHEDULER_FdInfo *fdi = &pos->fds[i];
+ if (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et))
+ {
+ GNUNET_NETWORK_fdset_set_native (sh->rs,
+ fdi->sock);
+ }
+ if (0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et))
+ {
+ GNUNET_NETWORK_fdset_set_native (sh->ws,
+ fdi->sock);
+ }
+ }
+ tc.read_ready = sh->rs;
+ tc.write_ready = sh->ws;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Running task %p\n",
+ pos);
+ GNUNET_assert (NULL != pos->callback);
+ {
+ struct GNUNET_AsyncScopeSave old_scope;
+ if (pos->scope.have_scope)
+ GNUNET_async_scope_enter (&pos->scope.scope_id, &old_scope);
+ else
+ GNUNET_async_scope_get (&old_scope);
+ pos->callback (pos->callback_cls);
+ GNUNET_async_scope_restore (&old_scope);
+ }
+ if (NULL != pos->fds)
+ {
+ int del_result = scheduler_driver->del (scheduler_driver->cls, pos);
+ if (GNUNET_OK != del_result)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "driver could not delete task %p\n", pos);
+ GNUNET_assert (0);
+ }
+ }
+ active_task = NULL;
+ dump_backtrace (pos);
+ destroy_task (pos);
+ }
}
+ shutdown_if_no_lifeness ();
if (0 == ready_count)
+ {
+ scheduler_driver->set_wakeup (scheduler_driver->cls,
+ get_timeout ());
return GNUNET_NO;
- return GNUNET_OK;
+ }
+ scheduler_driver->set_wakeup (scheduler_driver->cls,
+ GNUNET_TIME_absolute_get ());
+ return GNUNET_YES;
}
/**
- * Initialize and run scheduler. This function will return when all
- * tasks have completed. On systems with signals, receiving a SIGTERM
- * (and other similar signals) will cause #GNUNET_SCHEDULER_shutdown
- * to be run after the active task is complete. As a result, SIGTERM
- * causes all shutdown tasks to be scheduled with reason
- * #GNUNET_SCHEDULER_REASON_SHUTDOWN. (However, tasks added
- * afterwards will execute normally!). Note that any particular
- * signal will only shut down one scheduler; applications should
- * always only create a single scheduler.
+ * Function called by external event loop implementations to initialize
+ * the scheduler. An external implementation has to provide @a driver
+ * which contains callbacks for the scheduler (see definition of struct
+ * #GNUNET_SCHEDULER_Driver). The callbacks are used to instruct the
+ * external implementation to watch for events. If it detects any of
+ * those events it is expected to call #GNUNET_SCHEDULER_do_work to let
+ * the scheduler handle it. If an event is related to a specific task
+ * (e.g. the scheduler gave instructions to watch a file descriptor),
+ * the external implementation is expected to mark that task ready
+ * before by calling #GNUNET_SCHEDULER_task_ready.
+
+ * This function has to be called before any tasks are scheduled and
+ * before GNUNET_SCHEDULER_do_work is called for the first time. It
+ * allocates resources that have to be freed again by calling
+ * #GNUNET_SCHEDULER_driver_done.
*
- * @param driver drive to use for the event loop
- * @param task task to run first (and immediately)
- * @param task_cls closure of @a task
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ * This function installs the same signal handlers as
+ * #GNUNET_SCHEDULER_run. This means SIGTERM (and other similar signals)
+ * will induce a call to #GNUNET_SCHEDULER_shutdown during the next
+ * call to #GNUNET_SCHEDULER_do_work. As a result, SIGTERM causes all
+ * active tasks to be scheduled with reason
+ * #GNUNET_SCHEDULER_REASON_SHUTDOWN. (However, tasks added afterwards
+ * will execute normally!). Note that any particular signal will only
+ * shut down one scheduler; applications should always only create a
+ * single scheduler.
+ *
+ * @param driver to use for the event loop
+ * @return handle to be passed to #GNUNET_SCHEDULER_do_work and
+ * #GNUNET_SCHEDULER_driver_done
*/
-int
-GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
- GNUNET_SCHEDULER_TaskCallback task,
- void *task_cls)
+struct GNUNET_SCHEDULER_Handle *
+GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver)
{
- int ret;
- struct GNUNET_SIGNAL_Context *shc_int;
- struct GNUNET_SIGNAL_Context *shc_term;
-#if (SIGTERM != GNUNET_TERM_SIG)
- struct GNUNET_SIGNAL_Context *shc_gterm;
-#endif
-#ifndef MINGW
- struct GNUNET_SIGNAL_Context *shc_quit;
- struct GNUNET_SIGNAL_Context *shc_hup;
- struct GNUNET_SIGNAL_Context *shc_pipe;
-#endif
- struct GNUNET_SCHEDULER_Task tsk;
+ struct GNUNET_SCHEDULER_Handle *sh;
const struct GNUNET_DISK_FileHandle *pr;
- struct GNUNET_SCHEDULER_Handle sh;
- /* general set-up */
- GNUNET_assert (NULL == active_task);
+ /* scheduler must not be running */
+ GNUNET_assert (NULL == scheduler_driver);
GNUNET_assert (NULL == shutdown_pipe_handle);
+ /* general set-up */
+ sh = GNUNET_new (struct GNUNET_SCHEDULER_Handle);
shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
GNUNET_NO,
GNUNET_NO,
GNUNET_assert (NULL != shutdown_pipe_handle);
pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
GNUNET_DISK_PIPE_END_READ);
- GNUNET_assert (NULL != pr);
my_pid = getpid ();
+ scheduler_driver = driver;
/* install signal handlers */
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Registering signal handlers\n");
- shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
- &sighandler_shutdown);
- shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
- &sighandler_shutdown);
+ sh->shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
+ &sighandler_shutdown);
+ sh->shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
+ &sighandler_shutdown);
#if (SIGTERM != GNUNET_TERM_SIG)
- shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
- &sighandler_shutdown);
-#endif
-#ifndef MINGW
- shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
- &sighandler_pipe);
- shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
- &sighandler_shutdown);
- shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
- &sighandler_shutdown);
+ sh->shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
+ &sighandler_shutdown);
#endif
+ sh->shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
+ &sighandler_pipe);
+ sh->shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
+ &sighandler_shutdown);
+ sh->shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
+ &sighandler_shutdown);
/* Setup initial tasks */
current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
+ current_lifeness = GNUNET_NO;
+ install_parent_control_task =
+ GNUNET_SCHEDULER_add_now (&install_parent_control_handler,
+ NULL);
+ shutdown_pipe_task =
+ GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+ pr,
+ &shutdown_pipe_cb,
+ NULL);
current_lifeness = GNUNET_YES;
- memset (&tsk,
- 0,
- sizeof (tsk));
- active_task = &tsk;
- tsk.sh = &sh;
- GNUNET_SCHEDULER_add_with_reason_and_priority (task,
- task_cls,
- GNUNET_SCHEDULER_REASON_STARTUP,
- GNUNET_SCHEDULER_PRIORITY_DEFAULT);
- GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
- &GNUNET_OS_install_parent_control_handler,
- NULL);
- active_task = NULL;
- driver->set_wakeup (driver->cls,
- GNUNET_TIME_absolute_get ());
-
+ scheduler_driver->set_wakeup (scheduler_driver->cls,
+ get_timeout ());
/* begin main event loop */
- sh.rs = GNUNET_NETWORK_fdset_create ();
- sh.ws = GNUNET_NETWORK_fdset_create ();
- sh.driver = driver;
- ret = driver->loop (driver->cls,
- &sh);
- GNUNET_NETWORK_fdset_destroy (sh.rs);
- GNUNET_NETWORK_fdset_destroy (sh.ws);
+ sh->rs = GNUNET_NETWORK_fdset_create ();
+ sh->ws = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_handle_set (sh->rs, pr);
+ return sh;
+}
+
+
+/**
+ * Counter-part of #GNUNET_SCHEDULER_driver_init. Has to be called
+ * by external event loop implementations after the scheduler has
+ * shut down. This is the case if both of the following conditions
+ * are met:
+ *
+ * - all tasks the scheduler has added through the driver's add
+ * callback have been removed again through the driver's del
+ * callback
+ * - the timeout the scheduler has set through the driver's
+ * add_wakeup callback is FOREVER
+ *
+ * @param sh the handle returned by #GNUNET_SCHEDULER_driver_init
+ */
+void
+GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh)
+{
+ GNUNET_assert (NULL == pending_head);
+ GNUNET_assert (NULL == pending_timeout_head);
+ GNUNET_assert (NULL == shutdown_head);
+ for (int i = 0; i != GNUNET_SCHEDULER_PRIORITY_COUNT; ++i)
+ {
+ GNUNET_assert (NULL == ready_head[i]);
+ }
+ GNUNET_NETWORK_fdset_destroy (sh->rs);
+ GNUNET_NETWORK_fdset_destroy (sh->ws);
/* uninstall signal handlers */
- GNUNET_SIGNAL_handler_uninstall (shc_int);
- GNUNET_SIGNAL_handler_uninstall (shc_term);
+ GNUNET_SIGNAL_handler_uninstall (sh->shc_int);
+ GNUNET_SIGNAL_handler_uninstall (sh->shc_term);
#if (SIGTERM != GNUNET_TERM_SIG)
- GNUNET_SIGNAL_handler_uninstall (shc_gterm);
-#endif
-#ifndef MINGW
- GNUNET_SIGNAL_handler_uninstall (shc_pipe);
- GNUNET_SIGNAL_handler_uninstall (shc_quit);
- GNUNET_SIGNAL_handler_uninstall (shc_hup);
+ GNUNET_SIGNAL_handler_uninstall (sh->shc_gterm);
#endif
+ GNUNET_SIGNAL_handler_uninstall (sh->shc_pipe);
+ GNUNET_SIGNAL_handler_uninstall (sh->shc_quit);
+ GNUNET_SIGNAL_handler_uninstall (sh->shc_hup);
GNUNET_DISK_pipe_close (shutdown_pipe_handle);
shutdown_pipe_handle = NULL;
+ scheduler_driver = NULL;
+ GNUNET_free (sh);
+}
+
+
+static int
+select_loop (struct GNUNET_SCHEDULER_Handle *sh,
+ struct DriverContext *context)
+{
+ struct GNUNET_NETWORK_FDSet *rs;
+ struct GNUNET_NETWORK_FDSet *ws;
+ int select_result;
+
+ GNUNET_assert (NULL != context);
+ rs = GNUNET_NETWORK_fdset_create ();
+ ws = GNUNET_NETWORK_fdset_create ();
+ while ((NULL != context->scheduled_head) ||
+ (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us !=
+ context->timeout.abs_value_us))
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "select timeout = %s\n",
+ GNUNET_STRINGS_absolute_time_to_string (context->timeout));
+
+ GNUNET_NETWORK_fdset_zero (rs);
+ GNUNET_NETWORK_fdset_zero (ws);
+
+ for (struct Scheduled *pos = context->scheduled_head;
+ NULL != pos;
+ pos = pos->next)
+ {
+ if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et))
+ {
+ GNUNET_NETWORK_fdset_set_native (rs, pos->fdi->sock);
+ }
+ if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et))
+ {
+ GNUNET_NETWORK_fdset_set_native (ws, pos->fdi->sock);
+ }
+ }
+ struct GNUNET_TIME_Relative time_remaining =
+ GNUNET_TIME_absolute_get_remaining (context->timeout);
+ if (NULL == scheduler_select)
+ {
+ select_result = GNUNET_NETWORK_socket_select (rs,
+ ws,
+ NULL,
+ time_remaining);
+ }
+ else
+ {
+ select_result = scheduler_select (scheduler_select_cls,
+ rs,
+ ws,
+ NULL,
+ time_remaining);
+ }
+ if (select_result == GNUNET_SYSERR)
+ {
+ if (errno == EINTR)
+ continue;
+
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "select");
+#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))
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
+ "system");
+#endif
+#if DEBUG_FDS
+ for (struct Scheduled *s = context->scheduled_head;
+ NULL != s;
+ s = s->next)
+ {
+ int flags = fcntl (s->fdi->sock,
+ F_GETFD);
+
+ if ((flags == -1) &&
+ (EBADF == errno))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Got invalid file descriptor %d!\n",
+ s->fdi->sock);
+#if EXECINFO
+ dump_backtrace (s->task);
+#endif
+ }
+ }
+#endif
+ GNUNET_assert (0);
+ GNUNET_NETWORK_fdset_destroy (rs);
+ GNUNET_NETWORK_fdset_destroy (ws);
+ return GNUNET_SYSERR;
+ }
+ if (select_result > 0)
+ {
+ for (struct Scheduled *pos = context->scheduled_head;
+ NULL != pos;
+ pos = pos->next)
+ {
+ int is_ready = GNUNET_NO;
+
+ if ((0 != (GNUNET_SCHEDULER_ET_IN & pos->et)) &&
+ (GNUNET_YES ==
+ GNUNET_NETWORK_fdset_test_native (rs,
+ pos->fdi->sock)) )
+ {
+ pos->fdi->et |= GNUNET_SCHEDULER_ET_IN;
+ is_ready = GNUNET_YES;
+ }
+ if ((0 != (GNUNET_SCHEDULER_ET_OUT & pos->et)) &&
+ (GNUNET_YES ==
+ GNUNET_NETWORK_fdset_test_native (ws,
+ pos->fdi->sock)) )
+ {
+ pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT;
+ is_ready = GNUNET_YES;
+ }
+ if (GNUNET_YES == is_ready)
+ {
+ GNUNET_SCHEDULER_task_ready (pos->task,
+ pos->fdi);
+ }
+ }
+ }
+ if (GNUNET_YES == GNUNET_SCHEDULER_do_work (sh))
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "scheduler has more tasks ready!\n");
+ }
+ }
+ GNUNET_NETWORK_fdset_destroy (rs);
+ GNUNET_NETWORK_fdset_destroy (ws);
+ return GNUNET_OK;
+}
+
+
+static int
+select_add (void *cls,
+ struct GNUNET_SCHEDULER_Task *task,
+ struct GNUNET_SCHEDULER_FdInfo *fdi)
+{
+ struct DriverContext *context = cls;
+
+ GNUNET_assert (NULL != context);
+ GNUNET_assert (NULL != task);
+ GNUNET_assert (NULL != fdi);
+ GNUNET_assert (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et) ||
+ 0 != (GNUNET_SCHEDULER_ET_OUT & fdi->et));
+
+ if (! ((NULL != fdi->fd) ^ (NULL != fdi->fh)) || (fdi->sock < 0))
+ {
+ /* exactly one out of {fd, hf} must be != NULL and the OS handle must be valid */
+ return GNUNET_SYSERR;
+ }
+
+ struct Scheduled *scheduled = GNUNET_new (struct Scheduled);
+ scheduled->task = task;
+ scheduled->fdi = fdi;
+ scheduled->et = fdi->et;
+
+ GNUNET_CONTAINER_DLL_insert (context->scheduled_head,
+ context->scheduled_tail,
+ scheduled);
+ return GNUNET_OK;
+}
+
+
+static int
+select_del (void *cls,
+ struct GNUNET_SCHEDULER_Task *task)
+{
+ struct DriverContext *context;
+ struct Scheduled *pos;
+ int ret;
+
+ GNUNET_assert (NULL != cls);
+
+ context = cls;
+ ret = GNUNET_SYSERR;
+ pos = context->scheduled_head;
+ while (NULL != pos)
+ {
+ struct Scheduled *next = pos->next;
+ if (pos->task == task)
+ {
+ GNUNET_CONTAINER_DLL_remove (context->scheduled_head,
+ context->scheduled_tail,
+ pos);
+ GNUNET_free (pos);
+ ret = GNUNET_OK;
+ }
+ pos = next;
+ }
return ret;
}
+static void
+select_set_wakeup (void *cls,
+ struct GNUNET_TIME_Absolute dt)
+{
+ struct DriverContext *context = cls;
+
+ GNUNET_assert (NULL != context);
+ context->timeout = dt;
+}
+
+
/**
* Obtain the driver for using select() as the event loop.
*
* @return NULL on error
*/
-const struct GNUNET_SCHEDULER_Driver *
+struct GNUNET_SCHEDULER_Driver *
GNUNET_SCHEDULER_driver_select ()
{
- GNUNET_break (0); // not implemented
- return NULL;
+ struct GNUNET_SCHEDULER_Driver *select_driver;
+
+ select_driver = GNUNET_new (struct GNUNET_SCHEDULER_Driver);
+
+ select_driver->add = &select_add;
+ select_driver->del = &select_del;
+ select_driver->set_wakeup = &select_set_wakeup;
+
+ return select_driver;
+}
+
+
+/**
+ * Change the async scope for the currently executing task and (transitively)
+ * for all tasks scheduled by the current task after calling this function.
+ * Nested tasks can begin their own nested async scope.
+ *
+ * Once the current task is finished, the async scope ID is reset to
+ * its previous value.
+ *
+ * Must only be called from a running task.
+ *
+ * @param aid the asynchronous scope id to enter
+ */
+void
+GNUNET_SCHEDULER_begin_async_scope (struct GNUNET_AsyncScopeId *aid)
+{
+ struct GNUNET_AsyncScopeSave dummy_old_scope;
+
+ GNUNET_assert (NULL != active_task);
+ /* Since we're in a task, the context will be automatically
+ restored by the scheduler. */
+ GNUNET_async_scope_enter (aid, &dummy_old_scope);
}
projects / oweals / gnunet.git / blobdiff