scheduler.c File Reference

main event loop we use for most processes, schedules computations based on time or network events with priorities More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include <inttypes.h>

Include dependency graph for scheduler.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_SCHEDULER_Handle
	Argument to be passed from the driver to GNUNET_SCHEDULER_do_work(). More...
struct	GNUNET_SCHEDULER_Task
	Entry in list of pending tasks. More...
struct	Scheduled
	A struct representing an event the select driver is waiting for. More...
struct	DriverContext
	Driver context used by GNUNET_SCHEDULER_run. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)
#define	LOG_STRERROR(kind, syscall)
#define	PROFILE_DELAYS   GNUNET_NO
	Should we figure out which tasks are delayed for a while before they are run? (Consider using in combination with EXECINFO).
#define	DELAY_THRESHOLD   GNUNET_TIME_UNIT_SECONDS
	Task that were in the queue for longer than this are reported if PROFILE_DELAYS is active.

Functions
void	GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select, void *new_select_cls)
	Sets the select function to use in the scheduler (scheduler_select).
static enum GNUNET_SCHEDULER_Priority	check_priority (enum GNUNET_SCHEDULER_Priority p)
	Check that the given priority is legal (and return it).
static struct GNUNET_TIME_Absolute	get_timeout ()
	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	remove_pass_end_marker ()
static void	set_work_priority (enum GNUNET_SCHEDULER_Priority p)
static void	queue_ready_task (struct GNUNET_SCHEDULER_Task *task)
	Put a task that is ready for execution into the ready queue.
void	GNUNET_SCHEDULER_shutdown ()
	Request the shutdown of a scheduler.
static void	dump_backtrace (struct GNUNET_SCHEDULER_Task *t)
	Output stack trace of task t.
static void	destroy_task (struct GNUNET_SCHEDULER_Task *t)
	Destroy a task (release associated resources)
static void	sighandler_pipe ()
	Signal handler called for SIGPIPE.
static void	sighandler_shutdown (void)
	Signal handler called for signals that should cause us to shutdown.
static void	shutdown_if_no_lifeness (void)
static enum GNUNET_GenericReturnValue	select_loop (struct GNUNET_SCHEDULER_Handle *sh, struct DriverContext *context)
void	GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Initialize and run scheduler.
const struct GNUNET_SCHEDULER_TaskContext *	GNUNET_SCHEDULER_get_task_context ()
	Obtain the task context, giving the reason why the current task was started.
unsigned int	GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
	Get information about the current load of this scheduler.
static 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)
static void	driver_add_multiple (struct GNUNET_SCHEDULER_Task *t)
	calls the given function func on each FdInfo related to t.
static void	install_parent_control_handler (void *cls)
static void	shutdown_pipe_cb (void *cls)
void *	GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
	Cancel the task with the specified identifier.
static void	init_backtrace (struct GNUNET_SCHEDULER_Task *t)
	Initialize backtrace data for task t.
void	GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback task, void *task_cls, enum GNUNET_SCHEDULER_Reason reason, enum GNUNET_SCHEDULER_Priority priority)
	Continue the current execution with the given function.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run at the specified time.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run with a specified delay.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run with a specified priority.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run at the specified time.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run with a specified delay.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run as soon as possible.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run as soon as possible with the (transitive) ignore-shutdown flag either explicitly set or explicitly enabled.
static struct GNUNET_SCHEDULER_Task *	add_without_sets (struct GNUNET_TIME_Relative delay, 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)
	Schedule a new task to be run with a specified delay or when any of the specified file descriptor sets is ready.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run with a specified delay or when the specified file descriptor is ready for reading.
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, void *task_cls)
	Schedule a new task to be run with a specified priority and to be run after the specified delay or when the specified file descriptor is ready for reading.
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run with a specified delay or when the specified file descriptor is ready for writing.
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)
	Schedule a new task to be run with a specified delay or when the specified file descriptor is ready.
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)
	Schedule a new task to be run with a specified delay or when the specified file descriptor is ready for reading.
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)
	Schedule a new task to be run with a specified delay or when the specified file descriptor is ready for writing.
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, int on_read, int on_write, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run with a specified delay or when the specified file descriptor is ready.
static 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)
struct GNUNET_SCHEDULER_Task *	GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Schedule a new task to be run with a specified delay or when any of the specified file descriptor sets is ready.
void	GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task, struct GNUNET_SCHEDULER_FdInfo *fdi)
	Function used by event-loop implementations to signal the scheduler that a particular task is ready due to an event specified in the et field of fdi.
int	GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh)
	Function called by external event loop implementations to tell the scheduler to run some of the tasks that are ready.
struct GNUNET_SCHEDULER_Handle *	GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver)
	Function called by external event loop implementations to initialize the scheduler.
void	GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh)
	Counter-part of GNUNET_SCHEDULER_driver_init.
static int	select_add (void *cls, struct GNUNET_SCHEDULER_Task *task, struct GNUNET_SCHEDULER_FdInfo *fdi)
static int	select_del (void *cls, struct GNUNET_SCHEDULER_Task *task)
static void	select_set_wakeup (void *cls, struct GNUNET_TIME_Absolute dt)
struct GNUNET_SCHEDULER_Driver *	GNUNET_SCHEDULER_driver_select ()
	Obtain the driver for using select() as the event loop.
void	GNUNET_SCHEDULER_begin_async_scope (struct GNUNET_AsyncScopeId *aid)
	Change the async scope for the currently executing task and (transitively) for all tasks scheduled by the current task after calling this function.

Variables
static struct GNUNET_SCHEDULER_Task	pass_end_marker
	Placed at the end of a ready queue to indicate where a scheduler run pass ends.
static const struct GNUNET_SCHEDULER_Driver *	scheduler_driver
	The driver used for the event loop.
static struct GNUNET_SCHEDULER_Task *	pending_head
	Head of list of tasks waiting for an event.
static struct GNUNET_SCHEDULER_Task *	pending_tail
	Tail of list of tasks waiting for an event.
static struct GNUNET_SCHEDULER_Task *	shutdown_head
	Head of list of tasks waiting for shutdown.
static struct GNUNET_SCHEDULER_Task *	shutdown_tail
	Tail of list of tasks waiting for shutdown.
static struct GNUNET_SCHEDULER_Task *	pending_timeout_head
	List of tasks waiting ONLY for a timeout event.
static struct GNUNET_SCHEDULER_Task *	pending_timeout_tail
	List of tasks waiting ONLY for a timeout event.
static struct GNUNET_SCHEDULER_Task *	pending_timeout_last
	Last inserted task waiting ONLY for a timeout event.
static struct GNUNET_SCHEDULER_Task *	active_task
	ID of the task that is running right now.
static struct GNUNET_SCHEDULER_Task *	ready_head [GNUNET_SCHEDULER_PRIORITY_COUNT]
	Head of list of tasks ready to run right now, grouped by importance.
static struct GNUNET_SCHEDULER_Task *	ready_tail [GNUNET_SCHEDULER_PRIORITY_COUNT]
	Tail of list of tasks ready to run right now, grouped by importance.
