39 files changed, 181 insertions, 204 deletions

diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c
index 5fbb608e7..2df2a9449 100644
--- a/src/util/bandwidth.c
+++ b/src/util/bandwidth.c
@@ -142,11 +142,9 @@ GNUNET_BANDWIDTH_value_get_delay_for (struct GNUNET_BANDWIDTH_Value32NBO bps,
  * Task run whenever we hit the bandwidth limit for a tracker.
  *
  * @param cls the `struct GNUNET_BANDWIDTH_Tracker`
- * @param tc scheduler context
  */
 static void
-excess_trigger (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+excess_trigger (void *cls)
 {
   struct GNUNET_BANDWIDTH_Tracker *av = cls;
 
diff --git a/src/util/client.c b/src/util/client.c
index d87be74f6..f93fd1d10 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -579,11 +579,9 @@ receive_helper (void *cls,
  * Continuation to call the receive callback.
  *
  * @param cls  our handle to the client connection
- * @param tc scheduler context
  */
 static void
-receive_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+receive_task (void *cls)
 {
   struct GNUNET_CLIENT_Connection *client = cls;
   GNUNET_CLIENT_MessageHandler handler = client->receiver_handler;
@@ -746,11 +744,9 @@ GNUNET_CLIENT_service_test_cancel (struct GNUNET_CLIENT_TestHandle *th)
  * and then cleans up.
  *
  * @param cls the `struct GNUNET_CLIENT_TestHandle`
- * @param tc scheduler context
  */
 static void
-report_result (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+report_result (void *cls)
 {
   struct GNUNET_CLIENT_TestHandle *th = cls;
 
@@ -1080,16 +1076,16 @@ client_notify (void *cls, size_t size, void *buf);
  * service after a while.
  *
  * @param cls our `struct GNUNET_CLIENT_TransmitHandle` of the request
- * @param tc unused
  */
 static void
-client_delayed_retry (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+client_delayed_retry (void *cls)
 {
   struct GNUNET_CLIENT_TransmitHandle *th = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   struct GNUNET_TIME_Relative delay;
 
   th->reconnect_task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
     /* give up, was shutdown */
@@ -1153,11 +1149,14 @@ client_notify (void *cls,
   struct GNUNET_CLIENT_Connection *client = th->client;
   size_t ret;
   struct GNUNET_TIME_Relative delay;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
+
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "client_notify is running\n");
   th->th = NULL;
   client->th = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (NULL == buf)
   {
     delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
@@ -1165,7 +1164,7 @@ client_notify (void *cls,
     if ( (GNUNET_YES != th->auto_retry) ||
          (0 == --th->attempts_left) ||
          (delay.rel_value_us < 1)||
-         (0 != (GNUNET_SCHEDULER_get_reason() & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
+         (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Transmission failed %u times, giving up.\n",
diff --git a/src/util/client_manager.c b/src/util/client_manager.c
index 12c37b23f..f334bb5b6 100644
--- a/src/util/client_manager.c
+++ b/src/util/client_manager.c
@@ -240,7 +240,7 @@ transmit_next (struct GNUNET_CLIENT_MANAGER_Connection *mgr);
 
 
 static void
-schedule_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+schedule_disconnect (void *cls)
 {
   struct GNUNET_CLIENT_MANAGER_Connection *mgr = cls;
   GNUNET_CLIENT_MANAGER_disconnect (mgr, GNUNET_NO,
@@ -341,11 +341,9 @@ transmit_next (struct GNUNET_CLIENT_MANAGER_Connection *mgr)
  *
  * @param cls
  *        Channel handle.
- * @param tc
- *        Scheduler context.
  */
 static void
-schedule_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+schedule_reconnect (void *cls)
 {
   struct GNUNET_CLIENT_MANAGER_Connection *mgr = cls;
   mgr->reconnect_task = NULL;
diff --git a/src/util/connection.c b/src/util/connection.c
index 5aa277546..b3ea3b5af 100644
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -606,10 +606,9 @@ connect_fail_continuation (struct GNUNET_CONNECTION_Handle *connection)
  * We are ready to transmit (or got a timeout).
  *
  * @param cls our connection handle
- * @param tc task context describing why we are here
  */
 static void
-transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+transmit_ready (void *cls);
 
 
 /**
@@ -617,10 +616,9 @@ transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
  * to read.
  *
  * @param cls connection to read from
- * @param tc scheduler context
  */
 static void
-receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+receive_ready (void *cls);
 
 
 /**
@@ -668,15 +666,14 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *connection)
  * Scheduler let us know that we're either ready to write on the
  * socket OR connect timed out.  Do the right thing.
  *
- * @param cls the "struct AddressProbe*" with the address that we are probing
- * @param tc success or failure info about the connect attempt.
+ * @param cls the `struct AddressProbe *` with the address that we are probing
  */
 static void
-connect_probe_continuation (void *cls,
-                            const struct GNUNET_SCHEDULER_TaskContext *tc)
+connect_probe_continuation (void *cls)
 {
   struct AddressProbe *ap = cls;
   struct GNUNET_CONNECTION_Handle *connection = ap->connection;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   struct AddressProbe *pos;
   int error;
   socklen_t len;
@@ -686,6 +683,7 @@ connect_probe_continuation (void *cls,
   len = sizeof (error);
   errno = 0;
   error = 0;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
       (GNUNET_OK !=
        GNUNET_NETWORK_socket_getsockopt (ap->sock, SOL_SOCKET, SO_ERROR, &error,
@@ -1095,18 +1093,18 @@ GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *connection)
  * or have data ready to read.
  *
  * @param cls connection to read from
- * @param tc scheduler context
  */
 static void
-receive_ready (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+receive_ready (void *cls)
 {
   struct GNUNET_CONNECTION_Handle *connection = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   char buffer[connection->max];
   ssize_t ret;
   GNUNET_CONNECTION_Receiver receiver;
 
   connection->read_task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
     /* ignore shutdown request, go again immediately */
@@ -1296,11 +1294,9 @@ process_notify (struct GNUNET_CONNECTION_Handle *connection)
  * This task notifies the client about the timeout.
  *
  * @param cls the `struct GNUNET_CONNECTION_Handle`
- * @param tc scheduler context
  */
 static void
-transmit_timeout (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmit_timeout (void *cls)
 {
   struct GNUNET_CONNECTION_Handle *connection = cls;
   GNUNET_CONNECTION_TransmitReadyNotify notify;
@@ -1327,11 +1323,9 @@ transmit_timeout (void *cls,
  * This task notifies the client about the error.
  *
  * @param cls the `struct GNUNET_CONNECTION_Handle`
- * @param tc scheduler context
  */
 static void
-connect_error (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+connect_error (void *cls)
 {
   struct GNUNET_CONNECTION_Handle *connection = cls;
   GNUNET_CONNECTION_TransmitReadyNotify notify;
@@ -1353,14 +1347,13 @@ connect_error (void *cls,
  * We are ready to transmit (or got a timeout).
  *
  * @param cls our connection handle
- * @param tc task context describing why we are here
  */
 static void
-transmit_ready (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmit_ready (void *cls)
 {
   struct GNUNET_CONNECTION_Handle *connection = cls;
   GNUNET_CONNECTION_TransmitReadyNotify notify;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   ssize_t ret;
   size_t have;
 
@@ -1370,6 +1363,7 @@ transmit_ready (void *cls,
   GNUNET_assert (NULL != connection->write_task);
   connection->write_task = NULL;
   GNUNET_assert (NULL == connection->nth.timeout_task);
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
     if (NULL != connection->sock)
diff --git a/src/util/crypto_hash_file.c b/src/util/crypto_hash_file.c
index 8bb03561b..f2d49d164 100644
--- a/src/util/crypto_hash_file.c
+++ b/src/util/crypto_hash_file.c
@@ -117,10 +117,9 @@ file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc,
  * File hashing task.
  *
  * @param cls closure
- * @param tc context
  */
 static void
-file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+file_hash_task (void *cls)
 {
   struct GNUNET_CRYPTO_FileHashContext *fhc = cls;
   struct GNUNET_HashCode *res;
diff --git a/src/util/disk_iterator.c b/src/util/disk_iterator.c
index 925d4c6fd..2315f2861 100644
--- a/src/util/disk_iterator.c
+++ b/src/util/disk_iterator.c
@@ -77,8 +77,7 @@ struct GNUNET_DISK_DirectoryIterator
  * Task used by the directory iterator.
  */
 static void
-directory_iterator_task (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+directory_iterator_task (void *cls)
 {
   struct GNUNET_DISK_DirectoryIterator *iter = cls;
   char *name;
diff --git a/src/util/gnunet-scrypt.c b/src/util/gnunet-scrypt.c
index 434574ef0..7449d8042 100644
--- a/src/util/gnunet-scrypt.c
+++ b/src/util/gnunet-scrypt.c
@@ -110,8 +110,7 @@ count_leading_zeroes (const struct GNUNET_HashCode *hash)
  * @param tc task context
  */
 static void
-find_proof (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+find_proof (void *cls)
 {
   #define ROUND_SIZE 10
   uint64_t counter;
@@ -121,7 +120,9 @@ find_proof (void *cls,
   unsigned int i;
   struct GNUNET_TIME_Absolute timestamp;
   struct GNUNET_TIME_Relative elapsed;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
   {
     write_proof ();
diff --git a/src/util/gnunet-uri.c b/src/util/gnunet-uri.c
index ada67e310..75e70d2b7 100644
--- a/src/util/gnunet-uri.c
+++ b/src/util/gnunet-uri.c
@@ -47,10 +47,9 @@ static struct GNUNET_DISK_PipeHandle *sigpipe;
  * process died) or when user presses CTRL-C.
  *
  * @param cls closure, NULL
- * @param tc scheduler context
  */
 static void
-maint_child_death (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+maint_child_death (void *cls)
 {
   enum GNUNET_OS_ProcessStatusType type;
   if ( (GNUNET_OK !=
diff --git a/src/util/helper.c b/src/util/helper.c
index f0123460b..3ed1c7276 100644
--- a/src/util/helper.c
+++ b/src/util/helper.c
@@ -138,7 +138,7 @@ struct GNUNET_HELPER_Handle
    * NULL-terminated list of command-line arguments.
    */
   char **binary_argv;
-                
+
   /**
    * Task to read from the helper.
    */
@@ -305,28 +305,26 @@ stop_helper (struct GNUNET_HELPER_Handle *h,
  * Restart the helper process.
  *
  * @param cls handle to the helper process
- * @param tc scheduler context
  */
 static void
-restart_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc);
+restart_task (void *cls);
 
 
 /**
  * Read from the helper-process
  *
  * @param cls handle to the helper process
- * @param tc scheduler context
  */
 static void
-helper_read (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+helper_read (void *cls)
 {
   struct GNUNET_HELPER_Handle *h = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE] GNUNET_ALIGN;
   ssize_t t;
 
   h->read_task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
     /* try again */
@@ -458,17 +456,15 @@ start_helper (struct GNUNET_HELPER_Handle *h)
  * Restart the helper process.
  *
  * @param cls handle to the helper process
- * @param tc scheduler context
  */
 static void
-restart_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_task (void *cls)
 {
   struct GNUNET_HELPER_Handle*h = cls;
 
   h->restart_task = NULL;
   h->retry_back_off++;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Restarting helper with back-off %u\n",
               h->retry_back_off);
   start_helper (h);
@@ -582,18 +578,18 @@ GNUNET_HELPER_stop (struct GNUNET_HELPER_Handle *h,
  * Write to the helper-process
  *
  * @param cls handle to the helper process
- * @param tc scheduler context
  */
 static void
-helper_write (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+helper_write (void *cls)
 {
   struct GNUNET_HELPER_Handle *h = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   struct GNUNET_HELPER_SendHandle *sh;
   const char *buf;
   ssize_t t;
 
   h->write_task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
     /* try again */
diff --git a/src/util/mq.c b/src/util/mq.c
index f5ebe33a5..aff9f465c 100644
--- a/src/util/mq.c
+++ b/src/util/mq.c
@@ -297,15 +297,15 @@ GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq,
  * results in undefined behavior if not used carefully.
  *
  * @param cls message queue to send the next message with
- * @param tc scheduler context
  */
 static void
-impl_send_continue (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+impl_send_continue (void *cls)
 {
   struct GNUNET_MQ_Handle *mq = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   struct GNUNET_MQ_Envelope *current_envelope;
 
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
 
diff --git a/src/util/os_priority.c b/src/util/os_priority.c
index 52e2f6d0e..8dfec6c5e 100644
--- a/src/util/os_priority.c
+++ b/src/util/os_priority.c
@@ -70,18 +70,19 @@ static struct GNUNET_OS_Process current_process;
  * This handler is called when there are control data to be read on the pipe
  *
  * @param cls the 'struct GNUNET_DISK_FileHandle' of the control pipe
- * @param tc scheduler context
  */
 static void
-parent_control_handler (void *cls,
-                        const struct GNUNET_SCHEDULER_TaskContext *tc)
+parent_control_handler (void *cls)
 {
   struct GNUNET_DISK_FileHandle *control_pipe = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   char sig;
   char *pipe_fd;
   ssize_t ret;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "`%s' invoked because of %d\n", __FUNCTION__,
+  tc = GNUNET_SCHEDULER_get_task_context ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "`%s' invoked because of %d\n", __FUNCTION__,
        tc->reason);
   if (0 != (tc->reason &
             (GNUNET_SCHEDULER_REASON_SHUTDOWN | GNUNET_SCHEDULER_REASON_TIMEOUT)))
@@ -118,12 +119,9 @@ parent_control_handler (void *cls,
  * variable) and raise those signals.
  *
  * @param cls closure (unused)
- * @param tc scheduler context (unused)
  */
 void
-GNUNET_OS_install_parent_control_handler (void *cls,
-                                          const struct
-                                          GNUNET_SCHEDULER_TaskContext *tc)
+GNUNET_OS_install_parent_control_handler (void *cls)
 {
   const char *env_buf;
   char *env_buf_end;
@@ -1751,18 +1749,19 @@ GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
 /**
  * Read from the process and call the line processor.
  *
- * @param cls the 'struct GNUNET_OS_CommandHandle'
- * @param tc scheduler context
+ * @param cls the `struct GNUNET_OS_CommandHandle *`
  */
 static void
-cmd_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+cmd_read (void *cls)
 {
   struct GNUNET_OS_CommandHandle *cmd = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   GNUNET_OS_LineProcessor proc;
   char *end;
   ssize_t ret;
 
   cmd->rtask = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (GNUNET_YES != GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, cmd->r))
   {
     /* timeout, shutdown, etc. */
diff --git a/src/util/program.c b/src/util/program.c
index 7023552f6..69dd455cd 100644
--- a/src/util/program.c
+++ b/src/util/program.c
@@ -73,10 +73,12 @@ struct CommandContext
  * program.  Runs the program-specific main task.
  */
 static void
-program_main (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+program_main (void *cls)
 {
   struct CommandContext *cc = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     return;
   GNUNET_SPEEDUP_start_(cc->cfg);
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index 81ec01af4..e7a836f03 100644
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.c
@@ -532,11 +532,9 @@ handle_response (void *cls,
  * numeric addresses.
  *
  * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
- * @param tc unused scheduler context
  */
 static void
-numeric_resolution (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+numeric_resolution (void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   struct sockaddr_in v4;
@@ -600,11 +598,9 @@ numeric_resolution (void *cls,
  * respective loopback numeric addresses.
  *
  * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
- * @param tc unused scheduler context
  */
 static void
-loopback_resolution (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+loopback_resolution (void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   struct sockaddr_in v4;
@@ -658,8 +654,7 @@ loopback_resolution (void *cls,
  * Task executed on system shutdown.
  */
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   s_task = NULL;
   GNUNET_RESOLVER_disconnect ();
@@ -728,15 +723,16 @@ process_requests ()
  * Now try to reconnect to the resolver service.
  *
  * @param cls NULL
- * @param tc scheduler context
  */
 static void
-reconnect_task (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect_task (void *cls)
 {
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
+
   r_task = NULL;
   if (NULL == req_head)
     return;                     /* no work pending */
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -802,11 +798,9 @@ reconnect ()
  * A DNS resolution timed out. Notify the application.
  *
  * @param cls the `struct GNUNET_RESOLVER_RequestHandle *`
- * @param tc scheduler context
  */
 static void
-handle_lookup_timeout (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+handle_lookup_timeout (void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
 
@@ -902,11 +896,9 @@ GNUNET_RESOLVER_ip_get (const char *hostname,
  * conversion and invoke the callback.
  *
  * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
- * @param tc unused scheduler context
  */
 static void
-numeric_reverse (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+numeric_reverse (void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   char *result;
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 6405ea336..dcf5aeeaa 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -256,6 +256,11 @@ static int current_lifeness;
 static GNUNET_SCHEDULER_select scheduler_select;
 
 /**
+ * Task context of the current task.
+ */
+static struct GNUNET_SCHEDULER_TaskContext tc;
+
+/**
  * Closure for #scheduler_select.
  */
 static void *scheduler_select_cls;
@@ -533,7 +538,6 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs,
 {
   enum GNUNET_SCHEDULER_Priority p;
   struct GNUNET_SCHEDULER_Task *pos;
-  struct GNUNET_SCHEDULER_TaskContext tc;
 
   max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
   do
@@ -584,7 +588,7 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs,
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Running task: %p\n",
          pos);
-    pos->callback (pos->callback_cls, &tc);
+    pos->callback (pos->callback_cls);
 #if EXECINFO
     unsigned int i;
 
@@ -902,17 +906,16 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
 
 
 /**
- * Obtain the reason code for why the current task was
- * started.  Will return the same value as
- * the `struct GNUNET_SCHEDULER_TaskContext`'s reason field.
+ * Obtain the task context, giving the reason why the current task was
+ * started.
  *
- * @return reason(s) why the current task is run
+ * @return current tasks' scheduler context
  */
-enum GNUNET_SCHEDULER_Reason
-GNUNET_SCHEDULER_get_reason ()
+const struct GNUNET_SCHEDULER_TaskContext *
+GNUNET_SCHEDULER_get_task_context ()
 {
   GNUNET_assert (NULL != active_task);
-  return active_task->reason;
+  return &tc;
 }
 
 
diff --git a/src/util/server.c b/src/util/server.c
index 0433feb58..8dedd28fd 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -389,17 +389,17 @@ GNUNET_SERVER_client_set_user_context_ (struct GNUNET_SERVER_Client *client,
  *
  * @param cls handle to our server for which we are processing the listen
  *        socket
- * @param tc reason why we are running right now
  */
 static void
-process_listen_socket (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+process_listen_socket (void *cls)
 {
   struct GNUNET_SERVER_Handle *server = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
   struct GNUNET_CONNECTION_Handle *sock;
   unsigned int i;
 
   server->listen_task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
     /* ignore shutdown, someone else will take care of it! */
@@ -655,12 +655,10 @@ GNUNET_SERVER_client_mark_monitor (struct GNUNET_SERVER_Client *client)
  * Helper function for #test_monitor_clients() to trigger
  * #GNUNET_SERVER_destroy() after the stack has unwound.
  *
- * @param cls the 'struct GNUNET_SERVER_Handle' to destroy
- * @param tc unused
+ * @param cls the `struct GNUNET_SERVER_Handle *` to destroy
  */
 static void
-do_destroy (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_destroy (void *cls)
 {
   struct GNUNET_SERVER_Handle *server = cls;
 
@@ -887,18 +885,18 @@ GNUNET_SERVER_set_callbacks (struct GNUNET_SERVER_Handle *server,
  * Task run to warn about missing calls to #GNUNET_SERVER_receive_done.
  *
  * @param cls our `struct GNUNET_SERVER_Client *` to process more requests from
- * @param tc scheduler context (unused)
  */
 static void
-warn_no_receive_done (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+warn_no_receive_done (void *cls)
 {
   struct GNUNET_SERVER_Client *client = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   GNUNET_break (0 != client->warn_type); /* type should never be 0 here, as we don't use 0 */
   client->warn_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
                                     &warn_no_receive_done, client);
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 == (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     LOG (GNUNET_ERROR_TYPE_WARNING,
          _("Processing code for message of type %u did not call `GNUNET_SERVER_receive_done' after %s\n"),
@@ -1199,11 +1197,9 @@ process_incoming (void *cls,
  * and process requests.
  *
  * @param cls our `struct GNUNET_SERVER_Client *` to process more requests from
- * @param tc scheduler context (unused)
  */
 static void
-restart_processing (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_processing (void *cls)
 {
   struct GNUNET_SERVER_Client *client = cls;
 
@@ -1497,11 +1493,9 @@ GNUNET_SERVER_connect_notify_cancel (struct GNUNET_SERVER_Handle *server,
  * 'connection.c' is not allowed (see #2329).
  *
  * @param cls connection to destroy
- * @param tc scheduler context (unused)
  */
 static void
-destroy_connection (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+destroy_connection (void *cls)
 {
   struct GNUNET_CONNECTION_Handle *connection = cls;
 
diff --git a/src/util/service.c b/src/util/service.c
index be3b4442a..76e540302 100644
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -1126,11 +1126,9 @@ write_pid_file (struct GNUNET_SERVICE_Context *sctx, pid_t pid)
  * Task run during shutdown.  Stops the server/service.
  *
  * @param cls the `struct GNUNET_SERVICE_Context`
- * @param tc unused
  */
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   struct GNUNET_SERVICE_Context *service = cls;
   struct GNUNET_SERVER_Handle *server = service->server;
@@ -1147,14 +1145,15 @@ shutdown_task (void *cls,
  * Initial task for the service.
  *
  * @param cls service context
- * @param tc unused
  */
 static void
-service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+service_task (void *cls)
 {
   struct GNUNET_SERVICE_Context *sctx = cls;
   unsigned int i;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     return;
   (void) GNUNET_SPEEDUP_start_ (sctx->cfg);
diff --git a/src/util/socks.c b/src/util/socks.c
index 3fa18cca9..cc59858dd 100644
--- a/src/util/socks.c
+++ b/src/util/socks.c
@@ -105,7 +105,7 @@ unsigned char * SOCK5_proto_string(unsigned char * b, const char * s)
 /**
  * State of the SOCKS5 handshake.
  */
-struct GNUNET_SOCKS_Handshake 
+struct GNUNET_SOCKS_Handshake
 {
 
   /**
@@ -124,7 +124,7 @@ struct GNUNET_SOCKS_Handshake
   struct GNUNET_CONNECTION_TransmitHandle *th;
 
   /**
-   * Our stage in the SOCKS5 handshake 
+   * Our stage in the SOCKS5 handshake
    */
   int step;
 
@@ -199,7 +199,7 @@ SOCKS5_handshake_step (struct GNUNET_SOCKS_Handshake *ih)
   GNUNET_assert (SOCKS5_step_done > ih->step && ih->step >= 0);
   switch (ih->step) {
     case SOCKS5_step_greet:  /* SOCKS5 server's greeting */
-      if (b[0] != 5) 
+      if (b[0] != 5)
       {
         LOG (GNUNET_ERROR_TYPE_ERROR,
              "Not a SOCKS5 server\n");
@@ -234,7 +234,7 @@ SOCKS5_handshake_step (struct GNUNET_SOCKS_Handshake *ih)
       b += 2;
       break;
     case SOCKS5_step_cmd:  /* SOCKS5 server's responce to command */
-      if (b[0] != 5) 
+      if (b[0] != 5)
       {
         LOG (GNUNET_ERROR_TYPE_ERROR,
              "SOCKS5 protocol error\n");
@@ -271,11 +271,11 @@ SOCKS5_handshake_step (struct GNUNET_SOCKS_Handshake *ih)
       ih->instart = b;
       SOCKS5_handshake_done (ih);
       return;
-    case SOCKS5_step_done: 
+    case SOCKS5_step_done:
       GNUNET_assert (0);
   }
   ih->instart = b;
-  /* Do not reschedule the sender unless we're done reading. 
+  /* Do not reschedule the sender unless we're done reading.
    * I imagine this lets us avoid ever cancelling the transmit handle. */
   register_sender (ih);
 }
@@ -289,7 +289,7 @@ SOCKS5_handshake_step (struct GNUNET_SOCKS_Handshake *ih)
  * @param handler_cls closure for @a handler
  */
 void
-reciever (void *cls, 
+reciever (void *cls,
           const void *buf, size_t available,
           const struct sockaddr * addr,
           socklen_t addrlen, int errCode)
@@ -330,7 +330,7 @@ register_reciever (struct GNUNET_SOCKS_Handshake *ih, int want)
  */
 
 size_t
-transmit_ready (void *cls, 
+transmit_ready (void *cls,
                 size_t size,
                 void *buf)
 {
@@ -345,23 +345,28 @@ transmit_ready (void *cls,
    * GNUNET_CONNECTION_notify_transmit_ready() can schedule :
    *   transmit_timeout() - DNS still working
    *   connect_error() - DNS done but no socket?
-   * transmit_ready() - scheduler shutdown or timeout, or signal_transmit_error() 
+   * transmit_ready() - scheduler shutdown or timeout, or signal_transmit_error()
    * We'd need to dig into the scheduler to guess at the reason, as
    * connection.c tells us nothing itself, but mostly its timouts.
    * Initially, we'll simply ignore this and leave massive timeouts, but
    * maybe that should change for error handling pruposes.  It appears that
    * successful operations, including DNS resolution, do not use this.  */
-  if (NULL==buf)
+  if (NULL == buf)
   {
-    enum GNUNET_SCHEDULER_Reason reason = GNUNET_SCHEDULER_get_reason ();
-    if (0 != (reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    const struct GNUNET_SCHEDULER_TaskContext *tc;
+
+    tc = GNUNET_SCHEDULER_get_task_context ();
+    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
       return 0;
-    if (0 != (reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) {
-      if (0==ih->step) {
+    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) {
+      if (0==ih->step)
+      {
         LOG (GNUNET_ERROR_TYPE_WARNING,
              "Timeout contacting SOCKS server, retrying indefinitely, but probably hopeless.\n");
         register_sender (ih);
-      } else {
+      }
+      else
+      {
         LOG (GNUNET_ERROR_TYPE_ERROR,
              "Timeout during mid SOCKS handshake (step %u), probably not a SOCKS server.\n",
              ih->step);
@@ -418,7 +423,7 @@ register_sender (struct GNUNET_SOCKS_Handshake *ih)
 /**
  * Initialize a SOCKS5 handshake for authentication via username and
  * password.  Tor uses SOCKS username and password authentication to assign
- * programs unique circuits. 
+ * programs unique circuits.
  *
  * @param user username for the proxy
  * @param pass password for the proxy
@@ -435,7 +440,7 @@ GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
   unsigned char * n = b++;
   *n = 1; /* Number of authentication methods */
   /* We support no authentication even when requesting authentication,
-   * but this appears harmless, given the way that Tor uses authentication. 
+   * but this appears harmless, given the way that Tor uses authentication.
    * And some SOCKS5 servers might require this.  */
   *(b++) = SOCKS5_AUTH_NOAUTH;
   if (NULL != user) {
@@ -445,7 +450,7 @@ GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
   /* There is no apperent reason to support authentication methods beyond
    * username and password since afaik Tor does not support them. */
 
-  /* We authenticate with an empty username and password if the server demands 
+  /* We authenticate with an empty username and password if the server demands
    * them but we do not have any. */
   if (user == NULL)
     user = "";
@@ -466,7 +471,7 @@ GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
 
 
 /**
- * Initialize a SOCKS5 handshake without authentication, thereby possibly 
+ * Initialize a SOCKS5 handshake without authentication, thereby possibly
  * sharing a Tor circuit with another process.
  *
  * @return Valid SOCKS5 hanbdshake handle
@@ -480,11 +485,11 @@ GNUNET_SOCKS_init_handshake_noauth ()
 
 /**
  * Build request that the SOCKS5 proxy open a TCP/IP stream to the given host
- * and port.  
+ * and port.
  *
  * @param ih SOCKS5 handshake
- * @param hostname 
- * @param port 
+ * @param hostname
+ * @param port
  */
 void
 GNUNET_SOCKS_set_handshake_destination (struct GNUNET_SOCKS_Handshake *ih,
@@ -529,7 +534,7 @@ GNUNET_SOCKS_set_handshake_destination (struct GNUNET_SOCKS_Handshake *ih,
  * @param c open unused connection, consumed here.
  * @return Connection handle that becomes usable when the SOCKS5 handshake completes.
  */
-struct GNUNET_CONNECTION_Handle * 
+struct GNUNET_CONNECTION_Handle *
 GNUNET_SOCKS_run_handshake(struct GNUNET_SOCKS_Handshake *ih,
                             struct GNUNET_CONNECTION_Handle *c)
 {
@@ -580,7 +585,7 @@ GNUNET_SOCKS_do_connect (const char *service_name,
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "SOCKSPORT", &port0))
     port0 = 9050;
-  /* A typical Tor client should usually try port 9150 for the TBB too, but 
+  /* A typical Tor client should usually try port 9150 for the TBB too, but
    * GUNNet can probably assume a system Tor instalation. */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "SOCKSHOST", &host0))
diff --git a/src/util/speedup.c b/src/util/speedup.c
index a42ed7faf..6dce6a490 100644
--- a/src/util/speedup.c
+++ b/src/util/speedup.c
@@ -34,16 +34,17 @@ static struct GNUNET_TIME_Relative interval;
 
 static struct GNUNET_TIME_Relative delta;
 
-static struct GNUNET_SCHEDULER_Task * speedup_task;
+static struct GNUNET_SCHEDULER_Task *speedup_task;
 
 
 static void
-do_speedup (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_speedup (void *cls)
 {
   static long long current_offset;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   speedup_task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     return;
   current_offset += delta.rel_value_us;
diff --git a/src/util/test_client.c b/src/util/test_client.c
index d8bf67ac6..dab985e5f 100644
--- a/src/util/test_client.c
+++ b/src/util/test_client.c
@@ -125,7 +125,7 @@ make_msg (void *cls, size_t size, void *buf)
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_in sa;
   struct sockaddr *sap[2];
diff --git a/src/util/test_common_logging_runtime_loglevels.c b/src/util/test_common_logging_runtime_loglevels.c
index 6c33c2da1..21eb3c6c6 100644
--- a/src/util/test_common_logging_runtime_loglevels.c
+++ b/src/util/test_common_logging_runtime_loglevels.c
@@ -58,7 +58,7 @@ runone (void);
 
 
 static void
-end_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_task (void *cls)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending phase %d, ok is %d\n", phase,
               ok);
@@ -215,7 +215,7 @@ static int bytes;
 
 
 static void
-read_call (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+read_call (void *cls)
 {
   const struct GNUNET_DISK_FileHandle *stdout_read_handle = cls;
   char level[8];
@@ -425,7 +425,7 @@ runone ()
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   phase = 0;
   runone ();
diff --git a/src/util/test_connection.c b/src/util/test_connection.c
index c4987d27d..eaca75c2e 100644
--- a/src/util/test_connection.c
+++ b/src/util/test_connection.c
@@ -98,7 +98,7 @@ receive_check (void *cls, const void *buf, size_t available,
 
 
 static void
-run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+run_accept (void *cls)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test accepts connection\n");
   asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
@@ -128,7 +128,7 @@ make_hello (void *cls, size_t size, void *buf)
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   ls = open_listen_socket ();
   lsock = GNUNET_CONNECTION_create_from_existing (ls);
diff --git a/src/util/test_connection_addressing.c b/src/util/test_connection_addressing.c
index 5d2766f5f..a6345b10a 100644
--- a/src/util/test_connection_addressing.c
+++ b/src/util/test_connection_addressing.c
@@ -102,7 +102,7 @@ receive_check (void *cls, const void *buf, size_t available,
 
 
 static void
-run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+run_accept (void *cls)
 {
   void *addr;
   size_t alen;
@@ -142,7 +142,7 @@ make_hello (void *cls, size_t size, void *buf)
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_in v4;
 
diff --git a/src/util/test_connection_receive_cancel.c b/src/util/test_connection_receive_cancel.c
index 73a041bdf..9ec96d8a6 100644
--- a/src/util/test_connection_receive_cancel.c
+++ b/src/util/test_connection_receive_cancel.c
@@ -79,7 +79,7 @@ dead_receive (void *cls, const void *buf, size_t available,
 
 
 static void
-run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+run_accept_cancel (void *cls)
 {
   asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
   GNUNET_assert (asock != NULL);
@@ -92,7 +92,7 @@ run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-receive_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+receive_cancel_task (void *cls)
 {
   int *ok = cls;
 
@@ -105,7 +105,7 @@ receive_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_receive_cancel (void *cls)
 {
   ls = open_listen_socket ();
   lsock = GNUNET_CONNECTION_create_from_existing (ls);
diff --git a/src/util/test_connection_timeout.c b/src/util/test_connection_timeout.c
index 5a649f5b0..e78cec669 100644
--- a/src/util/test_connection_timeout.c
+++ b/src/util/test_connection_timeout.c
@@ -93,7 +93,7 @@ send_kilo (void *cls, size_t size, void *buf)
 
 
 static void
-task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_timeout (void *cls)
 {
 
   ls = open_listen_socket ();
diff --git a/src/util/test_connection_timeout_no_connect.c b/src/util/test_connection_timeout_no_connect.c
index 1e3230d2f..ebcd4b71e 100644
--- a/src/util/test_connection_timeout_no_connect.c
+++ b/src/util/test_connection_timeout_no_connect.c
@@ -44,7 +44,7 @@ handle_timeout (void *cls, size_t size, void *buf)
 
 
 static void
-task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_timeout (void *cls)
 {
   csock = GNUNET_CONNECTION_create_from_connect (cfg, "localhost", PORT);
   GNUNET_assert (csock != NULL);
diff --git a/src/util/test_connection_transmit_cancel.c b/src/util/test_connection_transmit_cancel.c
index 8d016068c..9ef0720ed 100644
--- a/src/util/test_connection_transmit_cancel.c
+++ b/src/util/test_connection_transmit_cancel.c
@@ -38,7 +38,7 @@ not_run (void *cls, size_t size, void *buf)
 
 
 static void
-task_transmit_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task_transmit_cancel (void *cls)
 {
   int *ok = cls;
   struct GNUNET_CONNECTION_TransmitHandle *th;
diff --git a/src/util/test_crypto_hash.c b/src/util/test_crypto_hash.c
index fa0013264..731205841 100644
--- a/src/util/test_crypto_hash.c
+++ b/src/util/test_crypto_hash.c
@@ -114,7 +114,7 @@ finished_task (void *cls, const struct GNUNET_HashCode * res)
 
 
 static void
-file_hasher (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+file_hasher (void *cls)
 {
   GNUNET_assert (NULL !=
                  GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
diff --git a/src/util/test_disk.c b/src/util/test_disk.c
index 560b6710e..86b96e16c 100644
--- a/src/util/test_disk.c
+++ b/src/util/test_disk.c
@@ -141,12 +141,13 @@ iter_callback (void *cls, struct GNUNET_DISK_DirectoryIterator *di,
 }
 
 static void
-iter_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+iter_task (void *cls)
 {
   GNUNET_DISK_directory_iterator_start (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                         "test", &iter_callback, cls);
 }
 
+
 static int
 testDirIter ()
 {
diff --git a/src/util/test_mq_client.c b/src/util/test_mq_client.c
index 0d2f3befe..f894c3912 100644
--- a/src/util/test_mq_client.c
+++ b/src/util/test_mq_client.c
@@ -62,7 +62,7 @@ recv_cb (void *cls, struct GNUNET_SERVER_Client *argclient,
 
 
 static void
-clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+clean_up (void *cls)
 {
   GNUNET_SERVER_destroy (server);
   server = NULL;
@@ -134,7 +134,7 @@ test_mq (struct GNUNET_CLIENT_Connection *client)
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_in sa;
   struct sockaddr *sap[2];
@@ -181,4 +181,3 @@ main (int argc, char *argv[])
   GNUNET_assert (GNUNET_YES == notify);
   return ok;
 }
-
diff --git a/src/util/test_os_start_process.c b/src/util/test_os_start_process.c
index 3823beb3d..c617917cc 100644
--- a/src/util/test_os_start_process.c
+++ b/src/util/test_os_start_process.c
@@ -58,7 +58,7 @@ struct read_context
 struct read_context rc;
 
 static void
-end_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_task (void *cls)
 {
   if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
   {
@@ -73,7 +73,7 @@ end_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-read_call (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+read_call (void *cls)
 {
   int bytes;
 
@@ -110,7 +110,7 @@ read_call (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-run_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+run_task (void *cls)
 {
   char *fn;
   const struct GNUNET_DISK_FileHandle *stdout_read_handle;
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c
index 01d93febd..a246d75c5 100644
--- a/src/util/test_scheduler.c
+++ b/src/util/test_scheduler.c
@@ -31,7 +31,7 @@ static const struct GNUNET_DISK_FileHandle *fds[2];
 
 
 static void
-task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task2 (void *cls)
 {
   int *ok = cls;
 
@@ -44,7 +44,7 @@ task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-task3 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task3 (void *cls)
 {
   int *ok = cls;
 
@@ -54,11 +54,13 @@ task3 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-taskWrt (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+taskWrt (void *cls)
 {
   static char c;
   int *ok = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
+  tc = GNUNET_SCHEDULER_get_task_context ();
   GNUNET_assert (6 == *ok);
   GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->write_ready, fds[1]));
   (*ok) = 7;
@@ -67,14 +69,14 @@ taskWrt (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-taskNeverRun (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+taskNeverRun (void *cls)
 {
   GNUNET_assert (0);
 }
 
 
 static void
-taskLast (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+taskLast (void *cls)
 {
   int *ok = cls;
 
@@ -85,11 +87,13 @@ taskLast (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-taskRd (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+taskRd (void *cls)
 {
   static char c;
   int *ok = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
+  tc = GNUNET_SCHEDULER_get_task_context ();
   GNUNET_assert (7 == *ok);
   GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, fds[0]));
   GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1));
@@ -101,7 +105,7 @@ taskRd (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-task4 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task4 (void *cls)
 {
   int *ok = cls;
 
@@ -119,7 +123,7 @@ task4 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-task1 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task1 (void *cls)
 {
   int *ok = cls;
 
@@ -148,7 +152,7 @@ check ()
 
 
 static void
-taskShutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+taskShutdown (void *cls)
 {
   int *ok = cls;
 
@@ -176,7 +180,7 @@ checkShutdown ()
 
 #ifndef MINGW
 static void
-taskSig (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+taskSig (void *cls)
 {
   int *ok = cls;
 
@@ -204,7 +208,7 @@ checkSignal ()
 
 
 static void
-taskCancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+taskCancel (void *cls)
 {
   int *ok = cls;
 
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c
index c3821a173..c55f28e9b 100644
--- a/src/util/test_scheduler_delay.c
+++ b/src/util/test_scheduler_delay.c
@@ -41,11 +41,9 @@ static unsigned long long cumDelta;
  * Signature of the main function of a task.
  *
  * @param cls closure
- * @param tc context
  */
 static void
-test_task (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+test_task (void *cls)
 {
   struct GNUNET_TIME_Absolute now;
 
diff --git a/src/util/test_server.c b/src/util/test_server.c
index fdf298128..189c13e18 100644
--- a/src/util/test_server.c
+++ b/src/util/test_server.c
@@ -74,11 +74,9 @@ static int ok;
  * Final task invoked to clean up.
  *
  * @param cls NULL
- * @param tc scheduler context
  */
 static void
-finish_up (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+finish_up (void *cls)
 {
   GNUNET_assert (7 == ok);
   ok = 0;
@@ -262,11 +260,9 @@ static struct GNUNET_SERVER_MessageHandler handlers[] = {
  * server.
  *
  * @param cls NULL
- * @param tc scheduler context
  */
 static void
-task (void *cls,
-      const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_in sa;
   struct sockaddr *sap[2];
diff --git a/src/util/test_server_disconnect.c b/src/util/test_server_disconnect.c
index 4a6970fc3..21abf92bb 100644
--- a/src/util/test_server_disconnect.c
+++ b/src/util/test_server_disconnect.c
@@ -41,7 +41,7 @@ static int ok;
 
 
 static void
-finish_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+finish_up (void *cls)
 {
   GNUNET_assert (ok == 5);
   ok = 0;
@@ -52,9 +52,10 @@ finish_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-notify_disconnect (void *cls, struct GNUNET_SERVER_Client *clientarg)
+notify_disconnect (void *cls,
+                   struct GNUNET_SERVER_Client *clientarg)
 {
-  if (clientarg == NULL)
+  if (NULL == clientarg)
     return;
   GNUNET_assert (ok == 4);
   ok = 5;
@@ -63,7 +64,7 @@ notify_disconnect (void *cls, struct GNUNET_SERVER_Client *clientarg)
 
 
 static void
-server_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+server_disconnect (void *cls)
 {
   struct GNUNET_SERVER_Client *argclient = cls;
 
@@ -110,7 +111,7 @@ transmit_initial_message (void *cls, size_t size, void *buf)
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_in sa;
   struct sockaddr *sap[2];
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c
index 07bc88783..8a8f65474 100644
--- a/src/util/test_server_with_client.c
+++ b/src/util/test_server_with_client.c
@@ -40,7 +40,7 @@ static struct GNUNET_CONFIGURATION_Handle *cfg;
 static int ok;
 
 static void
-send_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+send_done (void *cls)
 {
   struct GNUNET_SERVER_Client *argclient = cls;
 
@@ -94,7 +94,7 @@ recv_cb (void *cls, struct GNUNET_SERVER_Client *argclient,
 
 
 static void
-clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+clean_up (void *cls)
 {
   GNUNET_SERVER_destroy (server);
   server = NULL;
@@ -146,7 +146,7 @@ static struct GNUNET_SERVER_MessageHandler handlers[] = {
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_in sa;
   struct sockaddr *sap[2];
diff --git a/src/util/test_server_with_client_unix.c b/src/util/test_server_with_client_unix.c
index 1d6f5dbed..ec84b08f8 100644
--- a/src/util/test_server_with_client_unix.c
+++ b/src/util/test_server_with_client_unix.c
@@ -39,7 +39,7 @@ static int ok;
 
 
 static void
-send_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+send_done (void *cls)
 {
   struct GNUNET_SERVER_Client *argclient = cls;
 
@@ -74,7 +74,7 @@ recv_cb (void *cls, struct GNUNET_SERVER_Client *argclient,
 
 
 static void
-clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+clean_up (void *cls)
 {
   GNUNET_SERVER_destroy (server);
   server = NULL;
@@ -126,7 +126,7 @@ static struct GNUNET_SERVER_MessageHandler handlers[] = {
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_un un;
   const char *unixpath = "/tmp/testsock";
diff --git a/src/util/test_service.c b/src/util/test_service.c
index 88f99f95a..efc765438 100644
--- a/src/util/test_service.c
+++ b/src/util/test_service.c
@@ -41,7 +41,7 @@ static struct GNUNET_CLIENT_Connection *client;
 
 
 static void
-do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls)
 {
   if (NULL != client)
   {
diff --git a/src/util/test_socks.c b/src/util/test_socks.c
index bb7d0031a..7f1140720 100644
--- a/src/util/test_socks.c
+++ b/src/util/test_socks.c
@@ -126,7 +126,7 @@ make_msg (void *cls, size_t size, void *buf)
 
 
 static void
-task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+task (void *cls)
 {
   struct sockaddr_in sa;
   struct sockaddr *sap[2];
diff --git a/src/util/test_speedup.c b/src/util/test_speedup.c
index 3c4a9bfdc..5d46e3127 100644
--- a/src/util/test_speedup.c
+++ b/src/util/test_speedup.c
@@ -47,7 +47,7 @@ static unsigned int cycles;
  * @param tc scheduler context, unused
  */
 static void
-run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+run (void *cls)
 {
   cycles++;
   fprintf (stderr, "..%u", cycles);