changing scheduler priorities to revert to DEFAULT instead of inheriting parent-task priority unless something else is explicitly specified

10 files changed, 168 insertions, 78 deletions

diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index e8e1113f0..4c78e6fe7 100644
--- a/src/arm/gnunet-service-arm.c
+++ b/src/arm/gnunet-service-arm.c
@@ -805,8 +805,9 @@ delayed_restart_task (void *cls,
                   (unsigned long long) lowestRestartDelay.rel_value);
 #endif
       child_restart_task =
-        GNUNET_SCHEDULER_add_delayed (lowestRestartDelay,
-                                      &delayed_restart_task, NULL);
+        GNUNET_SCHEDULER_add_delayed_with_priority (lowestRestartDelay,
+                                                    GNUNET_SCHEDULER_PRIORITY_IDLE, 
+                                                    &delayed_restart_task, NULL);
     }
 }
 
@@ -922,7 +923,8 @@ maint_child_death (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
             GNUNET_SCHEDULER_cancel (child_restart_task);
           child_restart_task =
             GNUNET_SCHEDULER_add_with_priority
-            (GNUNET_SCHEDULER_PRIORITY_IDLE, &delayed_restart_task, NULL);
+            (GNUNET_SCHEDULER_PRIORITY_IDLE, 
+             &delayed_restart_task, NULL);
         }
       else
         {
diff --git a/src/chat/gnunet-chat.c b/src/chat/gnunet-chat.c
index af4eb53f3..4abc58c9f 100644
--- a/src/chat/gnunet-chat.c
+++ b/src/chat/gnunet-chat.c
@@ -572,9 +572,10 @@ handle_command (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 next:
   handle_cmd_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_MILLISECONDS, 100),
-                                    &handle_command, NULL);
+    GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_multiply
+                                                (GNUNET_TIME_UNIT_MILLISECONDS, 100),
+                                                GNUNET_SCHEDULER_PRIORITY_UI,
+                                                &handle_command, NULL);
   return;
 
 out:
diff --git a/src/datastore/gnunet-service-datastore.c b/src/datastore/gnunet-service-datastore.c
index bf89c1bc2..1d7e8cd2b 100644
--- a/src/datastore/gnunet-service-datastore.c
+++ b/src/datastore/gnunet-service-datastore.c
@@ -326,7 +326,9 @@ expired_processor (void *cls, const GNUNET_HashCode * key, uint32_t size,
   if (key == NULL)
   {
     expired_kill_task =
-        GNUNET_SCHEDULER_add_delayed (MAX_EXPIRE_DELAY, &delete_expired, NULL);
+        GNUNET_SCHEDULER_add_delayed_with_priority (MAX_EXPIRE_DELAY,
+                                                    GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                    &delete_expired, NULL);
     return GNUNET_SYSERR;
   }
   now = GNUNET_TIME_absolute_get ();
@@ -334,7 +336,9 @@ expired_processor (void *cls, const GNUNET_HashCode * key, uint32_t size,
   {
     /* finished processing */
     expired_kill_task =
-        GNUNET_SCHEDULER_add_delayed (MAX_EXPIRE_DELAY, &delete_expired, NULL);
+        GNUNET_SCHEDULER_add_delayed_with_priority (MAX_EXPIRE_DELAY,
+                                                    GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                    &delete_expired, NULL);
     return GNUNET_SYSERR;
   }
 #if DEBUG_DATASTORE
@@ -348,7 +352,9 @@ expired_processor (void *cls, const GNUNET_HashCode * key, uint32_t size,
                             GNUNET_YES);
   GNUNET_CONTAINER_bloomfilter_remove (filter, key);
   expired_kill_task =
-      GNUNET_SCHEDULER_add_delayed (MIN_EXPIRE_DELAY, &delete_expired, NULL);
+      GNUNET_SCHEDULER_add_delayed_with_priority (MIN_EXPIRE_DELAY,
+                                                  GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                  &delete_expired, NULL);
   return GNUNET_NO;
 }
 
diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index 293638732..2b1e51031 100644
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -1356,7 +1356,8 @@ deserialize_publish_file (void *cls, const char *filename)
     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
     pc->upload_task =
         GNUNET_SCHEDULER_add_with_priority
-        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc);
+        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, 
+         &GNUNET_FS_publish_main_, pc);
   }
   if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
   {
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index 164e264c6..4711c09e6 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -1816,7 +1816,9 @@ cron_flush_trust (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
-  GNUNET_SCHEDULER_add_delayed (TRUST_FLUSH_FREQ, &cron_flush_trust, NULL);
+  GNUNET_SCHEDULER_add_delayed_with_priority (TRUST_FLUSH_FREQ,
+                                              GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                              &cron_flush_trust, NULL);
 }
 
 
diff --git a/src/include/gnunet_scheduler_lib.h b/src/include/gnunet_scheduler_lib.h
index 9b8c57ff3..e16ccc511 100644
--- a/src/include/gnunet_scheduler_lib.h
+++ b/src/include/gnunet_scheduler_lib.h
@@ -111,7 +111,9 @@ enum GNUNET_SCHEDULER_Priority
 
   /**
    * Run with the default priority (normal
-   * P2P operations).  Higher than BACKGROUND.
+   * P2P operations).  Any task that is scheduled
+   * without an explicit priority being specified
+   * will run with this priority.
    */
   GNUNET_SCHEDULER_PRIORITY_DEFAULT = 3,
 
@@ -262,7 +264,7 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p);
  * * @return reason(s) why the current task is run
  */
 enum GNUNET_SCHEDULER_Reason