static struct GNUNET_SCHEDULER_Task *	install_parent_control_task
	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 struct GNUNET_SCHEDULER_Task *	shutdown_pipe_task
	Task for reading from a pipe that signal handlers will use to initiate shutdown.
static unsigned int	ready_count
	Number of tasks on the ready list.
static enum GNUNET_SCHEDULER_Priority	current_priority
	Priority of the task running right now.
static enum GNUNET_SCHEDULER_Priority	max_priority_added
	Priority of the highest task added in the current select iteration.
static int	current_lifeness
	Value of the 'lifeness' flag for the current task.
static enum GNUNET_SCHEDULER_Priority	work_priority
	Priority used currently in GNUNET_SCHEDULER_do_work().
static GNUNET_SCHEDULER_select	scheduler_select
	Function to use as a select() in the scheduler.
static struct GNUNET_SCHEDULER_TaskContext	tc
	Task context of the current task.
static void *	scheduler_select_cls
	Closure for scheduler_select.
static struct GNUNET_DISK_PipeHandle *	shutdown_pipe_handle
	Pipe used to communicate shutdown via signal.
static pid_t	my_pid
	Process ID of this process at the time we installed the various signal handlers.

Detailed Description

main event loop we use for most processes, schedules computations based on time or network events with priorities

Author

Christian Grothoff

Definition in file scheduler.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)

Definition at line 32 of file scheduler.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)

Value:

                                                              GNUNET_log_from_strerror (kind, \
                                                              "util-scheduler", \
                                                              syscall)

Definition at line 34 of file scheduler.c.

{
  struct GNUNET_NETWORK_FDSet *rs;
 
  struct GNUNET_NETWORK_FDSet *ws;
 
  struct GNUNET_SIGNAL_Context *shc_int;
 
  struct GNUNET_SIGNAL_Context *shc_term;
 
#if (SIGTERM != GNUNET_TERM_SIG)
  struct GNUNET_SIGNAL_Context *shc_gterm;
#endif
 
  struct GNUNET_SIGNAL_Context *shc_quit;
 
  struct GNUNET_SIGNAL_Context *shc_hup;
 
  struct GNUNET_SIGNAL_Context *shc_pipe;
};
 
 
struct GNUNET_SCHEDULER_Task
{
  struct GNUNET_SCHEDULER_Task *next;
 
  struct GNUNET_SCHEDULER_Task *prev;
 
  GNUNET_SCHEDULER_TaskCallback callback;
 
  void *callback_cls;
 
  struct GNUNET_SCHEDULER_FdInfo *fds;
 
  struct GNUNET_SCHEDULER_FdInfo fdx;
 
  unsigned int fds_len;
 
  int own_handles;
 
  struct GNUNET_TIME_Absolute timeout;
 
#if PROFILE_DELAYS
  struct GNUNET_TIME_Absolute start_time;
#endif
 
  enum GNUNET_SCHEDULER_Reason reason;
 
  enum GNUNET_SCHEDULER_Priority priority;
 
  int read_fd;
 
  int write_fd;
 
  int lifeness;
 
  int on_shutdown;
 
  int in_ready_list;
 
#if EXECINFO
  char **backtrace_strings;
 
  int num_backtrace_strings;
#endif
 
  struct GNUNET_AsyncScopeSave scope;
};
 
static struct GNUNET_SCHEDULER_Task pass_end_marker;
 
 
struct Scheduled
{
  struct Scheduled *prev;
 
  struct Scheduled *next;
 
  struct GNUNET_SCHEDULER_Task *task;
 
  struct GNUNET_SCHEDULER_FdInfo *fdi;
 
  enum GNUNET_SCHEDULER_EventType et;
};
 
 
struct DriverContext
{
  struct Scheduled *scheduled_head;
 
  struct Scheduled *scheduled_tail;
 
  struct GNUNET_TIME_Absolute timeout;
};
 
 
static const struct GNUNET_SCHEDULER_Driver *scheduler_driver;
 
static struct GNUNET_SCHEDULER_Task *pending_head;
 
static struct GNUNET_SCHEDULER_Task *pending_tail;
 
static struct GNUNET_SCHEDULER_Task *shutdown_head;
 
static struct GNUNET_SCHEDULER_Task *shutdown_tail;
 
static struct GNUNET_SCHEDULER_Task *pending_timeout_head;
 
static struct GNUNET_SCHEDULER_Task *pending_timeout_tail;
 
static struct GNUNET_SCHEDULER_Task *pending_timeout_last;
 
static struct GNUNET_SCHEDULER_Task *active_task;
 
static struct
GNUNET_SCHEDULER_Task *ready_head[GNUNET_SCHEDULER_PRIORITY_COUNT];
 
static struct
GNUNET_SCHEDULER_Task *ready_tail[GNUNET_SCHEDULER_PRIORITY_COUNT];
 
static struct GNUNET_SCHEDULER_Task *install_parent_control_task;
 
static struct GNUNET_SCHEDULER_Task *shutdown_pipe_task;
 
static unsigned int ready_count;
 
static enum GNUNET_SCHEDULER_Priority current_priority;
 
static enum GNUNET_SCHEDULER_Priority max_priority_added;
 
static int current_lifeness;
 
static enum GNUNET_SCHEDULER_Priority work_priority;
 
static GNUNET_SCHEDULER_select scheduler_select;
 
static struct GNUNET_SCHEDULER_TaskContext tc;
 
static void *scheduler_select_cls;
 
 
void
GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select,
                             void *new_select_cls)
{
  scheduler_select = new_select;
  scheduler_select_cls = new_select_cls;
}
 
 
static enum GNUNET_SCHEDULER_Priority
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 */
}
 
 
static struct GNUNET_TIME_Absolute
get_timeout ()
{
  struct GNUNET_SCHEDULER_Task *pos;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute timeout;
 
  pos = pending_timeout_head;
  now = GNUNET_TIME_absolute_get ();
  timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
  if (NULL != pos)
  {
    if (0 != pos->reason)
    {
      return now;
    }
    else
    {
      timeout = pos->timeout;
    }
  }
  for (pos = pending_head; NULL != pos; pos = pos->next)
  {
    if (0 != pos->reason)
    {
      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;
    }
  }
  return timeout;
}
 
 
static void
remove_pass_end_marker ()
{
  if (pass_end_marker.in_ready_list)
  {
    GNUNET_CONTAINER_DLL_remove (ready_head[pass_end_marker.priority],
                                 ready_tail[pass_end_marker.priority],
                                 &pass_end_marker);
    pass_end_marker.in_ready_list = GNUNET_NO;
  }
}
 
 
static void
set_work_priority (enum GNUNET_SCHEDULER_Priority p)
{
  remove_pass_end_marker ();
  GNUNET_CONTAINER_DLL_insert_tail (ready_head[p],
                                    ready_tail[p],
                                    &pass_end_marker);
  pass_end_marker.priority = p;
  pass_end_marker.in_ready_list = GNUNET_YES;
  work_priority = p;
}
 
 
static void
queue_ready_task (struct GNUNET_SCHEDULER_Task *task)
{
  enum GNUNET_SCHEDULER_Priority p = check_priority (task->priority);
 
  GNUNET_CONTAINER_DLL_insert_tail (ready_head[p],
                                    ready_tail[p],
                                    task);
  if (p > work_priority)
    set_work_priority (p);
  task->in_ready_list = GNUNET_YES;
  ready_count++;
}
 
 
void
GNUNET_SCHEDULER_shutdown ()
{
  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,
                                 shutdown_tail,
                                 pos);
    pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
    queue_ready_task (pos);
  }
}
 
 
static void
dump_backtrace (struct GNUNET_SCHEDULER_Task *t)
{
#if EXECINFO
  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
}
 
 
static void
destroy_task (struct GNUNET_SCHEDULER_Task *t)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "destroying task %p\n",
       t);
 
  if (GNUNET_YES == t->own_handles)
  {
    for (unsigned int i = 0; i != t->fds_len; ++i)
    {
      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_nz ((void *) fh);
      }
    }
  }
  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);
}
 
 
static struct GNUNET_DISK_PipeHandle *shutdown_pipe_handle;
 
