Scheduler library

Event loop (scheduler) More...

Collaboration diagram for Scheduler library:

Data Structures
struct	GNUNET_SCHEDULER_FdInfo
	Information about an event relating to a file descriptor/socket. More...
struct	GNUNET_SCHEDULER_TaskContext
	Context information passed to each scheduler task. More...
struct	GNUNET_SCHEDULER_Driver
	API an external event loop has to implement for GNUNET_SCHEDULER_driver_init. More...

Typedefs
typedef void(*	GNUNET_SCHEDULER_TaskCallback) (void *cls)
	Signature of the main function of a task. More...
typedef int(*	GNUNET_SCHEDULER_select) (void *cls, struct GNUNET_NETWORK_FDSet *rfds, struct GNUNET_NETWORK_FDSet *wfds, struct GNUNET_NETWORK_FDSet *efds, struct GNUNET_TIME_Relative timeout)
	Signature of the select function used by the scheduler. More...

Enumerations
enum	GNUNET_SCHEDULER_Reason {   GNUNET_SCHEDULER_REASON_NONE = 0 , GNUNET_SCHEDULER_REASON_STARTUP = 1 , GNUNET_SCHEDULER_REASON_SHUTDOWN = 2 , GNUNET_SCHEDULER_REASON_TIMEOUT = 4 ,   GNUNET_SCHEDULER_REASON_READ_READY = 8 , GNUNET_SCHEDULER_REASON_WRITE_READY = 16 , GNUNET_SCHEDULER_REASON_PREREQ_DONE = 32 }
	Reasons why the schedule may have triggered the task now. More...
enum	GNUNET_SCHEDULER_EventType {   GNUNET_SCHEDULER_ET_NONE = 0 , GNUNET_SCHEDULER_ET_IN = 1 , GNUNET_SCHEDULER_ET_OUT = 2 , GNUNET_SCHEDULER_ET_HUP = 4 ,   GNUNET_SCHEDULER_ET_ERR = 8 , GNUNET_SCHEDULER_ET_PRI = 16 , GNUNET_SCHEDULER_ET_NVAL = 32 }
	Possible events on FDs, used as a bitmask. More...

Functions
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. More...
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. More...
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. More...
void	GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh)
	Counter-part of GNUNET_SCHEDULER_driver_init. More...
struct GNUNET_SCHEDULER_Driver *	GNUNET_SCHEDULER_driver_select (void)
	Obtain the driver for using select() as the event loop. More...
void	GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Initialize and run scheduler. More...
void	GNUNET_SCHEDULER_run_with_optional_signals (int install_signals, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
	Initialize and run scheduler. More...
void	GNUNET_SCHEDULER_shutdown (void)
	Request the shutdown of a scheduler. More...
unsigned int	GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
	Get information about the current load of this scheduler. More...
const struct GNUNET_SCHEDULER_TaskContext *	GNUNET_SCHEDULER_get_task_context (void)
	Obtain the reasoning why the current task was started. More...
void *	GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)
	Cancel the task with the specified identifier. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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). More...
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. More...

Detailed Description

Event loop (scheduler)

Schedule computations using continuation passing style.

Typedef Documentation

GNUNET_SCHEDULER_TaskCallback

typedef void(* GNUNET_SCHEDULER_TaskCallback) (void *cls)

Signature of the main function of a task.

Parameters

cls

closure

Definition at line 323 of file gnunet_scheduler_lib.h.

GNUNET_SCHEDULER_select

typedef int(* GNUNET_SCHEDULER_select) (void *cls, struct GNUNET_NETWORK_FDSet *rfds, struct GNUNET_NETWORK_FDSet *wfds, struct GNUNET_NETWORK_FDSet *efds, struct GNUNET_TIME_Relative timeout)

Signature of the select function used by the scheduler.

GNUNET_NETWORK_socket_select matches it.

Parameters

cls	closure
rfds	set of sockets to be checked for readability
wfds	set of sockets to be checked for writability
efds	set of sockets to be checked for exceptions
timeout	relative value when to return

Returns

number of selected sockets, GNUNET_SYSERR on error

Definition at line 400 of file gnunet_scheduler_lib.h.

Enumeration Type Documentation

GNUNET_SCHEDULER_Reason

enum GNUNET_SCHEDULER_Reason

Reasons why the schedule may have triggered the task now.

Enumerator
GNUNET_SCHEDULER_REASON_NONE	This task is not ready.
GNUNET_SCHEDULER_REASON_STARTUP	This is the very first task run during startup.
GNUNET_SCHEDULER_REASON_SHUTDOWN	We are shutting down and are running all shutdown-related tasks.
GNUNET_SCHEDULER_REASON_TIMEOUT	The specified timeout has expired. (also set if the delay given was 0).
GNUNET_SCHEDULER_REASON_READ_READY	The reading socket is ready.
GNUNET_SCHEDULER_REASON_WRITE_READY	The writing socket is ready.
GNUNET_SCHEDULER_REASON_PREREQ_DONE	The prerequisite task is done.

Definition at line 59 of file gnunet_scheduler_lib.h.

{
  GNUNET_SCHEDULER_REASON_NONE = 0,
 
  GNUNET_SCHEDULER_REASON_STARTUP = 1,
 
  GNUNET_SCHEDULER_REASON_SHUTDOWN = 2,
 
  GNUNET_SCHEDULER_REASON_TIMEOUT = 4,
 
  GNUNET_SCHEDULER_REASON_READ_READY = 8,
 
  GNUNET_SCHEDULER_REASON_WRITE_READY = 16,
 
  GNUNET_SCHEDULER_REASON_PREREQ_DONE = 32
};

GNUNET_SCHEDULER_EventType

enum GNUNET_SCHEDULER_EventType

Possible events on FDs, used as a bitmask.

Modelled after GPollFD.

Enumerator
GNUNET_SCHEDULER_ET_NONE	No event (useful for timeout).
GNUNET_SCHEDULER_ET_IN	Data available for reading.
GNUNET_SCHEDULER_ET_OUT	Buffer available for writing.
GNUNET_SCHEDULER_ET_HUP
GNUNET_SCHEDULER_ET_ERR
GNUNET_SCHEDULER_ET_PRI
GNUNET_SCHEDULER_ET_NVAL

Definition at line 108 of file gnunet_scheduler_lib.h.

{
  GNUNET_SCHEDULER_ET_NONE = 0,
 
  GNUNET_SCHEDULER_ET_IN = 1,
 
  GNUNET_SCHEDULER_ET_OUT = 2,
 
  GNUNET_SCHEDULER_ET_HUP = 4,
 
  GNUNET_SCHEDULER_ET_ERR = 8,
 
  GNUNET_SCHEDULER_ET_PRI = 16,
 
  GNUNET_SCHEDULER_ET_NVAL = 32
};

Function Documentation

GNUNET_SCHEDULER_task_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.

This function will then queue the task to notify the application that the task is ready (with the respective priority).

Parameters

task	the task that is ready
fdi	information about the related FD

Definition at line 1953 of file scheduler.c.

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