-GNUNET_SCHEDULER_get_reason ();
+GNUNET_SCHEDULER_get_reason (void);
 
 
 /**
@@ -291,9 +293,24 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
 
 
 /**
+ * Continue the current execution with the given function.  This is
+ * similar to the other "add" functions except that there is no delay
+ * and the reason code can be specified.
+ *
+ * @param task main function of the task
+ * @param task_cls closure for 'main'
+ * @param reason reason for task invocation
+ * @param priority priority to use for the task
+ */
+void
+GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, void *task_cls,
+                                                 enum GNUNET_SCHEDULER_Reason reason,
+                                                 enum GNUNET_SCHEDULER_Priority priority);
+
+
+/**
  * Schedule a new task to be run after the specified prerequisite task
- * has completed. It will be run with the priority of the calling
- * task.
+ * has completed. It will be run with DEFAULT priority.
  *
  * * @param prerequisite_task run this task after the task with the given
  *        task identifier completes (and any of our other
@@ -327,7 +344,7 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
 
 /**
  * Schedule a new task to be run as soon as possible. The task
- * will be run with the priority of the calling task.
+ * will be run with the DEFAULT priority.
  *
  * * @param task main function of the task
  * @param task_cls closure of task
@@ -361,7 +378,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 /**
  * Schedule a new task to be run with a specified delay.  The task
  * will be scheduled for execution once the delay has expired. It
- * will be run with the priority of the calling task.
+ * will be run with the DEFAULT priority.
  *
  * * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
@@ -376,12 +393,29 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
 
 
 /**
+ * Schedule a new task to be run with a specified delay.  The task
+ * will be scheduled for execution once the delay has expired.
+ *
+ * @param delay when should this operation time out? Use
+ *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param priority priority to use for the task
+ * @param task main function of the task
+ * @param task_cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "task" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
+                                            enum GNUNET_SCHEDULER_Priority priority,
+                                            GNUNET_SCHEDULER_Task task, void *task_cls);
+
+
+/**
  * Schedule a new task to be run with a specified delay or when the
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
- * socket operation is ready.  It will be run with the priority of
- * the calling task.
+ * socket operation is ready.  It will be run with the DEFAULT priority.
  *
  * * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
@@ -402,8 +436,7 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  * specified file descriptor is ready for writing.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
- * socket operation is ready.  It will be run with the priority of
- * the calling task.
+ * socket operation is ready.  It will be run with the DEFAULT priority.
  *
  * * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
@@ -424,8 +457,7 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
- * socket operation is ready. It will be run with the priority of
- * the calling task.
+ * socket operation is ready. It will be run with the DEFAULT priority.
  *
  * * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
@@ -446,8 +478,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  * specified file descriptor is ready for writing.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
- * socket operation is ready. It will be run with the priority of
- * the calling task.
+ * socket operation is ready. It will be run with the DEFAULT priority.
  *
  * * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c
index 30493851e..6617fdfea 100644
--- a/src/nse/gnunet-service-nse.c
+++ b/src/nse/gnunet-service-nse.c
@@ -911,7 +911,9 @@ find_proof (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     my_proof = counter;
   }
   proof_task =
-      GNUNET_SCHEDULER_add_delayed (proof_find_delay, &find_proof, NULL);
+      GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
+                                                  GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                  &find_proof, NULL);
 }
 
 
diff --git a/src/peerinfo/gnunet-service-peerinfo.c b/src/peerinfo/gnunet-service-peerinfo.c
index 799fdc6d8..d6e52d4b4 100644
--- a/src/peerinfo/gnunet-service-peerinfo.c
+++ b/src/peerinfo/gnunet-service-peerinfo.c
@@ -293,8 +293,9 @@ cron_scan_directory_data_hosts (void *cls,
   count = 0;
   if (GNUNET_SYSERR == GNUNET_DISK_directory_create (networkIdDirectory))
   {
-    GNUNET_SCHEDULER_add_delayed (DATA_HOST_FREQ,
-                                  &cron_scan_directory_data_hosts, NULL);
+    GNUNET_SCHEDULER_add_delayed_with_priority (DATA_HOST_FREQ,
+                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                &cron_scan_directory_data_hosts, NULL);
     return;
   }
   GNUNET_DISK_directory_scan (networkIdDirectory,
@@ -302,8 +303,10 @@ cron_scan_directory_data_hosts (void *cls,
   if ((0 == count) && (0 == (++retries & 31)))
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
                 _("Still no peers found in `%s'!\n"), networkIdDirectory);
-  GNUNET_SCHEDULER_add_delayed (DATA_HOST_FREQ, &cron_scan_directory_data_hosts,
-                                NULL);
+  GNUNET_SCHEDULER_add_delayed_with_priority (DATA_HOST_FREQ, 
+                                              GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                              &cron_scan_directory_data_hosts,
+                                              NULL);
 }
 
 
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index 2ab682494..9faa213ae 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -106,6 +106,11 @@ struct GNUNET_CRYPTO_FileHashContext
   GNUNET_SCHEDULER_TaskIdentifier task;
 
   /**
+   * Priority we use.
+   */
+  enum GNUNET_SCHEDULER_Priority priority;
+
+  /**
    * Blocksize.
    */
   size_t bsize;
@@ -162,7 +167,8 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     file_hash_finish (fhc, res);
     return;
   }
-  fhc->task = GNUNET_SCHEDULER_add_now (&file_hash_task, fhc);
+  fhc->task = GNUNET_SCHEDULER_add_with_priority (fhc->priority,
+                                                  &file_hash_task, fhc);
 }
 
 
@@ -213,6 +219,7 @@ GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
     GNUNET_free (fhc);
     return NULL;
   }
+  fhc->priority = priority;
   fhc->task =
       GNUNET_SCHEDULER_add_with_priority (priority, &file_hash_task, fhc);
   return fhc;
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 1acc9a6d6..5f91ffbbc 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -1054,10 +1054,12 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
  * @param task main function of the task
  * @param task_cls closure for 'main'
  * @param reason reason for task invocation
+ * @param priority priority to use for the task
  */
 void
-GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
-                                   enum GNUNET_SCHEDULER_Reason reason)
+GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, void *task_cls,
+                                                 enum GNUNET_SCHEDULER_Reason reason,
+                                                 enum GNUNET_SCHEDULER_Priority priority)
 {
   struct Task *t;
 
@@ -1083,7 +1085,7 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->reason = reason;
-  t->priority = current_priority;
+  t->priority = priority;
   t->lifeness = current_lifeness;
 #if DEBUG_TASKS
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n", t->id,
@@ -1093,11 +1095,28 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
 }
 
 
+/**
+ * Continue the current execution with the given function.  This is
+ * similar to the other "add" functions except that there is no delay
+ * and the reason code can be specified.
+ *
+ * @param task main function of the task
+ * @param task_cls closure for 'main'
+ * @param reason reason for task invocation
+ */
+void
+GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
+                                   enum GNUNET_SCHEDULER_Reason reason)
+{
+  GNUNET_SCHEDULER_add_continuation_with_priority (task, task_cls,
+                                                   reason,
+                                                   GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+}
+
 
 /**
  * Schedule a new task to be run after the specified prerequisite task
- * has completed. It will be run with the priority of the calling
- * task.
+ * has completed. It will be run with the DEFAULT priority.
  *
  * @param prerequisite_task run this task after the task with the given
  *        task identifier completes (and any of our other
@@ -1114,7 +1133,7 @@ GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
                             GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
+  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                       prerequisite_task, GNUNET_TIME_UNIT_ZERO,
                                       NULL, NULL, task, task_cls);
 }
@@ -1142,22 +1161,21 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
 
 /**
  * Schedule a new task to be run with a specified delay.  The task
- * will be scheduled for execution once the delay has expired. It
- * will be run with the priority of the calling task.
+ * will be scheduled for execution once the delay has expired.
  *
  * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param priority priority to use for the task
  * @param task main function of the task
  * @param task_cls closure of task
  * @return unique task identifier for the job
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
-                              GNUNET_SCHEDULER_Task task, void *task_cls)
+GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
+                                            enum GNUNET_SCHEDULER_Priority priority,
+                                            GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-#if 1
-  /* new, optimized version */
   struct Task *t;
   struct Task *pos;
   struct Task *prev;
@@ -1183,7 +1201,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
-  t->priority = current_priority;
+  t->priority = priority;
   t->lifeness = current_lifeness;
   /* try tail first (optimization in case we are
    * appending to a long list of tasks with timeouts) */
@@ -1227,20 +1245,34 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
          t->backtrace_strings[i]);
 #endif
   return t->id;
-
-#else
-  /* unoptimized version */
-  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      GNUNET_SCHEDULER_NO_TASK, delay, NULL,
-                                      NULL, task, task_cls);
-#endif
 }
 
 