static pid_t my_pid;
 
static void
sighandler_pipe ()
{
  return;
}
 
 
static void
sighandler_shutdown (void)
{
  static char c;
  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 */
  GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (
                            shutdown_pipe_handle,
                            GNUNET_DISK_PIPE_END_WRITE),
                          &c, sizeof(c));
  errno = old_errno;
}
 
 
static void
shutdown_if_no_lifeness (void)
{
  struct GNUNET_SCHEDULER_Task *t;
 
  if (ready_count > 0)
    return;
  for (t = pending_head; NULL != t; t = t->next)
    if (GNUNET_YES == t->lifeness)
      return;
  for (t = shutdown_head; NULL != t; t = t->next)
    if (GNUNET_YES == t->lifeness)
      return;
  for (t = pending_timeout_head; NULL != t; t = t->next)
    if (GNUNET_YES == t->lifeness)
      return;
  /* No lifeness! */
  GNUNET_SCHEDULER_shutdown ();
}
 
 
static enum GNUNET_GenericReturnValue
select_loop (struct GNUNET_SCHEDULER_Handle *sh,
             struct DriverContext *context);
 
 
void
GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
                      void *task_cls)
{
  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);
  GNUNET_break (GNUNET_OK ==
                select_loop (sh,
                             &context));
  GNUNET_SCHEDULER_driver_done (sh);
  GNUNET_free (driver);
}
 
 
const struct GNUNET_SCHEDULER_TaskContext *
GNUNET_SCHEDULER_get_task_context ()
{
  GNUNET_assert (NULL != active_task);
  return &tc;
}
 
 
unsigned int
GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
{
  unsigned int ret;
 
  GNUNET_assert (NULL != active_task);
  if (p == GNUNET_SCHEDULER_PRIORITY_COUNT)
    return ready_count;
  if (p == GNUNET_SCHEDULER_PRIORITY_KEEP)
    p = current_priority;
  ret = 0;
  for (struct GNUNET_SCHEDULER_Task *pos = ready_head[check_priority (p)];
       NULL != pos;
       pos = pos->next)
    ret++;
  if (pass_end_marker.in_ready_list && pass_end_marker.priority == p)
    // Don't count the dummy marker
    ret--;
  return ret;
}
 
 
static 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;
    for (int 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 (int 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 (int 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 (int 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;
    }
  }
}
 
 
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);
}
 
 
void *
GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
{
  enum GNUNET_SCHEDULER_Priority p;
  int is_fd_task;
  void *ret;
 
  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)
  {
    int del_result = scheduler_driver->del (scheduler_driver->cls, task);
    if (GNUNET_OK != del_result)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "driver could not delete task\n");
      GNUNET_assert (0);
    }
  }
  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
  {
    p = check_priority (task->priority);
    GNUNET_CONTAINER_DLL_remove (ready_head[p],
                                 ready_tail[p],
                                 task);
    ready_count--;
  }
  ret = task->callback_cls;
  destroy_task (task);
  return ret;
}
 
 
static void
init_backtrace (struct GNUNET_SCHEDULER_Task *t)
{
#if EXECINFO
  void *backtrace_array[MAX_TRACE_DEPTH];
 
  t->num_backtrace_strings
    = backtrace (backtrace_array, MAX_TRACE_DEPTH);
  t->backtrace_strings =
    backtrace_symbols (backtrace_array,
                       t->num_backtrace_strings);
  dump_backtrace (t);
#else
  (void) t;
#endif
}
 
 
void
GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback
                                               task,
                                               void *task_cls,
                                               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);
  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
  t->read_fd = -1;
  t->write_fd = -1;
  t->callback = task;
  t->callback_cls = task_cls;
#if PROFILE_DELAYS
  t->start_time = GNUNET_TIME_absolute_get ();
#endif
  t->reason = reason;
  t->priority = check_priority (priority);
  t->lifeness = current_lifeness;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding continuation task %p\n",
       t);
  init_backtrace (t);
  queue_ready_task (t);
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
                                       enum GNUNET_SCHEDULER_Priority priority,
                                       GNUNET_SCHEDULER_TaskCallback task,
                                       void *task_cls)
{
  struct GNUNET_SCHEDULER_Task *t;
  struct GNUNET_SCHEDULER_Task *pos;
  struct GNUNET_SCHEDULER_Task *prev;
  struct GNUNET_TIME_Relative left;
 
  /* 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->write_fd = -1;
#if PROFILE_DELAYS
  t->start_time = GNUNET_TIME_absolute_get ();
#endif
  t->timeout = at;
  t->priority = check_priority (priority);
  t->lifeness = current_lifeness;
  init_backtrace (t);
 
  left = GNUNET_TIME_absolute_get_remaining (at);
  if (0 == left.rel_value_us)
  {
    queue_ready_task (t);
    if (priority > work_priority)
      work_priority = priority;
    return t;
  }
 
  /* 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))
  {
    GNUNET_CONTAINER_DLL_insert (pending_timeout_head,
                                 pending_timeout_tail,
                                 t);
  }
  else
  {
    /* 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))
      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))
    {
      prev = pos;
      pos = pos->next;
    }
    GNUNET_CONTAINER_DLL_insert_after (pending_timeout_head,
                                       pending_timeout_tail,
                                       prev,
                                       t);
  }
  /* finally, update heuristic insertion point to last insertion... */
  pending_timeout_last = t;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding task %p\n",
       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,
                                            void *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_with_priority (enum GNUNET_SCHEDULER_Priority prio,
                                    GNUNET_SCHEDULER_TaskCallback task,
                                    void *task_cls)
{
  return GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_UNIT_ZERO,
                                                     prio,
                                                     task,
                                                     task_cls);
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at,
                         GNUNET_SCHEDULER_TaskCallback task,
                         void *task_cls)
{
  return GNUNET_SCHEDULER_add_at_with_priority (at,
                                                GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                task,
                                                task_cls);
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
                              GNUNET_SCHEDULER_TaskCallback task,
                              void *task_cls)
{
  return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
                                                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                     task,
                                                     task_cls);
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
                          void *task_cls)
{
  struct GNUNET_SCHEDULER_Task *t;
 
  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->write_fd = -1;
#if PROFILE_DELAYS
  t->start_time = GNUNET_TIME_absolute_get ();
#endif
  t->timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  t->priority = current_priority;
  t->on_shutdown = GNUNET_YES;
  t->lifeness = current_lifeness;
  queue_ready_task (t);
  init_backtrace (t);
  return t;
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
                               void *task_cls)
{
  struct GNUNET_SCHEDULER_Task *t;
 
  /* 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->write_fd = -1;
#if PROFILE_DELAYS
  t->start_time = GNUNET_TIME_absolute_get ();
#endif
  t->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
  t->priority = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
  t->on_shutdown = GNUNET_YES;
  t->lifeness = GNUNET_NO;
  GNUNET_CONTAINER_DLL_insert (shutdown_head,
                               shutdown_tail,
                               t);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding shutdown task %p\n",
       t);
  init_backtrace (t);
  return t;
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
                                        GNUNET_SCHEDULER_TaskCallback task,
                                        void *task_cls)
{
  struct GNUNET_SCHEDULER_Task *ret;
 
  ret = GNUNET_SCHEDULER_add_now (task, task_cls);
  ret->lifeness = lifeness;
  return ret;
}
 
 
#if DEBUG_FDS
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
 
 
static struct GNUNET_SCHEDULER_Task *
add_without_sets (struct GNUNET_TIME_Relative delay,
                  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;
 
  /* 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
  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
#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->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);
  init_backtrace (t);
  return t;
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
                               struct GNUNET_NETWORK_Handle *rfd,
                               GNUNET_SCHEDULER_TaskCallback task,
                               void *task_cls)
{
  return GNUNET_SCHEDULER_add_read_net_with_priority (delay,
                                                      GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                      rfd, task, task_cls);
}
 
 
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,
                                             void *task_cls)
{
  return GNUNET_SCHEDULER_add_net_with_priority (delay, priority,
                                                 rfd,
                                                 GNUNET_YES,
                                                 GNUNET_NO,
                                                 task, task_cls);
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
                                struct GNUNET_NETWORK_Handle *wfd,
                                GNUNET_SCHEDULER_TaskCallback task,
                                void *task_cls)
{
  return GNUNET_SCHEDULER_add_net_with_priority (delay,
                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                 wfd,
                                                 GNUNET_NO, GNUNET_YES,
                                                 task, task_cls);
}
 
 
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)
{
  /* 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  ? fd : NULL,
                           on_write ? fd : NULL,
                           NULL,
                           NULL,
                           task, task_cls);
}
 
 
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)
{
  return GNUNET_SCHEDULER_add_file_with_priority (
    delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
    rfd, GNUNET_YES, GNUNET_NO,
    task, task_cls);
}
 
 
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)
{
  return GNUNET_SCHEDULER_add_file_with_priority (
    delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
    wfd, GNUNET_NO, GNUNET_YES,
    task, task_cls);
}
 
 
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,
                                         int on_read, int on_write,
                                         GNUNET_SCHEDULER_TaskCallback task,
                                         void *task_cls)
{
  /* 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);
}
 
 
static 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;
}
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                             struct GNUNET_TIME_Relative delay,
                             const struct GNUNET_NETWORK_FDSet *rs,
                             const struct GNUNET_NETWORK_FDSet *ws,
                             GNUNET_SCHEDULER_TaskCallback task,
                             void *task_cls)
{
  struct GNUNET_SCHEDULER_Task *t;
  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;
  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);
  int no_fds_extracted;
 
  /* scheduler must be running */
  GNUNET_assert (NULL != scheduler_driver);
  GNUNET_assert (NULL != task);
  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);
    }
  }
  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);
  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->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);
  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;
}
 
 
void
GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
                             struct GNUNET_SCHEDULER_FdInfo *fdi)
{
  enum GNUNET_SCHEDULER_Reason reason;
 
  reason = task->reason;
  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 & fdi->et)))
    reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
  reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
  task->reason = reason;
  if (GNUNET_NO == task->in_ready_list)
  {
    GNUNET_CONTAINER_DLL_remove (pending_head,
                                 pending_tail,
                                 task);
    queue_ready_task (task);
  }
}
 
 
int
GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh)
{
  struct GNUNET_SCHEDULER_Task *pos;
  struct GNUNET_TIME_Absolute now;
 
  /* check for tasks that reached the timeout! */
  now = GNUNET_TIME_absolute_get ();
  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)
      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 = 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)
  {
    struct GNUNET_TIME_Absolute timeout = get_timeout ();
 
    if (timeout.abs_value_us > now.abs_value_us)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "GNUNET_SCHEDULER_do_work did not find any ready "
           "tasks and timeout has not been reached yet.\n");
    }
    else
    {
      GNUNET_assert (0);
    }
  }
  else
  {
    /* 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 (work_priority = GNUNET_SCHEDULER_PRIORITY_COUNT - 1;
         work_priority > 0;
         work_priority--)
    {
      pos = ready_head[work_priority];
      if (NULL != pos)
        break;
    }
    GNUNET_assert (NULL != pos);        /* ready_count wrong? */
 
    /* process all *existing* tasks at this priority
       level, then yield */
    set_work_priority (work_priority);
    while (NULL != (pos = ready_head[work_priority])
           && pos != &pass_end_marker)
    {
      GNUNET_CONTAINER_DLL_remove (ready_head[work_priority],
                                   ready_tail[work_priority],
                                   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);
      // 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);
    }
    remove_pass_end_marker ();
  }
  shutdown_if_no_lifeness ();
  if (0 == ready_count)
  {
    scheduler_driver->set_wakeup (scheduler_driver->cls,
                                  get_timeout ());
    return GNUNET_NO;
  }
  scheduler_driver->set_wakeup (scheduler_driver->cls,
                                GNUNET_TIME_absolute_get ());
  return GNUNET_YES;
}
 
 
struct GNUNET_SCHEDULER_Handle *
GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver)
{
  struct GNUNET_SCHEDULER_Handle *sh;
  const struct GNUNET_DISK_FileHandle *pr;
 
  /* 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_DISK_PF_NONE);
  GNUNET_assert (NULL != shutdown_pipe_handle);
  pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
                                GNUNET_DISK_PIPE_END_READ);
  my_pid = getpid ();
  scheduler_driver = driver;
 
  /* install signal handlers */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Registering signal handlers\n");
  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)
  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;
  /* ensure this task runs first, by using a priority level reserved for
     the scheduler (not really shutdown, but start-up ;-) */
  install_parent_control_task =
    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_SHUTDOWN,
                                        &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;
  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 ();
  GNUNET_NETWORK_fdset_handle_set (sh->rs, pr);
  return sh;
}
 
 
void
GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh)
{
  GNUNET_break (NULL == pending_head);
  GNUNET_break (NULL == pending_timeout_head);
  GNUNET_break (NULL == shutdown_head);
  for (int i = 0; i != GNUNET_SCHEDULER_PRIORITY_COUNT; ++i)
  {
    GNUNET_break (NULL == ready_head[i]);
  }
  GNUNET_NETWORK_fdset_destroy (sh->rs);
  GNUNET_NETWORK_fdset_destroy (sh->ws);
 
  /* uninstall signal handlers */
  GNUNET_SIGNAL_handler_uninstall (sh->shc_int);
  GNUNET_SIGNAL_handler_uninstall (sh->shc_term);
#if (SIGTERM != GNUNET_TERM_SIG)
  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 enum GNUNET_GenericReturnValue
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))
  {
    struct GNUNET_TIME_Relative time_remaining;
 
    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);
      }
    }
    time_remaining = GNUNET_TIME_absolute_get_remaining (context->timeout);
    if (0 < ready_count)
      time_remaining = GNUNET_TIME_UNIT_ZERO;
    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);
 
  if ( (NULL == context->scheduled_head) &&
       (NULL != pending_timeout_head) &&
       (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us ==
        context->timeout.abs_value_us) )
  {
    /* Only remaining task has timeout of 'forever'.
       We exit here more as sanity measure, as just
       waiting forever isn't exactly useful. Still,
       this is indicative of a bug in the client code. */
    GNUNET_break (0);
    return GNUNET_NO;
  }
  return GNUNET_OK;
}
 
 
static int
select_add (void *cls,
            struct GNUNET_SCHEDULER_Task *task,
            struct GNUNET_SCHEDULER_FdInfo *fdi)
{
  struct DriverContext *context = cls;
  struct Scheduled *scheduled;
 
  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;
  }
 
  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;
}
 
 
struct GNUNET_SCHEDULER_Driver *
GNUNET_SCHEDULER_driver_select ()
{
  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;
}
 
 
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);
}
 
 
/* end of scheduler.c */

PROFILE_DELAYS

#define PROFILE_DELAYS   GNUNET_NO

Should we figure out which tasks are delayed for a while before they are run? (Consider using in combination with EXECINFO).

Definition at line 68 of file scheduler.c.

DELAY_THRESHOLD

#define DELAY_THRESHOLD   GNUNET_TIME_UNIT_SECONDS

Task that were in the queue for longer than this are reported if PROFILE_DELAYS is active.

Definition at line 74 of file scheduler.c.

Function Documentation

check_priority()

static enum GNUNET_SCHEDULER_Priority check_priority ( enum GNUNET_SCHEDULER_Priority  p )

static

Check that the given priority is legal (and return it).

Parameters

p	priority value to check

Returns

p on success, 0 on error

Definition at line 462 of file scheduler.c.

{
  if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT))
    return p;
  GNUNET_assert (0);
  return 0;                     /* make compiler happy */
}

References GNUNET_assert, GNUNET_SCHEDULER_PRIORITY_COUNT, and p.

Referenced by add_without_sets(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_with_reason_and_priority(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_get_load(), and queue_ready_task().

Here is the caller graph for this function:

get_timeout()

static struct GNUNET_TIME_Absolute get_timeout ( )

static

chooses the nearest timeout from all pending tasks, to be used to tell the driver the next wakeup time (using its set_wakeup callback)

Definition at line 477 of file scheduler.c.

{
  struct GNUNET_SCHEDULER_Task *pos;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute timeout;
 
  pos = pending_timeout_head;
  now = GNUNET_TIME_absolute_get ();
  timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
  if (NULL != pos)
  {
    if (0 != pos->reason)
    {
      return now;
    }
    else
    {
      timeout = pos->timeout;
    }
  }
  for (pos = pending_head; NULL != pos; pos = pos->next)
  {
    if (0 != pos->reason)
    {
      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;
    }
  }
  return timeout;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_SCHEDULER_Task::next, pending_head, pending_timeout_head, GNUNET_SCHEDULER_Task::reason, timeout, and GNUNET_SCHEDULER_Task::timeout.

Referenced by GNUNET_SCHEDULER_do_work(), and GNUNET_SCHEDULER_driver_init().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_pass_end_marker()

static void remove_pass_end_marker ( )

static

Definition at line 515 of file scheduler.c.

{
  if (pass_end_marker.in_ready_list)
  {
    GNUNET_CONTAINER_DLL_remove (ready_head[pass_end_marker.priority],
                                 ready_tail[pass_end_marker.priority],
                                 &pass_end_marker);
    pass_end_marker.in_ready_list = GNUNET_NO;
  }
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_SCHEDULER_Task::in_ready_list, pass_end_marker, GNUNET_SCHEDULER_Task::priority, ready_head, and ready_tail.

Referenced by GNUNET_SCHEDULER_do_work(), and set_work_priority().

Here is the caller graph for this function:

set_work_priority()

static void set_work_priority ( enum GNUNET_SCHEDULER_Priority  p )

static

Definition at line 528 of file scheduler.c.

{
  remove_pass_end_marker ();
  GNUNET_CONTAINER_DLL_insert_tail (ready_head[p],
                                    ready_tail[p],
                                    &pass_end_marker);
  pass_end_marker.priority = p;
  pass_end_marker.in_ready_list = GNUNET_YES;
  work_priority = p;
}

References GNUNET_CONTAINER_DLL_insert_tail, GNUNET_YES, GNUNET_SCHEDULER_Task::in_ready_list, p, pass_end_marker, GNUNET_SCHEDULER_Task::priority, ready_head, ready_tail, remove_pass_end_marker(), and work_priority.

Referenced by GNUNET_SCHEDULER_do_work(), and queue_ready_task().

Here is the call graph for this function:

Here is the caller graph for this function:

queue_ready_task()

static void queue_ready_task ( struct GNUNET_SCHEDULER_Task *  task )

static

Put a task that is ready for execution into the ready queue.

Parameters

task	task ready for execution

Definition at line 546 of file scheduler.c.

{
  enum GNUNET_SCHEDULER_Priority p = check_priority (task->priority);
 
  GNUNET_CONTAINER_DLL_insert_tail (ready_head[p],
                                    ready_tail[p],
                                    task);
  if (p > work_priority)
    set_work_priority (p);
  task->in_ready_list = GNUNET_YES;
  ready_count++;
}

References check_priority(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_YES, GNUNET_SCHEDULER_Task::in_ready_list, p, GNUNET_SCHEDULER_Task::priority, ready_count, ready_head, ready_tail, set_work_priority(), and work_priority.

Referenced by GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_with_reason_and_priority(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_shutdown(), and GNUNET_SCHEDULER_task_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_backtrace()

static void dump_backtrace ( struct GNUNET_SCHEDULER_Task *  t )

static

Output stack trace of task t.

Parameters

t	task to dump stack trace of

Definition at line 600 of file scheduler.c.

{
#if EXECINFO
  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
}

References GNUNET_ERROR_TYPE_WARNING, LOG, and t.

Referenced by GNUNET_SCHEDULER_do_work(), init_backtrace(), and select_loop().

Here is the caller graph for this function:

destroy_task()

static void destroy_task ( struct GNUNET_SCHEDULER_Task *  t )

static

Destroy a task (release associated resources)

Parameters

t	task to destroy

Definition at line 621 of file scheduler.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "destroying task %p\n",
       t);
 
  if (GNUNET_YES == t->own_handles)
  {
    for (unsigned int i = 0; i != t->fds_len; ++i)
    {
      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_nz ((void *) fh);
      }
    }
  }
  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);
}

References GNUNET_DISK_FileHandle::fd, GNUNET_SCHEDULER_FdInfo::fd, GNUNET_NETWORK_Handle::fd, GNUNET_SCHEDULER_Task::fds, GNUNET_SCHEDULER_Task::fds_len, GNUNET_SCHEDULER_FdInfo::fh, GNUNET_array_grow, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_nz, GNUNET_NETWORK_socket_free_memory_only_(), GNUNET_YES, LOG, GNUNET_SCHEDULER_Task::own_handles, and t.

Referenced by GNUNET_SCHEDULER_cancel(), and GNUNET_SCHEDULER_do_work().

Here is the call graph for this function:

Here is the caller graph for this function:

sighandler_pipe()

static void sighandler_pipe ( )

static

Signal handler called for SIGPIPE.

Definition at line 672 of file scheduler.c.

{
  return;
}

Referenced by GNUNET_SCHEDULER_driver_init().

Here is the caller graph for this function:

sighandler_shutdown()

static void sighandler_shutdown ( void  )

static

Signal handler called for signals that should cause us to shutdown.

Definition at line 682 of file scheduler.c.

{
  static char c;
  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 */
  GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (
                            shutdown_pipe_handle,
                            GNUNET_DISK_PIPE_END_WRITE),
                          &c, sizeof(c));
  errno = old_errno;
}

References GNUNET_DISK_file_write(), GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), my_pid, and shutdown_pipe_handle.

Referenced by GNUNET_SCHEDULER_driver_init().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_if_no_lifeness()

static void shutdown_if_no_lifeness ( void  )

static

Definition at line 699 of file scheduler.c.

{
  struct GNUNET_SCHEDULER_Task *t;
 
  if (ready_count > 0)
    return;
  for (t = pending_head; NULL != t; t = t->next)
    if (GNUNET_YES == t->lifeness)
      return;
  for (t = shutdown_head; NULL != t; t = t->next)
    if (GNUNET_YES == t->lifeness)
      return;
  for (t = pending_timeout_head; NULL != t; t = t->next)
    if (GNUNET_YES == t->lifeness)
      return;
  /* No lifeness! */
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_SCHEDULER_shutdown(), GNUNET_YES, GNUNET_SCHEDULER_Task::lifeness, GNUNET_SCHEDULER_Task::next, pending_head, pending_timeout_head, ready_count, shutdown_head, and t.

Referenced by GNUNET_SCHEDULER_do_work().

Here is the call graph for this function:

Here is the caller graph for this function:

select_loop()

static enum GNUNET_GenericReturnValue select_loop ( struct GNUNET_SCHEDULER_Handle *  sh, struct DriverContext *  context  )

static

Definition at line 2313 of file scheduler.c.

{
  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))
  {
    struct GNUNET_TIME_Relative time_remaining;
 
    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);
      }
    }
    time_remaining = GNUNET_TIME_absolute_get_remaining (context->timeout);
    if (0 < ready_count)
      time_remaining = GNUNET_TIME_UNIT_ZERO;
    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);
 
  if ( (NULL == context->scheduled_head) &&
       (NULL != pending_timeout_head) &&
       (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us ==
        context->timeout.abs_value_us) )
  {
    /* Only remaining task has timeout of 'forever'.
       We exit here more as sanity measure, as just
       waiting forever isn't exactly useful. Still,
       this is indicative of a bug in the client code. */
    GNUNET_break (0);
    return GNUNET_NO;
  }
  return GNUNET_OK;
}

References context, dump_backtrace(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set_native(), GNUNET_NETWORK_fdset_test_native(), GNUNET_NETWORK_fdset_zero(), GNUNET_NETWORK_socket_select(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_ET_IN, GNUNET_SCHEDULER_ET_OUT, GNUNET_SCHEDULER_task_ready(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, LOG, LOG_STRERROR, pending_timeout_head, ready_count, scheduler_select, scheduler_select_cls, and sh.

Referenced by GNUNET_SCHEDULER_run().

Here is the call graph for this function:

Here is the caller graph for this function:

init_fd_info()

static 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  )

static

Definition at line 797 of file scheduler.c.

{
  // 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;
    for (int 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 (int 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 (int 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 (int 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;
    }
  }
}

References GNUNET_SCHEDULER_FdInfo::et, GNUNET_SCHEDULER_FdInfo::fd, GNUNET_SCHEDULER_Task::fds, GNUNET_SCHEDULER_Task::fds_len, GNUNET_SCHEDULER_Task::fdx, GNUNET_SCHEDULER_FdInfo::fh, GNUNET_assert, GNUNET_NETWORK_get_fd(), GNUNET_new_array, GNUNET_SCHEDULER_ET_IN, GNUNET_SCHEDULER_ET_OUT, GNUNET_SCHEDULER_Task::read_fd, GNUNET_SCHEDULER_FdInfo::sock, t, and GNUNET_SCHEDULER_Task::write_fd.

Referenced by add_without_sets(), and GNUNET_SCHEDULER_add_select().

Here is the call graph for this function:

Here is the caller graph for this function:

driver_add_multiple()

static void driver_add_multiple ( struct GNUNET_SCHEDULER_Task *  t )

static

calls the given function func on each FdInfo related to t.

Optionally updates the event type field in each FdInfo after calling func.

Parameters

t	the task
driver_func	the function to call with each FdInfo contained in in t
if_not_ready	only call driver_func on FdInfos that are not ready
et	the event type to be set in each FdInfo after calling driver_func on it, or -1 if no updating not desired.

Definition at line 914 of file scheduler.c.

{
  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");
  }
}

References GNUNET_SCHEDULER_Driver::add, GNUNET_SCHEDULER_Driver::cls, GNUNET_SCHEDULER_FdInfo::et, GNUNET_SCHEDULER_Task::fds, GNUNET_SCHEDULER_Task::fds_len, GNUNET_ERROR_TYPE_ERROR, GNUNET_SCHEDULER_ET_NONE, GNUNET_YES, LOG, scheduler_driver, and t.

Referenced by add_without_sets(), and GNUNET_SCHEDULER_add_select().

Here is the caller graph for this function:

install_parent_control_handler()

static void install_parent_control_handler ( void *  cls )

static

Definition at line 936 of file scheduler.c.

{
  (void) cls;
  install_parent_control_task = NULL;
  GNUNET_OS_install_parent_control_handler (NULL);
}

References GNUNET_OS_install_parent_control_handler(), and install_parent_control_task.

Referenced by GNUNET_SCHEDULER_driver_init().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_pipe_cb()

static void shutdown_pipe_cb ( void *  cls )

static

Definition at line 945 of file scheduler.c.

{
  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);
}

References GNUNET_assert, GNUNET_DISK_file_read(), GNUNET_DISK_handle_invalid(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_UNIT_FOREVER_REL, shutdown_pipe_cb(), shutdown_pipe_handle, and shutdown_pipe_task.

Referenced by GNUNET_SCHEDULER_driver_init(), and shutdown_pipe_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

init_backtrace()

static void init_backtrace ( struct GNUNET_SCHEDULER_Task *  t )

static

Initialize backtrace data for task t.

Parameters

t	task to initialize

Definition at line 1046 of file scheduler.c.

{
#if EXECINFO
  void *backtrace_array[MAX_TRACE_DEPTH];
 
  t->num_backtrace_strings
    = backtrace (backtrace_array, MAX_TRACE_DEPTH);
  t->backtrace_strings =
    backtrace_symbols (backtrace_array,
                       t->num_backtrace_strings);
  dump_backtrace (t);
#else
  (void) t;
#endif
}

References dump_backtrace(), and t.

Referenced by add_without_sets(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_shutdown(), and GNUNET_SCHEDULER_add_with_reason_and_priority().

Here is the call graph for this function:

Here is the caller graph for this function:

add_without_sets()

static struct GNUNET_SCHEDULER_Task * add_without_sets ( struct GNUNET_TIME_Relative  delay, 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  )

static

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 as a timeout on the socket(s) being ready. The task will be scheduled for execution once either the delay has expired or any of the socket operations is ready. This is the most general function of the "add" family. Note that the "prerequisite_task" must be satisfied in addition to any of the other conditions. In other words, the task will be started when (prerequisite-run) && (delay-ready || any-rs-ready || any-ws-ready)

Parameters

delay	how long should we wait?
priority	priority to use
rfd	file descriptor we want to read (can be -1)
wfd	file descriptors we want to write (can be -1)
task	main function of the task
task_cls	closure of task

Returns

unique task identifier for the job only valid until task is started!

Definition at line 1439 of file scheduler.c.

{
  struct GNUNET_SCHEDULER_Task *t;
 
  /* 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
  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
#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->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);
  init_backtrace (t);
  return t;
}

References GNUNET_SCHEDULER_Task::callback, GNUNET_SCHEDULER_Task::callback_cls, check_priority(), current_lifeness, current_priority, driver_add_multiple(), GNUNET_DISK_FileHandle::fd, GNUNET_assert, GNUNET_async_scope_get(), GNUNET_CONTAINER_DLL_insert, GNUNET_MAX, GNUNET_NETWORK_get_fd(), GNUNET_new, GNUNET_SCHEDULER_PRIORITY_KEEP, GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_to_absolute(), init_backtrace(), init_fd_info(), GNUNET_SCHEDULER_Task::lifeness, max_priority_added, pending_head, pending_tail, GNUNET_SCHEDULER_Task::priority, scheduler_driver, GNUNET_SCHEDULER_Task::scope, t, and GNUNET_SCHEDULER_Task::timeout.

Referenced by GNUNET_SCHEDULER_add_file_with_priority(), and GNUNET_SCHEDULER_add_net_with_priority().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_handles()

static 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  )

static

Definition at line 1753 of file scheduler.c.

{
  // 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;
}

References GNUNET_array_append, GNUNET_assert, GNUNET_DISK_get_handle_from_int_fd(), GNUNET_NETWORK_fdset_test_native(), GNUNET_NETWORK_socket_box_native(), GNUNET_YES, and GNUNET_NETWORK_FDSet::nsds.

Referenced by GNUNET_SCHEDULER_add_select().

Here is the call graph for this function:

Here is the caller graph for this function:

select_add()

static int select_add ( void *  cls, struct GNUNET_SCHEDULER_Task *  task, struct GNUNET_SCHEDULER_FdInfo *  fdi  )

static

Definition at line 2469 of file scheduler.c.

{
  struct DriverContext *context = cls;
  struct Scheduled *scheduled;
 
  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;
  }
 
  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;
}

References context, GNUNET_SCHEDULER_FdInfo::et, Scheduled::et, GNUNET_SCHEDULER_FdInfo::fd, Scheduled::fdi, GNUNET_SCHEDULER_FdInfo::fh, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_ET_IN, GNUNET_SCHEDULER_ET_OUT, GNUNET_SYSERR, GNUNET_SCHEDULER_FdInfo::sock, and Scheduled::task.

Referenced by GNUNET_SCHEDULER_driver_select().

Here is the caller graph for this function:

select_del()

static int select_del ( void *  cls, struct GNUNET_SCHEDULER_Task *  task  )

static

Definition at line 2501 of file scheduler.c.

{
  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;
}

References context, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, Scheduled::next, ret, and Scheduled::task.

Referenced by GNUNET_SCHEDULER_driver_select().

Here is the caller graph for this function:

select_set_wakeup()

static void select_set_wakeup ( void *  cls, struct GNUNET_TIME_Absolute  dt  )

static

Definition at line 2531 of file scheduler.c.

{
  struct DriverContext *context = cls;
 
  GNUNET_assert (NULL != context);
  context->timeout = dt;
}

References context, and GNUNET_assert.

Referenced by GNUNET_SCHEDULER_driver_select().

Here is the caller graph for this function:

Variable Documentation

pass_end_marker

struct GNUNET_SCHEDULER_Task pass_end_marker

static

Placed at the end of a ready queue to indicate where a scheduler run pass ends.

The next, prev, in_ready_list and priority fields are the only ones that should be used.

Definition at line 256 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_get_load(), remove_pass_end_marker(), and set_work_priority().

scheduler_driver

const struct GNUNET_SCHEDULER_Driver* scheduler_driver

static

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().

Definition at line 319 of file scheduler.c.

Referenced by add_without_sets(), driver_add_multiple(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_file_with_priority(), GNUNET_SCHEDULER_add_net_with_priority(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_add_with_reason_and_priority(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_driver_done(), and GNUNET_SCHEDULER_driver_init().

pending_head

struct GNUNET_SCHEDULER_Task* pending_head

static

Head of list of tasks waiting for an event.

Definition at line 324 of file scheduler.c.

Referenced by add_without_sets(), get_timeout(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_driver_done(), GNUNET_SCHEDULER_task_ready(), and shutdown_if_no_lifeness().

pending_tail

struct GNUNET_SCHEDULER_Task* pending_tail

static

Tail of list of tasks waiting for an event.

Definition at line 329 of file scheduler.c.

Referenced by add_without_sets(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_do_work(), and GNUNET_SCHEDULER_task_ready().

shutdown_head

struct GNUNET_SCHEDULER_Task* shutdown_head

static

Head of list of tasks waiting for shutdown.

Definition at line 334 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_driver_done(), GNUNET_SCHEDULER_shutdown(), and shutdown_if_no_lifeness().

shutdown_tail

struct GNUNET_SCHEDULER_Task* shutdown_tail

static

Tail of list of tasks waiting for shutdown.

Definition at line 339 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_cancel(), and GNUNET_SCHEDULER_shutdown().

pending_timeout_head

struct GNUNET_SCHEDULER_Task* pending_timeout_head

static

List of tasks waiting ONLY for a timeout event.

Sorted by timeout (earliest first). Used so that we do not traverse the list of these tasks when building select sets (we just look at the head to determine the respective timeout ONCE).

Definition at line 348 of file scheduler.c.

Referenced by get_timeout(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_driver_done(), select_loop(), and shutdown_if_no_lifeness().

pending_timeout_tail

struct GNUNET_SCHEDULER_Task* pending_timeout_tail

static

List of tasks waiting ONLY for a timeout event.

Sorted by timeout (earliest first). Used so that we do not traverse the list of these tasks when building select sets (we just look at the head to determine the respective timeout ONCE).

Definition at line 357 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_cancel(), and GNUNET_SCHEDULER_do_work().

pending_timeout_last

struct GNUNET_SCHEDULER_Task* pending_timeout_last

static

Last inserted task waiting ONLY for a timeout event.

Used to (heuristically) speed up insertion.

Definition at line 363 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_cancel(), and GNUNET_SCHEDULER_do_work().

active_task

struct GNUNET_SCHEDULER_Task* active_task

static

ID of the task that is running right now.

Definition at line 368 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_begin_async_scope(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_get_load(), and GNUNET_SCHEDULER_get_task_context().

ready_head

struct GNUNET_SCHEDULER_Task* ready_head[GNUNET_SCHEDULER_PRIORITY_COUNT]

static

Head of list of tasks ready to run right now, grouped by importance.

Definition at line 374 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_driver_done(), GNUNET_SCHEDULER_get_load(), queue_ready_task(), remove_pass_end_marker(), and set_work_priority().

ready_tail

struct GNUNET_SCHEDULER_Task* ready_tail[GNUNET_SCHEDULER_PRIORITY_COUNT]

static

Tail of list of tasks ready to run right now, grouped by importance.

Definition at line 380 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_do_work(), queue_ready_task(), remove_pass_end_marker(), and set_work_priority().

install_parent_control_task

struct GNUNET_SCHEDULER_Task* install_parent_control_task

static

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)

Definition at line 387 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_driver_init(), GNUNET_SCHEDULER_shutdown(), and install_parent_control_handler().

shutdown_pipe_task

struct GNUNET_SCHEDULER_Task* shutdown_pipe_task

static

Task for reading from a pipe that signal handlers will use to initiate shutdown.

Definition at line 393 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_driver_init(), GNUNET_SCHEDULER_shutdown(), and shutdown_pipe_cb().

ready_count

unsigned int ready_count

static

Number of tasks on the ready list.

Definition at line 398 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_get_load(), queue_ready_task(), select_loop(), and shutdown_if_no_lifeness().

current_priority

enum GNUNET_SCHEDULER_Priority current_priority

static

Priority of the task running right now.

Only valid while a task is running.

Definition at line 404 of file scheduler.c.

Referenced by add_without_sets(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_driver_init(), and GNUNET_SCHEDULER_get_load().

max_priority_added

enum GNUNET_SCHEDULER_Priority max_priority_added

static

Priority of the highest task added in the current select iteration.

Definition at line 410 of file scheduler.c.

Referenced by add_without_sets(), GNUNET_SCHEDULER_add_select(), and GNUNET_SCHEDULER_do_work().

current_lifeness

int current_lifeness

static

Value of the 'lifeness' flag for the current task.

Definition at line 415 of file scheduler.c.

Referenced by add_without_sets(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_with_reason_and_priority(), GNUNET_SCHEDULER_do_work(), and GNUNET_SCHEDULER_driver_init().

work_priority

enum GNUNET_SCHEDULER_Priority work_priority

static

Priority used currently in GNUNET_SCHEDULER_do_work().

Definition at line 420 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_do_work(), queue_ready_task(), and set_work_priority().

scheduler_select

GNUNET_SCHEDULER_select scheduler_select

static

Function to use as a select() in the scheduler.

If NULL, we use GNUNET_NETWORK_socket_select().

Definition at line 426 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_set_select(), and select_loop().

tc

struct GNUNET_SCHEDULER_TaskContext tc

static

Task context of the current task.

Definition at line 431 of file scheduler.c.

Referenced by check_add_address(), check_add_queue_message(), check_client_send(), check_communicator_available(), check_incoming_msg(), client_connect_cb(), client_disconnect_cb(), client_send_response(), cmd_read(), connect_probe_continuation(), core_send_connect_info(), cores_send_connect_info(), cores_send_disconnect_info(), create_address_entry(), decrypt_and_check_tc(), decrypt_and_check_tc(), do_read(), do_read(), do_s5r_read(), do_udp_read(), do_udp_read(), do_udp_read(), finish_handling_raw_message(), free_address_list_entry(), free_pending_message(), free_queue(), free_queue_entry(), free_timedout_queue_entry(), GNUNET_FS_share_tree_trim(), GNUNET_SCHEDULER_do_work(), GNUNET_SCHEDULER_get_task_context(), handle_add_address(), handle_add_queue_message(), handle_backchannel_encapsulation(), handle_client_recv_ok(), handle_client_send(), handle_client_send(), handle_client_start(), handle_communicator_available(), handle_communicator_backchannel(), handle_del_address(), handle_del_queue_message(), handle_incoming_msg(), handle_monitor_start(), handle_queue_create_fail(), handle_queue_create_ok(), handle_request_hello_validation(), handle_send_message_ack(), handle_suggest(), handle_suggest_cancel(), handle_update_queue_message(), lookup_communicator(), maint_child_death(), migrate_and_drop_keywords(), migrate_and_drop_metadata(), notify_client_connect_info(), notify_client_queues(), notify_monitor(), notify_monitors(), proto_read_kx(), proto_read_kx(), queue_read_kx(), queue_read_kx(), queue_send_msg(), read_dns4(), read_dns6(), read_response(), remove_high_frequency_keywords(), share_tree_trim(), shutdown_task(), start_burst(), stop_peer_request(), suggest_to_connect(), tcp_send(), tokenized_cb(), transmit_kx(), and transmit_kx().

scheduler_select_cls

void* scheduler_select_cls

static

Closure for scheduler_select.

Definition at line 436 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_set_select(), and select_loop().

shutdown_pipe_handle

struct GNUNET_DISK_PipeHandle* shutdown_pipe_handle

static

Pipe used to communicate shutdown via signal.

Definition at line 660 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_driver_done(), GNUNET_SCHEDULER_driver_init(), shutdown_pipe_cb(), and sighandler_shutdown().

my_pid

pid_t my_pid

static

Process ID of this process at the time we installed the various signal handlers.

Definition at line 666 of file scheduler.c.

Referenced by GNUNET_SCHEDULER_driver_init(), and sighandler_shutdown().