44 files changed, 152 insertions, 237 deletions

diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index f85b8e739..2db475528 100644
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -108,11 +108,9 @@ stop_job (struct GNUNET_FS_QueueEntry *qe)
  * and stopping others.
  *
  * @param cls the `struct GNUNET_FS_Handle *`
- * @param tc scheduler context
  */
 static void
-process_job_queue (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+process_job_queue (void *cls)
 {
   struct GNUNET_FS_Handle *h = cls;
   struct GNUNET_FS_QueueEntry *qe;
diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index e9f9ab2cb..0e1476f5c 100644
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -757,11 +757,9 @@ GNUNET_FS_search_probe_progress_ (void *cls,
  * Main function that performs the upload.
  *
  * @param cls `struct GNUNET_FS_PublishContext` identifies the upload
- * @param tc task context
  */
 void
-GNUNET_FS_publish_main_ (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc);
+GNUNET_FS_publish_main_ (void *cls);
 
 
 /**
@@ -828,11 +826,9 @@ GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  * request for the file.
  *
  * @param cls the 'struct GNUNET_FS_DownloadContext'
- * @param tc scheduler context
  */
 void
-GNUNET_FS_download_start_task_ (void *cls,
-                                const struct GNUNET_SCHEDULER_TaskContext *tc);
+GNUNET_FS_download_start_task_ (void *cls);
 
 
 
diff --git a/src/fs/fs_dirmetascan.c b/src/fs/fs_dirmetascan.c
index 72098957d..2f79c7c05 100644
--- a/src/fs/fs_dirmetascan.c
+++ b/src/fs/fs_dirmetascan.c
@@ -222,11 +222,9 @@ expand_tree (struct GNUNET_FS_ShareTreeItem *parent,
  * Task run last to shut everything down.
  *
  * @param cls the 'struct GNUNET_FS_DirScanner'
- * @param tc unused
  */
 static void
-finish_scan (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+finish_scan (void *cls)
 {
   struct GNUNET_FS_DirScanner *ds = cls;
 
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index f43524553..e8b632a3f 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -1372,10 +1372,9 @@ transmit_download_request (void *cls, size_t size, void *buf)
  * Reconnect to the FS service and transmit our queries NOW.
  *
  * @param cls our download context
- * @param tc unused
  */
 static void
-do_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_reconnect (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_CLIENT_Connection *client;
@@ -1625,10 +1624,9 @@ create_download_request (struct DownloadRequest *parent,
  * the current IBlock from the existing file.
  *
  * @param cls the 'struct ReconstructContext'
- * @param tc scheduler context
  */
 static void
-reconstruct_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconstruct_cont (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
 
@@ -1655,10 +1653,9 @@ reconstruct_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Task requesting the next block from the tree encoder.
  *
  * @param cls the 'struct GNUJNET_FS_DownloadContext' we're processing
- * @param tc task context
  */
 static void
-get_next_block (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+get_next_block (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
 
@@ -1855,11 +1852,9 @@ fh_reader (void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
  * request for the file.
  *
  * @param cls the 'struct GNUNET_FS_DownloadContext'
- * @param tc scheduler context
  */
 void
-GNUNET_FS_download_start_task_ (void *cls,
-                                const struct GNUNET_SCHEDULER_TaskContext *tc)
+GNUNET_FS_download_start_task_ (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 1e8e82c71..80843006e 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -413,11 +413,9 @@ block_reader (void *cls,
  * the final result.
  *
  * @param cls our publishing context
- * @param tc scheduler's task context (not used)
  */
 static void
-encode_cont (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+encode_cont (void *cls)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -960,11 +958,9 @@ create_loc_uri (struct GNUNET_FS_PublishContext *pc)
  * Main function that performs the upload.
  *
  * @param cls `struct GNUNET_FS_PublishContext *` identifies the upload
- * @param tc task context
  */
 void
-GNUNET_FS_publish_main_ (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+GNUNET_FS_publish_main_ (void *cls)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
diff --git a/src/fs/fs_publish_ksk.c b/src/fs/fs_publish_ksk.c
index b3e9de728..a7ad3e91f 100644
--- a/src/fs/fs_publish_ksk.c
+++ b/src/fs/fs_publish_ksk.c
@@ -110,11 +110,9 @@ struct GNUNET_FS_PublishKskContext
  * of the keywords).
  *
  * @param cls closure of type `struct PublishKskContext *`
- * @param tc unused
  */
 static void
-publish_ksk_cont (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc);
+publish_ksk_cont (void *cls);
 
 
 /**
@@ -148,11 +146,9 @@ kb_put_cont (void *cls,
  * publishing operation (iterating over all of the keywords).
  *
  * @param cls closure of type `struct GNUNET_FS_PublishKskContext *`
- * @param tc unused
  */
 static void
-publish_ksk_cont (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+publish_ksk_cont (void *cls)
 {
   struct GNUNET_FS_PublishKskContext *pkc = cls;
   const char *keyword;
diff --git a/src/fs/fs_publish_ublock.c b/src/fs/fs_publish_ublock.c
index 7cdad396b..9ea7bf41b 100644
--- a/src/fs/fs_publish_ublock.c
+++ b/src/fs/fs_publish_ublock.c
@@ -147,11 +147,9 @@ ublock_put_cont (void *cls,
  * Run the continuation.
  *
  * @param cls the `struct GNUNET_FS_PublishUblockContext *`
- * @param tc scheduler context
  */
 static void
-run_cont (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc)
+run_cont (void *cls)
 {
   struct GNUNET_FS_PublishUblockContext *uc = cls;
 
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index 626d23a72..eaabac746 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -215,11 +215,9 @@ signal_probe_result (struct GNUNET_FS_SearchResult *sr)
  * Handle the case where we have failed to receive a response for our probe.
  *
  * @param cls our `struct GNUNET_FS_SearchResult *`
- * @param tc scheduler context
  */
 static void
-probe_failure_handler (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+probe_failure_handler (void *cls)
 {
   struct GNUNET_FS_SearchResult *sr = cls;
 
@@ -241,11 +239,9 @@ probe_failure_handler (void *cls,
  * Handle the case where we have gotten a response for our probe.
  *
  * @param cls our `struct GNUNET_FS_SearchResult *`
- * @param tc scheduler context
  */
 static void
-probe_success_handler (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+probe_success_handler (void *cls)
 {
   struct GNUNET_FS_SearchResult *sr = cls;
 
@@ -364,11 +360,9 @@ GNUNET_FS_search_probe_progress_ (void *cls,
  * Task run periodically to remind clients that a probe is active.
  *
  * @param cls the `struct GNUNET_FS_SearchResult` that we are probing for
- * @param tc scheduler context
  */
 static void
-probe_ping_task_cb (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+probe_ping_task_cb (void *cls)
 {
   struct GNUNET_FS_Handle *h = cls;
   struct GNUNET_FS_SearchResult *sr;
@@ -1245,10 +1239,9 @@ schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
  * our queries NOW.
  *
  * @param cls our search context
- * @param tc unused
  */
 static void
-do_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_reconnect (void *cls)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_CLIENT_Connection *client;
@@ -1637,7 +1630,7 @@ GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
 
   GNUNET_assert (NULL == sc->client);
   GNUNET_assert (NULL == sc->task);
-  do_reconnect (sc, NULL);
+  do_reconnect (sc);
   GNUNET_FS_search_sync_ (sc);
   pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED;
   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
diff --git a/src/fs/fs_test_lib.c b/src/fs/fs_test_lib.c
index 6bd156e8b..d03888021 100644
--- a/src/fs/fs_test_lib.c
+++ b/src/fs/fs_test_lib.c
@@ -183,8 +183,7 @@ struct TestDownloadOperation
  * @param tc scheduler context (unused)
  */
 static void
-report_uri (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+report_uri (void *cls)
 {
   struct TestPublishOperation *po = cls;
 
@@ -208,10 +207,9 @@ report_uri (void *cls,
  * Task scheduled to run when publish operation times out.
  *
  * @param cls the publish operation context
- * @param tc scheduler context (unused)
  */
 static void
-publish_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+publish_timeout (void *cls)
 {
   struct TestPublishOperation *po = cls;
 
@@ -480,10 +478,9 @@ GNUNET_FS_TEST_publish (struct GNUNET_TESTBED_Peer *peer,
  * Task scheduled to run when download operation times out.
  *
  * @param cls the download operation context
- * @param tc scheduler context (unused)
  */
 static void
-download_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+download_timeout (void *cls)
 {
   struct TestDownloadOperation *dop = cls;
 
@@ -504,11 +501,9 @@ download_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Task scheduled to report on the completion of our download operation.
  *
  * @param cls the download operation context
- * @param tc scheduler context (unused)
  */
 static void
-report_success (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+report_success (void *cls)
 {
   struct TestDownloadOperation *dop = cls;
 
diff --git a/src/fs/fs_tree.c b/src/fs/fs_tree.c
index 57c4c567f..b3c632203 100644
--- a/src/fs/fs_tree.c
+++ b/src/fs/fs_tree.c
@@ -352,7 +352,7 @@ GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te)
     te->uri->data.chk.chk = te->chk_tree[off];
     te->uri->data.chk.file_length = GNUNET_htonll (te->size);
     te->in_next = GNUNET_NO;
-    te->cont (te->cls, NULL);
+    te->cont (te->cls);
     return;
   }
   if (0 == te->current_depth)
@@ -363,7 +363,7 @@ GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te)
         te->reader (te->cls, te->publish_offset, pt_size, iob, &te->emsg))
     {
       te->in_next = GNUNET_NO;
-      te->cont (te->cls, NULL);
+      te->cont (te->cls);
       return;
     }
     pt_block = iob;
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index 88d3dd0ea..2e9c17217 100644
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -626,11 +626,9 @@ GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
  * processed all blocks.  Clean up.
  *
  * @param cls our unindexing context
- * @param tc not used
  */
 static void
-unindex_extract_keywords (void *cls,
-                          const struct GNUNET_SCHEDULER_TaskContext *tc)
+unindex_extract_keywords (void *cls)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
 
diff --git a/src/fs/gnunet-auto-share.c b/src/fs/gnunet-auto-share.c
index 3e5c8777c..aef66614c 100644
--- a/src/fs/gnunet-auto-share.c
+++ b/src/fs/gnunet-auto-share.c
@@ -317,17 +317,15 @@ save_state ()
  * Task run on shutdown.  Serializes our current state to disk.
  *
  * @param cls closure, unused
- * @param tc scheduler context, unused
  */
 static void
-do_stop_task (void *cls, 
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop_task (void *cls)
 {
   kill_task = NULL;
   do_shutdown = GNUNET_YES;
   if (NULL != publish_proc)
   {
-    GNUNET_OS_process_kill (publish_proc, 
+    GNUNET_OS_process_kill (publish_proc,
                             SIGKILL);
     return;
   }
@@ -351,11 +349,9 @@ schedule_next_task (void);
  * process died).
  *
  * @param cls the `struct WorkItem` we were working on
- * @param tc context
  */
 static void
-maint_child_death (void *cls, 
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+maint_child_death (void *cls)
 {
   struct WorkItem *wi = cls;
   struct GNUNET_HashCode key;
@@ -364,10 +360,12 @@ maint_child_death (void *cls,
   int ret;
   char c;
   const struct GNUNET_DISK_FileHandle *pr;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   run_task = NULL;
   pr = GNUNET_DISK_pipe_handle (sigpipe,
                                 GNUNET_DISK_PIPE_END_READ);
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
   {
     /* shutdown scheduled us, someone else will kill child,
@@ -389,7 +387,7 @@ maint_child_death (void *cls,
   {
     /* process still running? Then where did the SIGCHLD come from?
        Well, let's declare it spurious (kernel bug?) and keep rolling.
-    */  
+    */
     GNUNET_break (0);
     run_task =
       GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
@@ -398,7 +396,7 @@ maint_child_death (void *cls,
     return;
   }
   GNUNET_assert (GNUNET_OK == ret);
-  
+
   GNUNET_OS_process_destroy (publish_proc);
   publish_proc = NULL;
 
@@ -457,11 +455,9 @@ sighandler_child_death ()
  * Function called to process work items.
  *
  * @param cls closure, NULL
- * @param tc scheduler context (unused)
  */
 static void
-work (void *cls,
-      const struct GNUNET_SCHEDULER_TaskContext *tc)
+work (void *cls)
 {
   static char *argv[14];
   static char anon_level[20];
@@ -521,7 +517,7 @@ work (void *cls,
                                              NULL);
     return;
   }
-  pr = GNUNET_DISK_pipe_handle (sigpipe, 
+  pr = GNUNET_DISK_pipe_handle (sigpipe,
                                 GNUNET_DISK_PIPE_END_READ);
   run_task =
     GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
@@ -549,13 +545,13 @@ determine_id (void *cls,
 
   if (0 != STAT (filename, &sbuf))
   {
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, 
-                              "stat", 
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                              "stat",
                               filename);
     return GNUNET_OK;
   }
-  GNUNET_CRYPTO_hash (filename, 
-                      strlen (filename), 
+  GNUNET_CRYPTO_hash (filename,
+                      strlen (filename),
                       &fx[0]);
   if (!S_ISDIR (sbuf.st_mode))
   {
@@ -564,8 +560,8 @@ determine_id (void *cls,
     fattr[0] = GNUNET_htonll (sbuf.st_size);
     fattr[0] = GNUNET_htonll (sbuf.st_mtime);
 
-    GNUNET_CRYPTO_hash (fattr, 
-                        sizeof (fattr), 
+    GNUNET_CRYPTO_hash (fattr,
+                        sizeof (fattr),
                         &fx[1]);
   }
   else
@@ -579,7 +575,7 @@ determine_id (void *cls,
   }
   /* use hash here to make hierarchical structure distinct from
      all files on the same level */
-  GNUNET_CRYPTO_hash (fx, 
+  GNUNET_CRYPTO_hash (fx,
                       sizeof (fx),
                       &ft);
   /* use XOR here so that order of the files in the directory
@@ -653,11 +649,9 @@ add_file (void *cls,
  * Periodically run task to update our view of the directory to share.
  *
  * @param cls NULL
- * @param tc scheduler context, unused
  */
 static void
-scan (void *cls, 
-      const struct GNUNET_SCHEDULER_TaskContext *tc)
+scan (void *cls)
 {
   run_task = NULL;
   start_time = GNUNET_TIME_absolute_get ();
@@ -695,7 +689,7 @@ schedule_next_task ()
   }
   else
   {
-    run_task = GNUNET_SCHEDULER_add_now (&work, 
+    run_task = GNUNET_SCHEDULER_add_now (&work,
                                          NULL);
   }
 }
@@ -710,15 +704,15 @@ schedule_next_task ()
  * @param c configuration
  */
 static void
-run (void *cls, 
-     char *const *args, 
+run (void *cls,
+     char *const *args,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *c)
 {
   /* check arguments */
-  if ( (NULL == args[0]) || 
+  if ( (NULL == args[0]) ||
        (NULL != args[1]) ||
-       (GNUNET_YES != 
+       (GNUNET_YES !=
         GNUNET_DISK_directory_test (args[0],
                                     GNUNET_YES)) )
   {
@@ -729,14 +723,14 @@ run (void *cls,
   cfg_filename = GNUNET_strdup (cfgfile);
   cfg = c;
   dir_name = args[0];
-  work_finished = GNUNET_CONTAINER_multihashmap_create (1024, 
+  work_finished = GNUNET_CONTAINER_multihashmap_create (1024,
                                                         GNUNET_NO);
   load_state ();
   run_task = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                                 &scan, 
+                                                 &scan,
                                                  NULL);
   kill_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, 
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                     &do_stop_task,
                                     NULL);
 }
@@ -799,17 +793,17 @@ main (int argc, char *const *argv)
   int ok;
   struct GNUNET_SIGNAL_Context *shc_chld;
 
-  if (GNUNET_OK != 
+  if (GNUNET_OK !=
       GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
-  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, 
+  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO,
                               GNUNET_NO, GNUNET_NO);
   GNUNET_assert (NULL != sigpipe);
   shc_chld =
     GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD,
                                    &sighandler_child_death);
   ok = (GNUNET_OK ==
-        GNUNET_PROGRAM_run (argc, argv, 
+        GNUNET_PROGRAM_run (argc, argv,
                             "gnunet-auto-share [OPTIONS] FILENAME",
                             gettext_noop
                             ("Automatically publish files from a directory on GNUnet"),
@@ -823,7 +817,7 @@ main (int argc, char *const *argv)
   }
   while (NULL != (wi = work_head))
   {
-    GNUNET_CONTAINER_DLL_remove (work_head, 
+    GNUNET_CONTAINER_DLL_remove (work_head,
                                  work_tail,
                                  wi);
     GNUNET_free (wi->filename);
diff --git a/src/fs/gnunet-daemon-fsprofiler.c b/src/fs/gnunet-daemon-fsprofiler.c
index 77a293a23..326178df9 100644
--- a/src/fs/gnunet-daemon-fsprofiler.c
+++ b/src/fs/gnunet-daemon-fsprofiler.c
@@ -267,10 +267,9 @@ make_file (uint64_t length,
  * Task run during shutdown.
  *
  * @param cls unused
- * @param tc unused
  */
 static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   struct Pattern *p;
 
@@ -313,10 +312,9 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Task run when a publish operation should be stopped.
  *
  * @param cls the 'struct Pattern' of the publish operation to stop
- * @param tc unused
  */
 static void
-publish_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+publish_stop_task (void *cls)
 {
   struct Pattern *p = cls;
 
@@ -329,10 +327,9 @@ publish_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Task run when a download operation should be stopped.
  *
  * @param cls the 'struct Pattern' of the download operation to stop
- * @param tc unused
  */
 static void
-download_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+download_stop_task (void *cls)
 {
   struct Pattern *p = cls;
 
@@ -345,10 +342,9 @@ download_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Task run when a download operation should be stopped.
  *
  * @param cls the 'struct Pattern' of the download operation to stop
- * @param tc unused
  */
 static void
-search_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+search_stop_task (void *cls)
 {
   struct Pattern *p = cls;
 
@@ -498,16 +494,16 @@ progress_cb (void *cls,
  * Start publish operation.
  *
  * @param cls the 'struct Pattern' specifying the operation to perform
- * @param tc scheduler context
  */
 static void
-start_publish (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+start_publish (void *cls)
 {
   struct Pattern *p = cls;
   struct GNUNET_FS_FileInformation *fi;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   p->task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   fi = make_file (p->x, p->y, p);
@@ -523,16 +519,16 @@ start_publish (void *cls,
  * Start download operation.
  *
  * @param cls the 'struct Pattern' specifying the operation to perform
- * @param tc scheduler context
  */
 static void
-start_download (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+start_download (void *cls)
 {
   struct Pattern *p = cls;
   struct GNUNET_FS_Uri *keywords;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   p->task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   keywords = make_keywords (p->x);
diff --git a/src/fs/gnunet-download.c b/src/fs/gnunet-download.c
index 85afbe606..a2b0aa5fc 100644
--- a/src/fs/gnunet-download.c
+++ b/src/fs/gnunet-download.c
@@ -54,7 +54,7 @@ static int local_only;
 
 
 static void
-cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup_task (void *cls)
 {
   GNUNET_FS_stop (ctx);
   ctx = NULL;
@@ -62,7 +62,7 @@ cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   if (NULL != dc)
   {
diff --git a/src/fs/gnunet-fs-profiler.c b/src/fs/gnunet-fs-profiler.c
index cd4f9d851..69433346f 100644
--- a/src/fs/gnunet-fs-profiler.c
+++ b/src/fs/gnunet-fs-profiler.c
@@ -109,11 +109,9 @@ process_stats (void *cls,
  * all statistics.
  *
  * @param cls NULL
- * @param tc unused
  */
 static void
-terminate_task (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+terminate_task (void *cls)
 {
   terminate_taskid = NULL;
   GNUNET_TESTBED_get_statistics (0, NULL,
diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index b5c8acc4c..f058c10b2 100644
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -146,11 +146,9 @@ static struct GNUNET_IDENTITY_Handle *identity;
  * FS state.
  *
  * @param cls NULL
- * @param tc scheduler context
  */
 static void
-do_stop_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop_task (void *cls)
 {
   struct GNUNET_FS_PublishContext *p;
 
diff --git a/src/fs/gnunet-search.c b/src/fs/gnunet-search.c
index d9ce456a6..a15d0d883 100644
--- a/src/fs/gnunet-search.c
+++ b/src/fs/gnunet-search.c
@@ -96,7 +96,7 @@ item_printer (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type,
 
 
 static void
-clean_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+clean_task (void *cls)
 {
   size_t dsize;
   void *ddata;
@@ -210,7 +210,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 
 
 static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   if (sc != NULL)
   {
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index aebbe5854..2ba96334c 100644
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -184,11 +184,9 @@ static struct GNUNET_PeerIdentity my_id;
  * Task that periodically ages our cover traffic statistics.
  *
  * @param cls unused closure
- * @param tc task context
  */
 static void
-age_cover_counters (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+age_cover_counters (void *cls)
 {
   GSF_cover_content_count = (GSF_cover_content_count * 15) / 16;
   GSF_cover_query_count = (GSF_cover_query_count * 15) / 16;
@@ -531,11 +529,9 @@ handle_loc_sign (void *cls,
  * Task run during shutdown.
  *
  * @param cls unused
- * @param tc unused
  */
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   GSF_cadet_stop_client ();
   GSF_cadet_stop_server ();
@@ -821,7 +817,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
       (GNUNET_OK != main_init (server, cfg)))
   {
     GNUNET_SCHEDULER_shutdown ();
-    shutdown_task (NULL, NULL);
+    shutdown_task (NULL);
     return;
   }
 }
diff --git a/src/fs/gnunet-service-fs_cadet_client.c b/src/fs/gnunet-service-fs_cadet_client.c
index 417468970..3ea2efa67 100644
--- a/src/fs/gnunet-service-fs_cadet_client.c
+++ b/src/fs/gnunet-service-fs_cadet_client.c
@@ -246,11 +246,9 @@ reset_cadet (struct CadetHandle *mh)
  * Task called when it is time to destroy an inactive cadet channel.
  *
  * @param cls the `struct CadetHandle` to tear down
- * @param tc scheduler context, unused
  */
 static void
-cadet_timeout (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+cadet_timeout (void *cls)
 {
   struct CadetHandle *mh = cls;
   struct GNUNET_CADET_Channel *tun;
@@ -270,11 +268,9 @@ cadet_timeout (void *cls,
  * Task called when it is time to reset an cadet.
  *
  * @param cls the `struct CadetHandle` to tear down
- * @param tc scheduler context, unused
  */
 static void
-reset_cadet_task (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+reset_cadet_task (void *cls)
 {
   struct CadetHandle *mh = cls;
 
diff --git a/src/fs/gnunet-service-fs_cadet_server.c b/src/fs/gnunet-service-fs_cadet_server.c
index 46086eec8..ccf6b3c5c 100644
--- a/src/fs/gnunet-service-fs_cadet_server.c
+++ b/src/fs/gnunet-service-fs_cadet_server.c
@@ -154,11 +154,9 @@ static unsigned long long sc_count_max;
  * Task run to asynchronously terminate the cadet due to timeout.
  *
  * @param cls the 'struct CadetClient'
- * @param tc scheduler context
  */
 static void
-timeout_cadet_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_cadet_task (void *cls)
 {
   struct CadetClient *sc = cls;
   struct GNUNET_CADET_Channel *tun;
@@ -324,7 +322,7 @@ continue_writing (struct CadetClient *sc)
 static void
 handle_datastore_reply (void *cls,
                         const struct GNUNET_HashCode *key,
-                        size_t size, 
+                        size_t size,
                         const void *data,
                         enum GNUNET_BLOCK_Type type,
                         uint32_t priority,
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index 3cabfeaaf..e916a73a8 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -522,11 +522,9 @@ peer_transmit_ready_cb (void *cls,
  * (re)try to reserve bandwidth from the given peer.
  *
  * @param cls the `struct GSF_ConnectedPeer` to reserve from
- * @param tc scheduler context
  */
 static void
-retry_reservation (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+retry_reservation (void *cls)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GNUNET_PeerIdentity target;
@@ -675,11 +673,9 @@ GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
  * peer.  Check, and if so, restart migration.
  *
  * @param cls the `struct GSF_ConnectedPeer`
- * @param tc scheduler context
  */
 static void
-revive_migration (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+revive_migration (void *cls)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GNUNET_TIME_Relative bt;
@@ -854,11 +850,9 @@ cancel_pending_request (void *cls,
  * Free the given request.
  *
  * @param cls the request to free
- * @param tc task context
  */
 static void
-peer_request_destroy (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+peer_request_destroy (void *cls)
 {
   struct PeerRequest *peerreq = cls;
   struct GSF_PendingRequest *pr = peerreq->pr;
@@ -876,19 +870,19 @@ peer_request_destroy (void *cls,
  * The artificial delay is over, transmit the message now.
  *
  * @param cls the `struct GSF_DelayedHandle` with the message
- * @param tc scheduler context
  */
 static void
-transmit_delayed_now (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmit_delayed_now (void *cls)
 {
   struct GSF_DelayedHandle *dh = cls;
   struct GSF_ConnectedPeer *cp = dh->cp;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   GNUNET_CONTAINER_DLL_remove (cp->delayed_head,
                                cp->delayed_tail,
                                dh);
   cp->delay_queue_size--;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
   {
     GNUNET_free (dh->pm);
@@ -1490,11 +1484,9 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
  * a transmission request.
  *
  * @param cls the `struct GSF_PeerTransmitHandle` of the request
- * @param tc scheduler context
  */
 static void
-peer_transmit_timeout (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+peer_transmit_timeout (void *cls)
 {
   struct GSF_PeerTransmitHandle *pth = cls;
   struct GSF_ConnectedPeer *cp;
@@ -1981,18 +1973,17 @@ GSF_connected_peer_change_preference_ (struct GSF_ConnectedPeer *cp,
  * Call this method periodically to flush respect information to disk.
  *
  * @param cls closure, not used
- * @param tc task context, not used
  */
 static void
-cron_flush_respect (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+cron_flush_respect (void *cls)
 {
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
+
   if (NULL == cp_map)
     return;
   GNUNET_CONTAINER_multipeermap_iterate (cp_map,
                                          &flush_respect, NULL);
-  if (NULL == tc)
-    return;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   GNUNET_SCHEDULER_add_delayed_with_priority (RESPECT_FLUSH_FREQ,
@@ -2038,7 +2029,9 @@ clean_peer (void *cls,
 void
 GSF_connected_peer_done_ ()
 {
-  cron_flush_respect (NULL, NULL);
+  GNUNET_CONTAINER_multipeermap_iterate (cp_map,
+                                         &flush_respect,
+                                         NULL);
   GNUNET_CONTAINER_multipeermap_iterate (cp_map,
                                          &clean_peer, NULL);
   GNUNET_CONTAINER_multipeermap_destroy (cp_map);
diff --git a/src/fs/gnunet-service-fs_lc.c b/src/fs/gnunet-service-fs_lc.c
index f837ad320..2706aea30 100644
--- a/src/fs/gnunet-service-fs_lc.c
+++ b/src/fs/gnunet-service-fs_lc.c
@@ -184,11 +184,9 @@ GSF_local_client_lookup_ (struct GNUNET_SERVER_Client *client)
  * Free the given client request.
  *
  * @param cls the client request to free
- * @param tc task context
  */
 static void
-client_request_destroy (void *cls,
-                        const struct GNUNET_SCHEDULER_TaskContext *tc)
+client_request_destroy (void *cls)
 {
   struct ClientRequest *cr = cls;
   struct GSF_LocalClient *lc;
@@ -510,7 +508,7 @@ GSF_client_disconnect_handler_ (void *cls,
   {
     if (NULL != cr->kill_task)
       GNUNET_SCHEDULER_cancel (cr->kill_task);
-    client_request_destroy (cr, NULL);
+    client_request_destroy (cr);
   }
   while (NULL != (res = pos->res_head))
   {
diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index 8e414e74a..b338c1a13 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -244,11 +244,9 @@ get_rp_key (struct GSF_RequestPlan *rp)
  * Figure out when and how to transmit to the given peer.
  *
  * @param cls the `struct GSF_ConnectedPeer` for transmission
- * @param tc scheduler context
  */
 static void
-schedule_peer_transmission (void *cls,
-                            const struct GNUNET_SCHEDULER_TaskContext *tc);
+schedule_peer_transmission (void *cls);
 
 
 /**
@@ -457,11 +455,9 @@ transmit_message_callback (void *cls,
  * Figure out when and how to transmit to the given peer.
  *
  * @param cls the `struct PeerPlan`
- * @param tc scheduler context
  */
 static void
-schedule_peer_transmission (void *cls,
-                            const struct GNUNET_SCHEDULER_TaskContext *tc)
+schedule_peer_transmission (void *cls)
 {
   struct PeerPlan *pp = cls;
   struct GSF_RequestPlan *rp;
diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index 8c97e0898..a7a62a743 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -1300,11 +1300,9 @@ GSF_cadet_lookup_ (struct GSF_PendingRequest *pr)
  * Task that issues a warning if the datastore lookup takes too long.
  *
  * @param cls the `struct GSF_PendingRequest`
- * @param tc task context
  */
 static void
-warn_delay_task (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+warn_delay_task (void *cls)
 {
   struct GSF_PendingRequest *pr = cls;
 
@@ -1323,11 +1321,9 @@ warn_delay_task (void *cls,
  * Task that issues a warning if the datastore lookup takes too long.
  *
  * @param cls the `struct GSF_PendingRequest`
- * @param tc task context
  */
 static void
-odc_warn_delay_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+odc_warn_delay_task (void *cls)
 {
   struct GSF_PendingRequest *pr = cls;
 
diff --git a/src/fs/gnunet-service-fs_push.c b/src/fs/gnunet-service-fs_push.c
index a31a4f626..a76a3827c 100644
--- a/src/fs/gnunet-service-fs_push.c
+++ b/src/fs/gnunet-service-fs_push.c
@@ -432,11 +432,9 @@ find_content (struct MigrationReadyPeer *mrp)
  * migration
  *
  * @param cls unused
- * @param tc scheduler context (also unused)
  */
 static void
-gather_migration_blocks (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc);
+gather_migration_blocks (void *cls);
 
 
 /**
@@ -569,11 +567,9 @@ process_migration_content (void *cls,
  * migration
  *
  * @param cls unused
- * @param tc scheduler context (also unused)
  */
 static void
-gather_migration_blocks (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+gather_migration_blocks (void *cls)
 {
   mig_task = NULL;
   if (mig_size >= MAX_MIGRATION_QUEUE)
diff --git a/src/fs/gnunet-service-fs_put.c b/src/fs/gnunet-service-fs_put.c
index 3fb2d7abb..fa5aa461d 100644
--- a/src/fs/gnunet-service-fs_put.c
+++ b/src/fs/gnunet-service-fs_put.c
@@ -95,8 +95,7 @@ static struct PutOperator operators[] = {
  * @param tc scheduler context (unused)
  */
 static void
-gather_dht_put_blocks (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc);
+gather_dht_put_blocks (void *cls);
 
 
 /**
@@ -151,10 +150,9 @@ delay_dht_put_blocks (void *cls, int success)
  * Task that is run periodically to obtain blocks for DHT PUTs.
  *
  * @param cls type of blocks to gather
- * @param tc scheduler context
  */
 static void
-delay_dht_put_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+delay_dht_put_task (void *cls)
 {
   struct PutOperator *po = cls;
 
@@ -212,14 +210,15 @@ process_dht_put_content (void *cls,
  * Task that is run periodically to obtain blocks for DHT PUTs.
  *
  * @param cls type of blocks to gather
- * @param tc scheduler context (unused)
  */
 static void
-gather_dht_put_blocks (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+gather_dht_put_blocks (void *cls)
 {
   struct PutOperator *po = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   po->dht_task = NULL;
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   po->dht_qe =
diff --git a/src/fs/gnunet-unindex.c b/src/fs/gnunet-unindex.c
index 8a059478c..cab963e0d 100644
--- a/src/fs/gnunet-unindex.c
+++ b/src/fs/gnunet-unindex.c
@@ -40,7 +40,7 @@ static struct GNUNET_FS_UnindexContext *uc;
 
 
 static void
-cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup_task (void *cls)
 {
   GNUNET_FS_stop (ctx);
   ctx = NULL;
@@ -48,7 +48,7 @@ cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls)
 {
   struct GNUNET_FS_UnindexContext *u;
 
diff --git a/src/fs/perf_gnunet_service_fs_p2p.c b/src/fs/perf_gnunet_service_fs_p2p.c
index 08bfe1b30..40b2b977b 100644
--- a/src/fs/perf_gnunet_service_fs_p2p.c
+++ b/src/fs/perf_gnunet_service_fs_p2p.c
@@ -238,8 +238,7 @@ stat_run (void *cls,
 
 
 static void
-do_report (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_report (void *cls)
 {
   char *fn = cls;
   struct GNUNET_TIME_Relative del;
diff --git a/src/fs/perf_gnunet_service_fs_p2p_respect.c b/src/fs/perf_gnunet_service_fs_p2p_respect.c
index d20d15aff..2527c8978 100644
--- a/src/fs/perf_gnunet_service_fs_p2p_respect.c
+++ b/src/fs/perf_gnunet_service_fs_p2p_respect.c
@@ -279,7 +279,7 @@ stat_run (void *cls,
 
 
 static void
-do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_report (void *cls)
 {
   static int download_counter;
   const char *type = cls;
diff --git a/src/fs/test_fs_download.c b/src/fs/test_fs_download.c
index e192e8f52..936f001df 100644
--- a/src/fs/test_fs_download.c
+++ b/src/fs/test_fs_download.c
@@ -67,7 +67,7 @@ static int err;
 
 
 static void
-timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_kill_task (void *cls)
 {
   if (NULL != download)
   {
@@ -86,7 +86,7 @@ timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
   {
@@ -97,7 +97,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-stop_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+stop_fs_task (void *cls)
 {
   GNUNET_FS_stop (fs);
   fs = NULL;
@@ -105,7 +105,7 @@ stop_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_download_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_download_task (void *cls)
 {
   uint64_t size;
 
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index 6b78741e6..76a1ea911 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -62,7 +62,7 @@ static int err;
 
 
 static void
-timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_kill_task (void *cls)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
   if (download != NULL)
@@ -81,7 +81,7 @@ timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   if (publish != NULL)
   {
@@ -92,7 +92,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_download_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_download_task (void *cls)
 {
   uint64_t size;
 
@@ -116,7 +116,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n");
   GNUNET_FS_stop (fs);
diff --git a/src/fs/test_fs_list_indexed.c b/src/fs/test_fs_list_indexed.c
index b76e894a5..61e4df512 100644
--- a/src/fs/test_fs_list_indexed.c
+++ b/src/fs/test_fs_list_indexed.c
@@ -62,7 +62,7 @@ static int err;
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -76,8 +76,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-list_indexed_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+list_indexed_task (void *cls)
 {
   GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
 }
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index 201acb8f5..b8325d8d8 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -49,7 +49,7 @@ static int err;
 
 
 static void
-abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_ksk_search_task (void *cls)
 {
   if (ksk_search != NULL)
   {
@@ -66,7 +66,7 @@ abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_sks_search_task (void *cls)
 {
   if (sks_search == NULL)
     return;
@@ -82,13 +82,13 @@ abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-do_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_timeout (void *cls)
 {
   err = 1;
   FPRINTF (stderr, "%s",  "Operation timed out\n");
   kill_task = NULL;
-  abort_sks_search_task (NULL, tc);
-  abort_ksk_search_task (NULL, tc);
+  abort_sks_search_task (NULL);
+  abort_ksk_search_task (NULL);
 }
 
 
diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c
index a391dbe0d..f4c56e015 100644
--- a/src/fs/test_fs_publish.c
+++ b/src/fs/test_fs_publish.c
@@ -58,7 +58,7 @@ static int err;
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
diff --git a/src/fs/test_fs_publish_persistence.c b/src/fs/test_fs_publish_persistence.c
index 9807520a2..be9006d42 100644
--- a/src/fs/test_fs_publish_persistence.c
+++ b/src/fs/test_fs_publish_persistence.c
@@ -60,11 +60,11 @@ static char *fn2;
 
 static int err;
 
-static struct GNUNET_SCHEDULER_Task * rtask;
+static struct GNUNET_SCHEDULER_Task *rtask;
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -89,7 +89,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls)
 {
   rtask = NULL;
   GNUNET_FS_stop (fs);
diff --git a/src/fs/test_fs_search.c b/src/fs/test_fs_search.c
index 29a98bbad..0918b4b6b 100644
--- a/src/fs/test_fs_search.c
+++ b/src/fs/test_fs_search.c
@@ -58,7 +58,7 @@ static int err;
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
   {
@@ -74,7 +74,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_error (void *cls)
 {
   fprintf (stderr,
            "Timeout\n");
@@ -94,7 +94,7 @@ abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_search_task (void *cls)
 {
   if (NULL != search)
   {
diff --git a/src/fs/test_fs_search_persistence.c b/src/fs/test_fs_search_persistence.c
index 756c72557..db084446e 100644
--- a/src/fs/test_fs_search_persistence.c
+++ b/src/fs/test_fs_search_persistence.c
@@ -60,7 +60,7 @@ static int err;
 
 
 static void
-abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_error (void *cls)
 {
   timeout_task = NULL;
   fprintf (stderr,
@@ -78,8 +78,9 @@ abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   err = 1;
 }
 
+
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
   {
@@ -95,7 +96,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_search_task (void *cls)
 {
   if (NULL != search)
   {
@@ -110,7 +111,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls)
 {
   GNUNET_FS_stop (fs);
   fs = GNUNET_FS_start (cfg, "test-fs-search-persistence", &progress_cb, NULL,
diff --git a/src/fs/test_fs_search_probes.c b/src/fs/test_fs_search_probes.c
index bcb914d79..eaf804a22 100644
--- a/src/fs/test_fs_search_probes.c
+++ b/src/fs/test_fs_search_probes.c
@@ -59,7 +59,7 @@ static int err;
 
 
 static void
-abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_error (void *cls)
 {
   timeout_task = NULL;
   fprintf (stderr,
@@ -79,7 +79,7 @@ abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
   {
@@ -95,7 +95,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_search_task (void *cls)
 {
   if (search != NULL)
     GNUNET_FS_search_stop (search);
diff --git a/src/fs/test_fs_search_with_and.c b/src/fs/test_fs_search_with_and.c
index e25d3786a..83edf2e6c 100644
--- a/src/fs/test_fs_search_with_and.c
+++ b/src/fs/test_fs_search_with_and.c
@@ -66,7 +66,7 @@ static int processed_files;
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
   {
@@ -82,7 +82,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_error (void *cls)
 {
   fprintf (stderr,
            "Timeout\n");
@@ -102,7 +102,7 @@ abort_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_search_task (void *cls)
 {
   if (NULL != search)
   {
diff --git a/src/fs/test_fs_test_lib.c b/src/fs/test_fs_test_lib.c
index dda990830..c3a03668c 100644
--- a/src/fs/test_fs_test_lib.c
+++ b/src/fs/test_fs_test_lib.c
@@ -50,8 +50,7 @@ static int ret;
 
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls)
 {
   char *fn = cls;
 
diff --git a/src/fs/test_fs_unindex.c b/src/fs/test_fs_unindex.c
index 77a70cb20..bd36fcd18 100644
--- a/src/fs/test_fs_unindex.c
+++ b/src/fs/test_fs_unindex.c
@@ -57,7 +57,7 @@ static char *fn;
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -65,7 +65,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_unindex_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_unindex_task (void *cls)
 {
   GNUNET_FS_unindex_stop (unindex);
   unindex = NULL;
diff --git a/src/fs/test_fs_unindex_persistence.c b/src/fs/test_fs_unindex_persistence.c
index cfb08629b..7c76ee227 100644
--- a/src/fs/test_fs_unindex_persistence.c
+++ b/src/fs/test_fs_unindex_persistence.c
@@ -58,7 +58,7 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 
 static void
-abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -66,7 +66,7 @@ abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 static void
-abort_unindex_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_unindex_task (void *cls)
 {
   if (unindex != NULL)
   {
@@ -87,7 +87,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls)
 {
   GNUNET_FS_stop (fs);
   fs = GNUNET_FS_start (cfg, "test-fs-unindex-persistence", &progress_cb, NULL,
diff --git a/src/fs/test_gnunet_service_fs_migration.c b/src/fs/test_gnunet_service_fs_migration.c
index b698506b4..f00290b0d 100644
--- a/src/fs/test_gnunet_service_fs_migration.c
+++ b/src/fs/test_gnunet_service_fs_migration.c
@@ -64,8 +64,7 @@ struct DownloadContext
 
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls)
 {
   struct GNUNET_TIME_Relative del;
   char *fancy;
@@ -140,11 +139,12 @@ do_download (void *cls,
 
 
 static void
-stop_source_peer (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+stop_source_peer (void *cls)
 {
   struct DownloadContext *dc = cls;
+  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
+  tc = GNUNET_SCHEDULER_get_task_context ();
   /* Do not interact with testbed when shutting down */
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
diff --git a/src/fs/test_gnunet_service_fs_p2p.c b/src/fs/test_gnunet_service_fs_p2p.c
index f2b3f7516..3f6ec2497 100644
--- a/src/fs/test_gnunet_service_fs_p2p.c
+++ b/src/fs/test_gnunet_service_fs_p2p.c
@@ -54,7 +54,7 @@ static struct GNUNET_TIME_Absolute start_time;
 
 
 static void
-do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls)
 {
   char *fn = cls;
   struct GNUNET_TIME_Relative del;