References GNUNET_SCHEDULER_FdInfo::et, GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_SCHEDULER_ET_IN, GNUNET_SCHEDULER_ET_OUT, GNUNET_SCHEDULER_REASON_PREREQ_DONE, GNUNET_SCHEDULER_REASON_READ_READY, GNUNET_SCHEDULER_REASON_WRITE_READY, GNUNET_SCHEDULER_Task::in_ready_list, pending_head, pending_tail, queue_ready_task(), and GNUNET_SCHEDULER_Task::reason.

Referenced by select_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_do_work()

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.

Must be called only after GNUNET_SCHEDULER_driver_init has been called and before GNUNET_SCHEDULER_driver_done is called. This function may return even though there are tasks left to run just to give other tasks a chance as well. If we return GNUNET_YES, the event loop implementation should call this function again as soon as possible, while if we return GNUNET_NO it must block until either the operating system has more work (the scheduler has no more work to do right now) or the timeout set by the scheduler (using the set_wakeup callback) is reached.

Parameters

sh	scheduler handle that was returned by GNUNET_SCHEDULER_driver_init

Returns

GNUNET_YES if there are more tasks that are ready, and thus we would like to run more (yield to avoid blocking other activities for too long) GNUNET_NO if we are done running tasks (yield to block)

The event loop called this function before the current timeout was reached (and no FD tasks are ready). This is acceptable if

• the system time was changed while the driver was waiting for the timeout
• an external event loop called GNUnet API functions outside of the callbacks called in GNUNET_SCHEDULER_do_work and thus wasn't notified about the new timeout

It might also mean we are busy-waiting because of a programming error in the external event loop.

the current timeout was reached but no ready tasks were found, internal scheduler error!

Definition at line 1998 of file scheduler.c.

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