+/**
+ * Schedule a new task to be run with a specified delay.  The task
+ * will be scheduled for execution once the delay has expired. It
+ * will be run with the DEFAULT priority.
+ *
+ * @param delay when should this operation time out? Use
+ *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param task main function of the task
+ * @param task_cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "task" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
+                              GNUNET_SCHEDULER_Task task, void *task_cls)
+{
+  return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
+                                                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                                     task, task_cls);
+}
+
 
 /**
  * Schedule a new task to be run as soon as possible. The task
- * will be run with the priority of the calling task.
+ * will be run with the DEFAULT priority.
  *
  * @param task main function of the task
  * @param task_cls closure of task
@@ -1250,10 +1282,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      GNUNET_SCHEDULER_NO_TASK,
-                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                      task_cls);
+  return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO, task, task_cls);
 }
 
 
@@ -1279,7 +1308,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
   GNUNET_SCHEDULER_TaskIdentifier ret;
 
   ret =
-      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                    GNUNET_SCHEDULER_NO_TASK,
                                    GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
                                    task_cls);
@@ -1289,8 +1318,6 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 }
 
 
-
-
 /**
  * Schedule a new task to be run with a specified delay or when any of
  * the specified file descriptor sets is ready.  The delay can be used
@@ -1310,6 +1337,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
  *
  * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever",
  *        which means that the task will only be run after we receive SIGTERM
+ * @param priority priority to use
  * @param rfd file descriptor we want to read (can be -1)
  * @param wfd file descriptors we want to write (can be -1)
  * @param task main function of the task
@@ -1319,7 +1347,9 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
  */
 #ifndef MINGW
 static GNUNET_SCHEDULER_TaskIdentifier
-add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
+add_without_sets (struct GNUNET_TIME_Relative delay, 
+                  enum GNUNET_SCHEDULER_Priority priority,
+                  int rfd, int wfd,
                   GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
@@ -1381,7 +1411,7 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
 #endif
   t->prereq_id = GNUNET_SCHEDULER_NO_TASK;
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
-  t->priority = check_priority (current_priority);
+  t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority);
   t->lifeness = current_lifeness;
   t->next = pending;
   pending = t;
@@ -1408,8 +1438,7 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
- * socket operation is ready.  It will be run with the priority of
- * the calling task.
+ * socket operation is ready.  It will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
@@ -1432,13 +1461,15 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
   rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_set (rs, rfd);
   ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                   GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
-                                   task, task_cls);
+    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                 GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
+                                 task, task_cls);
   GNUNET_NETWORK_fdset_destroy (rs);
   return ret;
 #else
-  return add_without_sets (delay, GNUNET_NETWORK_get_fd (rfd), -1, task,
+  return add_without_sets (delay, 
+                           GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                           GNUNET_NETWORK_get_fd (rfd), -1, task,
                            task_cls);
 #endif
 }
@@ -1473,14 +1504,16 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
   ws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_set (ws, wfd);
   ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                   GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
+    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                 GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
                                    task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
   return ret;
 #else
   GNUNET_assert (GNUNET_NETWORK_get_fd (wfd) >= 0);
-  return add_without_sets (delay, -1, GNUNET_NETWORK_get_fd (wfd), task,
+  return add_without_sets (delay, 
+                           GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                           -1, GNUNET_NETWORK_get_fd (wfd), task,
                            task_cls);
 #endif
 }
@@ -1491,8 +1524,7 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
- * socket operation is ready. It will be run with the priority of
- * the calling task.
+ * socket operation is ready. It will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
@@ -1515,7 +1547,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
   rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_handle_set (rs, rfd);
   ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                    GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
                                    task, task_cls);
   GNUNET_NETWORK_fdset_destroy (rs);
@@ -1524,7 +1556,9 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
   int fd;
 
   GNUNET_DISK_internal_file_handle_ (rfd, &fd, sizeof (int));
-  return add_without_sets (delay, fd, -1, task, task_cls);
+  return add_without_sets (delay, 
+                           GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                           fd, -1, task, task_cls);
 
 #endif
 }
@@ -1535,8 +1569,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  * specified file descriptor is ready for writing.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
- * socket operation is ready. It will be run with the priority of
- * the calling task.
+ * socket operation is ready. It will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use
  *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
@@ -1559,7 +1592,7 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
   ws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_handle_set (ws, wfd);
   ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                    GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
                                    task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
@@ -1569,7 +1602,9 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
 
   GNUNET_DISK_internal_file_handle_ (wfd, &fd, sizeof (int));
   GNUNET_assert (fd >= 0);
-  return add_without_sets (delay, -1, fd, task, task_cls);
+  return add_without_sets (delay, 
+                           GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                           -1, fd, task, task_cls);
 
 #endif
 }