References GNUNET_TIME_Absolute::abs_value_us, active_task, GNUNET_SCHEDULER_Task::callback, GNUNET_SCHEDULER_Task::callback_cls, GNUNET_SCHEDULER_Driver::cls, current_lifeness, current_priority, GNUNET_SCHEDULER_Driver::del, DELAY_THRESHOLD, destroy_task(), dump_backtrace(), GNUNET_SCHEDULER_FdInfo::et, GNUNET_SCHEDULER_TaskContext::fds, GNUNET_SCHEDULER_Task::fds, GNUNET_SCHEDULER_TaskContext::fds_len, GNUNET_SCHEDULER_Task::fds_len, get_timeout(), GNUNET_assert, GNUNET_async_scope_enter(), GNUNET_async_scope_get(), GNUNET_async_scope_restore(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_NETWORK_fdset_set_native(), GNUNET_NETWORK_fdset_zero(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_ET_IN, GNUNET_SCHEDULER_ET_OUT, GNUNET_SCHEDULER_PRIORITY_COUNT, GNUNET_SCHEDULER_PRIORITY_KEEP, GNUNET_SCHEDULER_REASON_TIMEOUT, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, GNUNET_AsyncScopeSave::have_scope, GNUNET_SCHEDULER_Task::lifeness, LOG, max_priority_added, GNUNET_SCHEDULER_Task::next, pass_end_marker, pending_head, pending_tail, pending_timeout_head, pending_timeout_last, pending_timeout_tail, GNUNET_SCHEDULER_Task::priority, queue_ready_task(), GNUNET_SCHEDULER_TaskContext::read_ready, ready_count, ready_head, ready_tail, GNUNET_SCHEDULER_TaskContext::reason, GNUNET_SCHEDULER_Task::reason, GNUNET_TIME_Relative::rel_value_us, remove_pass_end_marker(), scheduler_driver, GNUNET_SCHEDULER_Task::scope, GNUNET_AsyncScopeSave::scope_id, GNUNET_SCHEDULER_Driver::set_wakeup, set_work_priority(), sh, shutdown_if_no_lifeness(), GNUNET_SCHEDULER_FdInfo::sock, tc, timeout, GNUNET_SCHEDULER_Task::timeout, work_priority, and GNUNET_SCHEDULER_TaskContext::write_ready.

Referenced by select_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_driver_init()

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.

An external implementation has to provide driver which contains callbacks for the scheduler (see definition of struct GNUNET_SCHEDULER_Driver). The callbacks are used to instruct the external implementation to watch for events. If it detects any of those events it is expected to call GNUNET_SCHEDULER_do_work to let the scheduler handle it. If an event is related to a specific task (e.g. the scheduler gave instructions to watch a file descriptor), the external implementation is expected to mark that task ready before by calling GNUNET_SCHEDULER_task_ready.

This function has to be called before any tasks are scheduled and before GNUNET_SCHEDULER_do_work is called for the first time. It allocates resources that have to be freed again by calling GNUNET_SCHEDULER_driver_done.

This function installs the same signal handlers as GNUNET_SCHEDULER_run. This means SIGTERM (and other similar signals) will induce a call to GNUNET_SCHEDULER_shutdown during the next call to GNUNET_SCHEDULER_do_work. As a result, SIGTERM causes all active tasks to be scheduled with reason GNUNET_SCHEDULER_REASON_SHUTDOWN. (However, tasks added afterwards will execute normally!). Note that any particular signal will only shut down one scheduler; applications should always only create a single scheduler.

Parameters

driver

to use for the event loop

Returns

handle to be passed to GNUNET_SCHEDULER_do_work and GNUNET_SCHEDULER_driver_done

Definition at line 2208 of file scheduler.c.

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

References GNUNET_SCHEDULER_Driver::cls, current_lifeness, current_priority, get_timeout(), GNUNET_assert, GNUNET_DISK_PF_NONE, GNUNET_DISK_pipe(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_handle_set(), GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SCHEDULER_PRIORITY_SHUTDOWN, GNUNET_SIGNAL_handler_install(), GNUNET_TERM_SIG, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, install_parent_control_handler(), install_parent_control_task, LOG, my_pid, scheduler_driver, GNUNET_SCHEDULER_Driver::set_wakeup, sh, shutdown_pipe_cb(), shutdown_pipe_handle, shutdown_pipe_task, sighandler_pipe(), and sighandler_shutdown().

Referenced by GNUNET_SCHEDULER_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_driver_done()

void GNUNET_SCHEDULER_driver_done

(

struct GNUNET_SCHEDULER_Handle *

sh

)

Counter-part of GNUNET_SCHEDULER_driver_init.

Has to be called by external event loop implementations after the scheduler has shut down. This is the case if both of the following conditions are met:

• all tasks the scheduler has added through the driver's add callback have been removed again through the driver's del callback
• the timeout the scheduler has set through the driver's add_wakeup callback is FOREVER

Parameters

sh	the handle returned by GNUNET_SCHEDULER_driver_init

Definition at line 2283 of file scheduler.c.

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

References GNUNET_break, GNUNET_DISK_pipe_close(), GNUNET_free, GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_PRIORITY_COUNT, GNUNET_SIGNAL_handler_uninstall(), pending_head, pending_timeout_head, ready_head, scheduler_driver, sh, shutdown_head, and shutdown_pipe_handle.

Referenced by GNUNET_SCHEDULER_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_driver_select()

struct GNUNET_SCHEDULER_Driver * GNUNET_SCHEDULER_driver_select

(

void

)

Obtain the driver for using select() as the event loop.

Returns

NULL on error

Definition at line 2545 of file scheduler.c.

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

References GNUNET_SCHEDULER_Driver::add, GNUNET_SCHEDULER_Driver::del, GNUNET_new, select_add(), select_del(), select_set_wakeup(), and GNUNET_SCHEDULER_Driver::set_wakeup.

Referenced by GNUNET_SCHEDULER_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_run()

void GNUNET_SCHEDULER_run	(	GNUNET_SCHEDULER_TaskCallback	task,
		void *	task_cls
	)

Initialize and run scheduler.

This function will return when all tasks have completed. On systems with signals, receiving a SIGTERM (and other similar signals) will cause GNUNET_SCHEDULER_shutdown to be run after the active task is complete. As a result, SIGTERM causes all shutdown tasks to be scheduled with reason GNUNET_SCHEDULER_REASON_SHUTDOWN. (However, tasks added afterwards will execute normally!). Note that any particular signal will only shut down one scheduler; applications should always only create a single scheduler.

Parameters

task	task to run first (and immediately)
task_cls	closure of task

Definition at line 725 of file scheduler.c.

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

References GNUNET_SCHEDULER_Driver::cls, context, GNUNET_break, GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_add_with_reason_and_priority(), GNUNET_SCHEDULER_driver_done(), GNUNET_SCHEDULER_driver_init(), GNUNET_SCHEDULER_driver_select(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SCHEDULER_REASON_STARTUP, GNUNET_TIME_absolute_get(), select_loop(), and sh.

Referenced by GNUNET_PROGRAM_run2(), GNUNET_SERVICE_main(), GNUNET_SERVICE_run_(), GNUNET_TESTING_main(), GNUNET_TESTING_service_run(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_run_with_optional_signals()

void GNUNET_SCHEDULER_run_with_optional_signals	(	int	install_signals,
		GNUNET_SCHEDULER_TaskCallback	task,
		void *	task_cls
	)

Initialize and run scheduler.

This function will return when all tasks have completed. When @ install_signals is GNUNET_YES, then this function behaves in the same was as GNUNET_SCHEDULER_run does. If @ install_signals is GNUNET_NO then no signal handlers are installed.

Parameters

install_signals	whether to install signals (GNUNET_YES/NO)
task	task to run first (and immediately)
task_cls	closure of task

GNUNET_SCHEDULER_shutdown()

void GNUNET_SCHEDULER_shutdown

(

void

)

Request the shutdown of a scheduler.

Marks all tasks awaiting shutdown as ready. Note that tasks scheduled with GNUNET_SCHEDULER_add_shutdown() AFTER this call will be delayed until the next shutdown signal.

Definition at line 567 of file scheduler.c.

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

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_REASON_SHUTDOWN, install_parent_control_task, LOG, queue_ready_task(), GNUNET_SCHEDULER_Task::reason, shutdown_head, shutdown_pipe_task, and shutdown_tail.

Referenced by action_loop(), add_continuation(), allocation_cb(), bandwidth_stats_cont(), calculate_pow(), channel_ended(), cleanup(), conn_status(), connect_check_run(), core_init(), delay_shutdown_cb(), dht_connected(), directory_scan_cb(), directory_trim_complete(), do_get(), do_quit(), do_send(), do_shutdown(), do_timeout(), ego_callback(), error_cb(), find_proof(), finish_command(), GCD_init(), get_cb(), get_ego(), handle_block(), handle_collect_result(), handle_data(), handle_estimate(), handle_result(), handle_revocation_union_request(), handle_stop(), handle_verify_result(), hello_done_cb(), hello_result_cb(), identity_cb(), identity_continuation(), init_callback(), init_socket(), list_callback(), main_init(), monitor_cb(), nat_register(), on_identity(), operation_timeout(), origin_create_cb(), parse(), path_callback(), peer_init_handler(), peers_callback(), print_finish(), print_indexed(), print_query_result(), print_revocation_result(), process_command_stdin(), process_lookup_result(), process_peer_string(), process_queue(), progress_cb(), put_cb(), read_stdio(), read_task(), reannounce_regex(), reply_handle(), requester_callback(), responder_callback(), run(), service_connect_comp(), show_peer(), shutdown_if_no_lifeness(), shutdown_pipe_cb(), shutdown_task(), sign_cb(), start_callback(), start_dump(), start_insert(), stats_cb(), stdin_cb(), stop_callback(), store_cb(), stun_read_task(), switch_to_speaker(), term_callback(), test_finished(), test_run(), testing_main(), timeout_task(), timeout_task_cb(), tokenizer_cb(), trigger_shutdown(), tunnels_callback(), uri_ksk_continuation(), uri_sks_continuation(), view_update_handle(), wait_child(), and zone_iteration_error().

Here is the call graph for this function:

GNUNET_SCHEDULER_get_load()

unsigned int GNUNET_SCHEDULER_get_load

(

enum GNUNET_SCHEDULER_Priority

p

)

Get information about the current load of this scheduler.

Use this function to determine if an elective task should be added or simply dropped (if the decision should be made based on the number of tasks ready to run).

Parameters

p	priority-level to query, use KEEP to query the level of the current task, use COUNT to get the sum over all priority levels

Returns

number of tasks pending right now

Use this function to determine if an elective task should be added or simply dropped (if the decision should be made based on the number of tasks ready to run).

Parameters

p	priority level to look at

Returns

number of tasks pending right now

Definition at line 775 of file scheduler.c.

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

References active_task, check_priority(), current_priority, GNUNET_assert, GNUNET_SCHEDULER_PRIORITY_COUNT, GNUNET_SCHEDULER_PRIORITY_KEEP, GNUNET_SCHEDULER_Task::in_ready_list, GNUNET_SCHEDULER_Task::next, p, pass_end_marker, GNUNET_SCHEDULER_Task::priority, ready_count, ready_head, and ret.

Here is the call graph for this function:

GNUNET_SCHEDULER_get_task_context()

const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context

(

void

)

Obtain the reasoning why the current task was started.

Returns

task context with information why the current task is run

Obtain the reasoning why the current task was started.

Returns

current tasks' scheduler context

Definition at line 758 of file scheduler.c.

{
  GNUNET_assert (NULL != active_task);
  return &tc;
}

References active_task, GNUNET_assert, and tc.

Referenced by cmd_read(), connect_probe_continuation(), do_read(), do_s5r_read(), do_udp_read(), maint_child_death(), read_dns4(), read_dns6(), read_response(), and tcp_send().

Here is the caller graph for this function:

GNUNET_SCHEDULER_cancel()

void * GNUNET_SCHEDULER_cancel

(

struct GNUNET_SCHEDULER_Task *

task

)

Cancel the task with the specified identifier.

The task must not yet have run. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

task	id of the task to cancel

Returns

original closure of the task

Definition at line 981 of file scheduler.c.

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

References GNUNET_SCHEDULER_Task::callback_cls, check_priority(), GNUNET_SCHEDULER_Driver::cls, GNUNET_SCHEDULER_Driver::del, destroy_task(), GNUNET_SCHEDULER_Task::fds, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_YES, GNUNET_SCHEDULER_Task::in_ready_list, LOG, GNUNET_SCHEDULER_Task::on_shutdown, p, pending_head, pending_tail, pending_timeout_head, pending_timeout_last, pending_timeout_tail, GNUNET_SCHEDULER_Task::priority, ready_count, ready_head, ready_tail, ret, scheduler_driver, shutdown_head, and shutdown_tail.

Referenced by abort_all_requests(), announce_next_regex(), backtalker_monotime_store_cb(), bi_destroy(), cadet_mq_cancel_impl(), calculate_pow_shutdown(), call_continuation(), cancel_aps(), channel_destroy(), check_autoconfig_finished(), check_completed(), check_disconnect(), child_management_done(), clean_request(), cleaning_task(), cleanup(), cleanup_cth(), cleanup_finish(), cleanup_handle(), cleanup_rs(), cleanup_s5r(), cleanup_task(), client_disconnect_cb(), close_srv_handle_room(), connection_client_cancel_impl(), connection_client_destroy_impl(), connection_ready_cb(), consider_peer_activate(), consider_peer_destroy(), consider_sending_fc(), consume_ticket(), continuation_print(), continue_store_activity(), cummulative_ack(), curl_download_prepare(), curl_task_download(), data_sent_cb(), destroy_channel(), destroy_handle(), destroy_iterator_cb(), destroy_message_control(), destroy_operation(), destroy_peer(), destroy_service(), destroy_srv_handle(), destroy_srv_room(), destroy_sub(), destroy_tunnel(), DHTU_ip_done(), disconnect_cb(), disconnect_notify(), dns_result_parser(), dns_result_processor(), do_cleanup(), do_error(), do_s5r_read(), do_shutdown(), do_stop_task(), do_suspend(), done_finish(), exp_cb(), finish_test(), free_ack_cummulator_cb(), free_active_lookup(), free_address_list_entry(), free_backtalker(), free_dv_route(), free_neighbour(), free_peer(), free_pending_request(), free_proto_queue(), free_qe(), free_queue(), free_queue_entry(), free_validation_state(), free_virtual_link(), GCC_destroy(), GCC_handle_connection_create_ack(), GCC_handle_duplicate_create(), GCC_transmit(), GCCH_bind(), GCCH_channel_local_destroy(), GCCH_handle_channel_open_ack(), GCCH_handle_channel_plaintext_data_ack(), GCCH_handle_local_data(), GCD_hello_update(), GCD_shutdown(), GCO_shutdown(), GCP_add_connection(), GCT_add_channel(), GCT_change_estate(), GCT_destroy_tunnel_now(), GCT_handle_encrypted(), GCT_handle_kx(), GCT_send(), GDS_CLIENTS_stop(), GDS_u_disconnect(), get_cadet(), get_iter(), get_lt_delete_it(), get_request_socket(), GN_nat_status_changed(), GN_stop_gnunet_nat_server_(), GNS_resolver_lookup_cancel(), GNUNET_ABD_disconnect(), GNUNET_ARM_disconnect(), GNUNET_ARM_monitor_stop(), GNUNET_ARM_operation_cancel(), GNUNET_BANDWIDTH_tracker_notification_stop(), GNUNET_CADET_disconnect(), GNUNET_CADET_get_channel_cancel(), GNUNET_CADET_get_path_cancel(), GNUNET_CADET_list_peers_cancel(), GNUNET_CADET_list_tunnels_cancel(), GNUNET_CORE_disconnect(), GNUNET_CRYPTO_hash_file_cancel(), GNUNET_CURL_gnunet_rc_destroy(), GNUNET_CURL_gnunet_scheduler_reschedule(), GNUNET_DATASTORE_disconnect(), GNUNET_DHT_disconnect(), GNUNET_DNS_disconnect(), GNUNET_DNSSTUB_resolve_cancel(), GNUNET_FS_dequeue_(), GNUNET_FS_directory_scan_abort(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_stop(), GNUNET_FS_publish_ksk_cancel(), GNUNET_FS_publish_signal_suspend_(), GNUNET_FS_publish_stop(), GNUNET_FS_publish_ublock_cancel_(), GNUNET_FS_queue_(), GNUNET_FS_search_pause(), GNUNET_FS_search_probe_progress_(), GNUNET_FS_search_signal_suspend_(), GNUNET_FS_search_start_searching_(), GNUNET_FS_search_stop(), GNUNET_FS_search_stop_probe_(), GNUNET_FS_stop(), GNUNET_FS_stop_probe_ping_task_(), GNUNET_GNS_disconnect(), GNUNET_HELPER_destroy(), GNUNET_HELPER_kill(), GNUNET_HELPER_send_cancel(), GNUNET_HELPER_wait(), GNUNET_HOSTLIST_client_stop(), GNUNET_HOSTLIST_server_stop(), GNUNET_IDENTITY_disconnect(), GNUNET_MQ_destroy(), GNUNET_NAMECACHE_disconnect(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAT_AUTO_test_start(), GNUNET_NAT_AUTO_test_stop(), GNUNET_NAT_autoconfig_cancel(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_NAT_mini_map_stop(), GNUNET_NAT_test_start(), GNUNET_NAT_test_stop(), GNUNET_NAT_unregister(), GNUNET_NSE_disconnect(), GNUNET_NT_scanner_done(), GNUNET_OS_command_stop(), GNUNET_PQ_event_listen_cancel(), GNUNET_RECLAIM_disconnect(), GNUNET_RESOLVER_disconnect(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_request_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_disable_continue_warning(), GNUNET_SERVICE_client_drop(), GNUNET_SET_listen_cancel(), GNUNET_SETI_listen_cancel(), GNUNET_SETU_listen_cancel(), GNUNET_SPEEDUP_stop_(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_application_done(), GNUNET_TRANSPORT_TESTING_connect_peers_cancel(), GNUNET_TRANSPORT_TESTING_stop_peer(), GNUNET_VPN_disconnect(), GSC_KX_done(), GSC_SESSIONS_confirm_typemap(), GSC_SESSIONS_end(), GSF_cadet_release_clients(), GSF_connected_peer_done_(), GSF_peer_disconnect_handler(), GSF_pending_request_cancel_(), GSF_plan_notify_peer_disconnect_(), GSF_push_done_(), GSF_put_done_(), handle_announce(), handle_core_disconnect(), handle_dht_local_get(), handle_disconnect_confirm(), handle_dns_response(), handle_encrypted(), handle_external_ip(), handle_flow_control(), handle_incoming_msg(), handle_monitor_next(), handle_p2p_estimate(), handle_ping(), handle_plaintext_channel_open(), handle_pong(), handle_stream_input(), handle_stun(), handle_transport_notify_disconnect(), helper_mst(), incoming_destroy(), insert_sorted(), kill_httpd(), maint_child_death(), manage_first_hop_mq(), mhd_log_callback(), monitor_unblock(), mq_cancel(), mq_error_handler(), notify_connect(), numeric_reverse(), on_identity(), parent_control_handler(), pending_reversals_delete_it(), primary_task(), process_job_queue(), process_local_reply(), process_peer_iteration_cb(), process_peer_monitoring_cb(), process_peer_string(), process_queue(), process_stat_done(), queue_destroy(), reconnect_later(), reconstruct_cont(), refresh_timeout_task(), regex_found_handler(), remove_channel_ctx(), remove_stream_request(), reschedule_hellos(), reset_cadet_async(), reset_handles(), RPS_sampler_request_cancel(), RPS_sampler_request_single_info_cancel(), run(), run_mhd_now(), schedule_current_round(), schedule_httpd(), schedule_read(), schedule_transmit_on_queue(), scheduler_fd_cb(), search_result_freeze_probes(), secret_destroy(), select_read_cb(), send_key(), send_response(), service_mq_cancel(), shutdown_hook(), shutdown_pch(), shutdown_task(), start_process(), start_typemap_task(), stop_helper(), stop_operation(), stop_peer_run(), stop_stun(), switch_to_speaker(), teardown_service(), terminate_ac_activities(), terminate_task(), test_master(), test_nat_punched(), try_transmission(), u_address_add(), u_address_del(), update_backtalker_monotime(), update_excess(), update_flood_times(), update_next_challenge_time(), update_timeout(), validation_transmit_on_queue(), and zone_iteration_error().

Here is the call graph for this function:

GNUNET_SCHEDULER_add_with_reason_and_priority()

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.

This is similar to the other "add" functions except that there is no delay and the reason code can be specified.

Parameters

task	main function of the task
task_cls	closure for task
reason	reason for task invocation
priority	priority to use for the task

Definition at line 1075 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);
  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);
}

References GNUNET_SCHEDULER_Task::callback, GNUNET_SCHEDULER_Task::callback_cls, check_priority(), current_lifeness, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_TIME_absolute_get(), init_backtrace(), GNUNET_SCHEDULER_Task::lifeness, LOG, GNUNET_SCHEDULER_Task::priority, queue_ready_task(), GNUNET_SCHEDULER_Task::read_fd, GNUNET_SCHEDULER_Task::reason, scheduler_driver, t, and GNUNET_SCHEDULER_Task::write_fd.

Referenced by GNUNET_SCHEDULER_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_with_priority()

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.

Parameters

prio	how important is the new task?
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 1232 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_UNIT_ZERO,
                                                     prio,
                                                     task,
                                                     task_cls);
}

References GNUNET_SCHEDULER_add_delayed_with_priority(), and GNUNET_TIME_UNIT_ZERO.

Referenced by begin_service(), block_proc(), create_srv_room(), deserialize_publish_file(), ds_put_cont(), encode_cont(), file_hash_task(), finish_reserve(), GNUNET_CRYPTO_hash_file(), GNUNET_FS_publish_start(), GNUNET_SCHEDULER_driver_init(), GSF_connected_peer_init_(), maint_child_death(), publish_kblocks_cont(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_now()

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.

Note that this does not guarantee that this will be the next task that is being run, as other tasks with higher priority (or that are already ready to run) might get to run first. Just as with delays, clients must not rely on any particular order of execution between tasks scheduled concurrently.

The task will be run with the DEFAULT priority.

Parameters

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 1305 of file scheduler.c.

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

References GNUNET_SCHEDULER_Task::callback, GNUNET_SCHEDULER_Task::callback_cls, current_lifeness, current_priority, GNUNET_async_scope_get(), GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, init_backtrace(), GNUNET_SCHEDULER_Task::lifeness, GNUNET_SCHEDULER_Task::on_shutdown, GNUNET_SCHEDULER_Task::priority, queue_ready_task(), GNUNET_SCHEDULER_Task::read_fd, GNUNET_SCHEDULER_Task::scope, t, GNUNET_SCHEDULER_Task::timeout, and GNUNET_SCHEDULER_Task::write_fd.

Referenced by add_attribute_cont(), add_continuation(), add_credential_cont(), advertise_dns_exit(), announce_regex(), attr_delete_cont(), attr_store_cont(), authorize_endpoint(), backchannel_check_run(), build_authz_response(), build_redirect(), bulk_tx_start(), cadet_mq_send_impl(), check_autoconfig_finished(), client_response_handler(), code_redirect(), collect_error_cb(), collect_finished_cb(), connect_cb(), connection_client_send_impl(), consistency_iter_fin(), consume_cont(), consume_fail(), consume_ticket_cont(), continuation_print(), continue_with_gns2dns(), cr_cont(), create_address_entry(), create_did(), create_did_cb(), create_did_ego_create_cb(), create_did_ego_lockup_cb(), create_download_context(), create_finished(), cred_delete_cont(), cred_error(), cred_iter_finished(), cred_store_cont(), decrypt_box(), del_attr_finished(), del_finished(), delete_attribute_cont(), delete_credential_cont(), delete_finished_cb(), deserialize_download(), DHTU_ip_init(), disconnect_notify(), dns_result_parser(), do_abort(), do_announce(), do_error(), do_finished(), ego_callback(), ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit(), ego_edit_name(), ego_edit_pubkey(), ego_get_all(), ego_get_name(), ego_get_pubkey(), ego_get_response(), ego_sign_data(), ego_sign_data_cb(), fail_resolution(), find_timed_out(), finished_cont(), free_dv_route(), free_neighbour(), gather_dht_put_blocks(), GCCH_bind(), GCCH_channel_local_destroy(), GCCH_handle_duplicate_open(), GCCH_tunnel_up(), GCP_attach_path(), GCT_change_estate(), GCT_create_tunnel(), GCT_handle_encrypted(), GCT_handle_kx(), GCT_send(), GDS_u_connect(), get_cont(), get_gns_cont(), get_oidc_dir_path(), GN_nat_status_changed(), GNS_resolver_lookup(), GNS_resolver_lookup_cancel(), GNUNET_ARM_request_service_start(), GNUNET_CLIENT_connect(), GNUNET_CURL_gnunet_scheduler_reschedule(), GNUNET_DNS_connect(), GNUNET_DNSSTUB_resolve(), GNUNET_FS_dequeue_(), GNUNET_FS_download_start_task_(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_ublock_(), GNUNET_FS_queue_(), GNUNET_FS_search_probe_progress_(), GNUNET_HOSTLIST_client_start(), GNUNET_MQ_impl_send_continue(), GNUNET_NAT_AUTO_test_start(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_NAT_test_start(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), GNUNET_SCHEDULER_add_now_with_lifeness(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TESTING_interpreter_fail(), GNUNET_TESTING_run(), GNUNET_TRANSPORT_TESTING_start_peer(), GSF_plan_add_(), GSF_put_init_(), handle_add_queue_message(), handle_attribute_store_message(), handle_credential_store_message(), handle_dht_local_get(), handle_disconnect_confirm(), handle_gns_redirect_result(), handle_gns_resolution_result(), handle_gns_response(), handle_local_ack(), handle_monitor_next(), handle_monitor_start(), handle_p2p_estimate(), handle_p2p_reply(), handle_stop(), handle_stream_input(), handler_advertisement(), hello_iter_cb(), identity_cb(), idle(), iface_proc(), import_next_cb(), init_callback(), interpreter_next(), iter_error(), iter_finished(), iterate_message_control(), kb_put_cont(), launch_registered_services(), list_attribute_cont(), list_callback(), list_credential_cont(), list_tickets_cont(), login_redirect(), lookup_hole_external(), lookup_redirect_uri_result(), main_task(), marked_deleted(), message_sent_cont(), monitor_iterate_cb(), mq_init(), namestore_add_or_update(), namestore_delete(), namestore_get(), namestore_import(), namestore_iteration_error(), namestore_list_finished(), new_sub(), notification_pipe_cb(), notify_srv_handle_member_id(), ns_get_lookup_cb(), ns_lookup_cb(), ns_lookup_error_cb(), offending_attr_delete_cont(), oidc_attr_collect_finished_cb(), oidc_iteration_error(), oidc_ticket_issue_cb(), options_cont(), origin_create_cb(), origin_lookup_cb(), post_ego_iteration(), primary_task(), print_did_document(), process_attrs(), process_delete(), process_dht_put_content(), process_dids(), process_helper_msgs(), process_result(), process_rvk(), process_stdin(), progress_cb(), purge_attributes(), put_cont(), queue_read_kx(), read_stdio(), reconnect_later(), reconstruct_cb(), recursive_dns_resolution(), recursive_gns2dns_resolution(), recursive_pkey_resolution(), regex_found_handler(), remove_did_document(), remove_did_document_namestore_cb(), replace_did_document(), reschedule_hellos(), reset_cadet_async(), resolve_did(), revoke_ticket_cont(), RPS_sampler_get_n_rand_peers(), RPS_sampler_get_rand_peer_info(), run(), run_mhd_now(), rvk_move_attr_cb(), rvk_ticket_update_finished(), schedule_channel_destruction(), schedule_next_task(), search_timed_out(), send_simple_single(), service_mq_send(), set_cont(), setup_sender(), sock_read(), start_callback(), start_peer_run(), start_probe_ping_task(), start_process(), start_resolver_lookup(), stat_timeout_task(), stop_callback(), store_completed_cb(), store_cont(), task_check(), term_callback(), test_icmp_server(), test_master(), ticket_issue_cb(), ticket_iter_err(), ticket_iter_fin(), ticket_processed(), ticket_updated(), timeout_task(), token_endpoint(), u_address_add(), u_address_del(), userinfo_endpoint(), zone_iteration_error(), and zone_iteration_finished().

Here is the call graph for this function:

GNUNET_SCHEDULER_add_shutdown()

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.

Parameters

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

References GNUNET_SCHEDULER_Task::callback, GNUNET_SCHEDULER_Task::callback_cls, GNUNET_assert, GNUNET_async_scope_get(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_PRIORITY_SHUTDOWN, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, init_backtrace(), GNUNET_SCHEDULER_Task::lifeness, LOG, GNUNET_SCHEDULER_Task::on_shutdown, GNUNET_SCHEDULER_Task::priority, GNUNET_SCHEDULER_Task::read_fd, scheduler_driver, GNUNET_SCHEDULER_Task::scope, shutdown_head, shutdown_tail, t, GNUNET_SCHEDULER_Task::timeout, and GNUNET_SCHEDULER_Task::write_fd.

Referenced by connect_check_run(), create_service(), ego_callback(), GNUNET_OS_install_parent_control_handler(), init_cb(), launch_registered_services(), main_init(), main_task(), on_identity(), program_main(), run(), service_main(), test_master(), and testing_main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_now_with_lifeness()

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.

This task (and all tasks created from it, other than by another call to this function) will either count or not count for the 'lifeness' of the process. This API is only useful in a few special cases.

Parameters

lifeness	GNUNET_YES if the task counts for lifeness, GNUNET_NO if not.
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 1373 of file scheduler.c.

{
  struct GNUNET_SCHEDULER_Task *ret;
 
  ret = GNUNET_SCHEDULER_add_now (task, task_cls);
  ret->lifeness = lifeness;
  return ret;
}

References GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_Task::lifeness, and ret.

Referenced by GNUNET_SPEEDUP_start_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_delayed()

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.

The task will be scheduled for execution once the delay has expired. It will be run with the DEFAULT priority.

Parameters

delay	with which the operation should be run
task	main function of the task
task_cls	closure of task

Returns

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

The task will be scheduled for execution once the delay has expired. It will be run with the DEFAULT priority.

Parameters

delay	when should this operation time out?
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 1278 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
                                                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                     task,
                                                     task_cls);
}

References GNUNET_SCHEDULER_add_delayed_with_priority(), and GNUNET_SCHEDULER_PRIORITY_DEFAULT.

Referenced by age_cover_counters(), announce_id(), announce_next_regex(), broadcast_hello(), calculate_pow(), callback_mq_error(), channel_new_cb(), channel_open_sent_cb(), check_disconnect(), check_timeouts(), check_zone_namestore_next(), cleanup_expired_records(), client_connect_cb(), connect_check_run(), connect_fail_continuation(), connection_ready_cb(), consider_gathering(), consider_peer_destroy(), consider_sending_fc(), continue_store_activity(), core_init(), curl_download_prepare(), daemon_started(), delay_warning(), delayed_get(), dht_connected(), disconnect_and_schedule_reconnect(), dns_pre_request_handler(), do_broadcast(), do_dht_put(), do_disconnect(), do_refresh(), do_rekey(), do_round(), do_scheduler_notify(), do_speedup(), error_handler(), expire_records_continuation(), find_string(), finished_cb(), force_reconnect(), GCC_handle_connection_create_ack(), GCCH_channel_incoming_new(), GCD_hello_update(), GCD_init(), GCT_remove_channel(), get_addresses(), get_cadet(), GNUNET_FS_search_probe_progress_(), GNUNET_HOSTLIST_client_start(), GNUNET_HOSTLIST_server_start(), GNUNET_NAMESTORE_records_store(), GNUNET_NAT_mini_map_start(), GNUNET_NAT_test_start(), GNUNET_NT_scanner_init(), GNUNET_PQ_event_listen(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), GNUNET_STATISTICS_destroy(), GNUNET_TESTING_run(), GSC_KX_init(), GSF_cadet_query_cancel(), handle_announce(), handle_autoconfig_request(), handle_client_listener_error(), handle_connection_create(), handle_core_connect(), handle_data(), handle_external_ip(), handle_fragment_box(), handle_monitor_next(), handle_mq_error(), handle_p2p_migration_stop(), handle_p2p_reply(), handle_ping(), handle_request(), handle_stun(), handle_transport_notify_connect(), handler_advertisement(), helper_read(), helper_write(), ifc_broadcast(), iter_finished(), kce_generate_cb(), keepalive_done(), learn_dv_path(), lookup_authz_cb(), main_init(), maintain_connections_cb(), manage_first_hop_mq(), monitor_unblock(), mq_error_handler(), mq_init(), netjail_exec_run(), odc_warn_delay_task(), peerstore_store_own_cb(), probe_ping_task_cb(), process_external_ip(), process_job_queue(), process_local_reply(), process_map_output(), process_peer_iteration_cb(), process_peer_monitoring_cb(), process_queue(), process_requests(), queue_send_msg(), queue_timeout(), read_from_log(), reannounce(), reannounce_regex(), reconnect(), reconnect_arm_later(), reconnect_arm_monitor_later(), reconnect_later(), recursive_dns_resolution(), refresh_timeout_task(), reschedule_connect(), resolve_and_cache(), REST_gns_process_request(), rest_identity_process_request(), REST_identity_process_request(), REST_namestore_process_request(), REST_openid_process_request(), REST_reclaim_process_request(), revive_migration(), run(), run_external_ip(), run_finish(), run_scan(), scan(), schedule_current_round(), schedule_httpd(), schedule_next_hello(), schedule_next_put(), schedule_next_task(), send_create_ack(), send_find_peer_message(), send_keep_alive(), send_keepalive(), send_key(), service_client_mst_cb(), setup_data_transfer(), setup_queue(), shc_cont(), start_cb(), start_dv_learn(), start_helper(), start_local_query(), start_typemap_task(), switch_to_speaker(), task_check(), task_download_dispatcher(), task_hostlist_saving(), test_master(), transmit_cummulative_ack_cb(), transmit_query(), transmit_task_cb(), transmit_typemap_task(), try_again(), try_reconnect(), update_excess(), update_flood_message(), update_flood_times(), update_timeout(), userinfo_endpoint(), warn_delay_task(), warn_monitor_slow(), warn_no_client_continue(), work(), and zone_iteration_finished().

Here is the call graph for this function:

GNUNET_SCHEDULER_add_at()

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.

The task will be scheduled for execution once specified time has been reached. It will be run with the DEFAULT priority.

Parameters

at	time at which this operation should run
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 1255 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_at_with_priority (at,
                                                GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                task,
                                                task_cls);
}

References GNUNET_SCHEDULER_add_at_with_priority(), and GNUNET_SCHEDULER_PRIORITY_DEFAULT.

Referenced by activate_core_visible_dv_path(), backtalker_monotime_store_cb(), backtalker_timeout_cb(), check_link_down(), connection_ready_cb(), core_init(), cummulative_ack(), data_sent_cb(), GCC_handle_duplicate_create(), GCCH_handle_channel_plaintext_data_ack(), GCT_add_channel(), GCT_handle_kx_auth(), handle_dv_box(), handle_validation_response(), insert_sorted(), manage_first_hop_mq(), path_cleanup_cb(), process_queue(), reassembly_cleanup_task(), schedule_peer_transmission(), timeout_cb(), transmit_next_request_task(), try_transmission(), update_flood_message(), and update_next_challenge_time().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_delayed_with_priority()

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.

The task will be scheduled for execution once the delay has expired.

Parameters

delay	when should this operation time out?
priority	priority to use for the task
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 1208 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_at_with_priority (
    GNUNET_TIME_relative_to_absolute (delay),
    priority,
    task,
    task_cls);
}

References GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_TIME_relative_to_absolute(), and GNUNET_SCHEDULER_Task::priority.

Referenced by cron_flush_respect(), delayed_disconnect_channel(), delayed_restart_task(), expired_processor(), find_proof(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_with_priority(), idle_request_room_messages(), load_operation(), on_identity(), schedule_transmit_on_queue(), and start_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_at_with_priority()

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.

The task will be scheduled for execution at time at.

Parameters

at	time when the operation should run
priority	priority to use for the task
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 1119 of file scheduler.c.

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

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_SCHEDULER_Task::callback, GNUNET_SCHEDULER_Task::callback_cls, check_priority(), current_lifeness, GNUNET_assert, GNUNET_async_scope_get(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_after, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), init_backtrace(), GNUNET_SCHEDULER_Task::lifeness, LOG, GNUNET_SCHEDULER_Task::next, pending_timeout_head, pending_timeout_last, pending_timeout_tail, GNUNET_SCHEDULER_Task::prev, GNUNET_SCHEDULER_Task::priority, queue_ready_task(), GNUNET_SCHEDULER_Task::read_fd, GNUNET_TIME_Relative::rel_value_us, scheduler_driver, GNUNET_SCHEDULER_Task::scope, t, GNUNET_SCHEDULER_Task::timeout, work_priority, and GNUNET_SCHEDULER_Task::write_fd.

Referenced by GNUNET_SCHEDULER_add_at(), and GNUNET_SCHEDULER_add_delayed_with_priority().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_read_net()

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.

The delay can be used as a timeout on the socket being ready. The task will be scheduled for execution once either the delay has expired or the socket operation is ready. It will be run with the DEFAULT priority. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

delay	when should this operation time out?
rfd	read file-descriptor
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 1512 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_read_net_with_priority (delay,
                                                      GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                      rfd, task, task_cls);
}

References GNUNET_SCHEDULER_add_read_net_with_priority(), and GNUNET_SCHEDULER_PRIORITY_DEFAULT.

Referenced by accept_client(), connect_success_continuation(), core_read_finished_cb(), create_listen_socket(), create_proto_queue(), delayed_restart_task(), DHTU_ip_init(), do_accept(), do_resume(), do_s5r_read(), do_scheduler_notify(), do_udp_read(), GNUNET_NAT_AUTO_test_start(), GNUNET_NAT_test_start(), init_socket(), listen_cb(), maint_child_death(), mq_init(), proto_read_kx(), queue_destroy(), queue_read(), queue_read_kx(), read_cb(), read_dns4(), read_dns6(), receive_complete_cb(), receive_ready(), resume_client_receive(), run(), scheduler_fd_cb(), select_read_cb(), service_client_recv(), sock_read(), start_client(), stun_read_task(), test_nat_punched(), and test_stun().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_read_net_with_priority()

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.

The delay can be used as a timeout on the socket being ready. The task will be scheduled for execution once either the delay has expired or the socket operation is ready. It will be run with the DEFAULT priority. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

delay	when should this operation time out?
priority	priority to use for the task
rfd	read file-descriptor
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 1546 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_net_with_priority (delay, priority,
                                                 rfd,
                                                 GNUNET_YES,
                                                 GNUNET_NO,
                                                 task, task_cls);
}

References GNUNET_NO, GNUNET_SCHEDULER_add_net_with_priority(), GNUNET_YES, and GNUNET_SCHEDULER_Task::priority.

Referenced by GNUNET_SCHEDULER_add_read_net().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_write_net()

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.

The delay can be used as a timeout on the socket being ready. The task will be scheduled for execution once either the delay has expired or the socket operation is ready. It will be run with the priority of the calling task. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

delay	when should this operation time out?
wfd	write file-descriptor
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 1583 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_net_with_priority (delay,
                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                                 wfd,
                                                 GNUNET_NO, GNUNET_YES,
                                                 task, task_cls);
}

References GNUNET_NO, GNUNET_SCHEDULER_add_net_with_priority(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, and GNUNET_YES.

Referenced by connect_success_continuation(), do_s5r_read(), do_send(), do_write(), mq_init(), mq_send(), proto_queue_write(), proto_read_kx(), queue_read_kx(), queue_write(), select_write_cb(), signal_socks_failure(), signal_socks_success(), transmit_ready(), try_connect_using_address(), try_connection_reversal(), try_handle_plaintext(), and try_send_tcp().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_net_with_priority()

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.

The delay can be used as a timeout on the socket being ready. The task will be scheduled for execution once either the delay has expired or the socket operation is ready. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

delay	when should this operation time out?
priority	priority of the task
fd	file-descriptor
on_read	whether to poll the file-descriptor for readability
on_write	whether to poll the file-descriptor for writability
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 1620 of file scheduler.c.

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

References add_without_sets(), GNUNET_assert, GNUNET_NETWORK_get_fd(), GNUNET_SCHEDULER_Task::priority, and scheduler_driver.

Referenced by GNUNET_SCHEDULER_add_read_net_with_priority(), and GNUNET_SCHEDULER_add_write_net().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_read_file()

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.

The delay can be used as a timeout on the socket being ready. The task will be scheduled for execution once either the delay has expired or the socket operation is ready. It will be run with the DEFAULT priority. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

delay	when should this operation time out?
rfd	read file-descriptor
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 1662 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_file_with_priority (
    delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
    rfd, GNUNET_YES, GNUNET_NO,
    task, task_cls);
}

References GNUNET_NO, GNUNET_SCHEDULER_add_file_with_priority(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, and GNUNET_YES.

Referenced by cmd_read(), GNUNET_ARM_request_service_start(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), GNUNET_OS_install_parent_control_handler(), GNUNET_SCHEDULER_driver_init(), GNUNET_wait_child(), handle_command(), helper_read(), initiate_put_from_pipe_trigger(), maint_child_death(), nat_server_read(), parent_control_handler(), read_external_ipv4(), read_task(), restart_nat_server(), run(), shutdown_pipe_cb(), start_helper(), stdin_cb(), testing_main(), and work().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_write_file()

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.

The delay can be used as a timeout on the socket being ready. The task will be scheduled for execution once either the delay has expired or the socket operation is ready. It will be run with the DEFAULT priority. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

delay	when should this operation time out?
wfd	write file-descriptor
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 1695 of file scheduler.c.

{
  return GNUNET_SCHEDULER_add_file_with_priority (
    delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
    wfd, GNUNET_NO, GNUNET_YES,
    task, task_cls);
}

References GNUNET_NO, GNUNET_SCHEDULER_add_file_with_priority(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, and GNUNET_YES.

Referenced by GNUNET_HELPER_send(), helper_write(), write_message(), and write_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_file_with_priority()

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.

The delay can be used as a timeout on the socket being ready. The task will be scheduled for execution once either the delay has expired or the socket operation is ready. Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

delay	when should this operation time out?
priority	priority of the task
fd	file-descriptor
on_read	whether to poll the file-descriptor for readability
on_write	whether to poll the file-descriptor for writability
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 1731 of file scheduler.c.

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

References add_without_sets(), GNUNET_DISK_FileHandle::fd, GNUNET_assert, GNUNET_SCHEDULER_Task::priority, and scheduler_driver.

Referenced by GNUNET_SCHEDULER_add_read_file(), and GNUNET_SCHEDULER_add_write_file().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_add_select()

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.

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) ) Only allowed to be called as long as the scheduler is running, that is one of the following conditions is met:

• GNUNET_SCHEDULER_run has been called and has not returned yet
• GNUNET_SCHEDULER_driver_init has been run and GNUNET_SCHEDULER_driver_done has not been called yet

Parameters

prio	how important is this task?
delay	how long should we wait?
rs	set of file descriptors we want to read (can be NULL)
ws	set of file descriptors we want to write (can be NULL)
task	main function of the task
task_cls	closure of task

Returns

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

here we consider the case that a GNUNET_NETWORK_FDSet might be empty although its maximum FD number (nsds) is greater than 0. We handle this case gracefully because some libraries such as libmicrohttpd only provide a hint what the maximum FD number in an FD set might be and not the exact FD number (see e.g. gnunet-rest-service.c)

Definition at line 1836 of file scheduler.c.

{
  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;
 
  /* scheduler must be running */
  GNUNET_assert (NULL != scheduler_driver);
  GNUNET_assert (NULL != task);
  int no_rs = (NULL == rs);
  int no_ws = (NULL == ws);
  int empty_rs = (NULL != rs) && (0 == rs->nsds);
  int empty_ws = (NULL != ws) && (0 == ws->nsds);
  int no_fds = (no_rs && no_ws) ||
               (empty_rs && empty_ws) ||
               (no_rs && empty_ws) ||
               (no_ws && empty_rs);
  if (! no_fds)
  {
    if (NULL != rs)
    {
      extract_handles (rs,
                       &read_nhandles,
                       &read_nhandles_len,
                       &read_fhandles,
                       &read_fhandles_len);
    }
    if (NULL != ws)
    {
      extract_handles (ws,
                       &write_nhandles,
                       &write_nhandles_len,
                       &write_fhandles,
                       &write_fhandles_len);
    }
  }int no_fds_extracted = (0 == read_nhandles_len) &&
                         (0 == read_fhandles_len) &&
                         (0 == write_nhandles_len) &&
                         (0 == write_fhandles_len);
  if (no_fds || no_fds_extracted)
    return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
                                                       prio,
                                                       task,
                                                       task_cls);
  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;
}

References GNUNET_SCHEDULER_Task::callback, GNUNET_SCHEDULER_Task::callback_cls, check_priority(), current_lifeness, current_priority, driver_add_multiple(), extract_handles(), GNUNET_array_grow, GNUNET_assert, GNUNET_async_scope_get(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MAX, GNUNET_new, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_KEEP, GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, init_backtrace(), init_fd_info(), GNUNET_SCHEDULER_Task::lifeness, LOG, max_priority_added, GNUNET_NETWORK_FDSet::nsds, GNUNET_SCHEDULER_Task::own_handles, pending_head, pending_tail, GNUNET_SCHEDULER_Task::priority, scheduler_driver, GNUNET_SCHEDULER_Task::scope, t, and GNUNET_SCHEDULER_Task::timeout.

Referenced by context_task(), curl_download_prepare(), download_prepare(), listen_stdio(), prepare_daemon(), run_httpd(), schedule_httpd(), and schedule_read().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SCHEDULER_set_select()

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

Parameters

new_select	new select function to use (NULL to reset to default)
new_select_cls	closure for new_select
new_select	new select function to use
new_select_cls	closure for new_select

Returns

previously used select function, NULL for default

Definition at line 447 of file scheduler.c.

{
  scheduler_select = new_select;
  scheduler_select_cls = new_select_cls;
}

References scheduler_select, and scheduler_select_cls.

GNUNET_SCHEDULER_begin_async_scope()

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.

Nested tasks can begin their own nested async scope.

Once the current task is finished, the async scope ID is reset to its previous value.

Must only be called from a running task.

Parameters

aid	the asynchronous scope id to enter

Definition at line 2572 of file scheduler.c.

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

References active_task, GNUNET_assert, and GNUNET_async_scope_enter().

Here is the call graph for this function: