use log from

1 files changed, 440 insertions, 417 deletions

diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index dad924c32..b7860650e 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -265,7 +265,7 @@ static void *scheduler_select_cls;
  */
 void
 GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select,
-                             void *new_select_cls)
+                             void *new_select_cls)
 {
   scheduler_select = new_select;
   scheduler_select_cls = new_select_cls;
@@ -284,7 +284,7 @@ check_priority (enum GNUNET_SCHEDULER_Priority p)
   if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT))
     return p;
   GNUNET_assert (0);
-  return 0;                     /* make compiler happy */
+  return 0;                     /* make compiler happy */
 }
 
 
@@ -306,37 +306,37 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
 
   if (id < lowest_pending_id)
     return GNUNET_NO;
-  min = -1;                     /* maximum value */
+  min = -1;                     /* maximum value */
   pos = pending;
   while (pos != NULL)
-  {
-    if (pos->id == id)
-      return GNUNET_YES;
-    if (pos->id < min)
-      min = pos->id;
-    pos = pos->next;
-  }
+    {
+      if (pos->id == id)
+        return GNUNET_YES;
+      if (pos->id < min)
+        min = pos->id;
+      pos = pos->next;
+    }
   pos = pending_timeout;
   while (pos != NULL)
-  {
-    if (pos->id == id)
-      return GNUNET_YES;
-    if (pos->id < min)
-      min = pos->id;
-    pos = pos->next;
-  }
-  for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++)
-  {
-    pos = ready[p];
-    while (pos != NULL)
     {
       if (pos->id == id)
-        return GNUNET_YES;
+        return GNUNET_YES;
       if (pos->id < min)
-        min = pos->id;
+        min = pos->id;
       pos = pos->next;
     }
-  }
+  for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++)
+    {
+      pos = ready[p];
+      while (pos != NULL)
+        {
+          if (pos->id == id)
+            return GNUNET_YES;
+          if (pos->id < min)
+            min = pos->id;
+          pos = pos->next;
+        }
+    }
   lowest_pending_id = min;
   return GNUNET_NO;
 }
@@ -351,7 +351,7 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
  */
 static void
 update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
-             struct GNUNET_TIME_Relative *timeout)
+             struct GNUNET_TIME_Relative *timeout)
 {
   struct Task *pos;
   struct GNUNET_TIME_Absolute now;
@@ -360,40 +360,40 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
   now = GNUNET_TIME_absolute_get ();
   pos = pending_timeout;
   if (pos != NULL)
-  {
-    to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-    if (timeout->rel_value > to.rel_value)
-      *timeout = to;
-    if (pos->reason != 0)
-      *timeout = GNUNET_TIME_UNIT_ZERO;
-  }
+    {
+      to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
+      if (timeout->rel_value > to.rel_value)
+        *timeout = to;
+      if (pos->reason != 0)
+        *timeout = GNUNET_TIME_UNIT_ZERO;
+    }
   pos = pending;
   while (pos != NULL)
-  {
-    if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) &&
-        (GNUNET_YES == is_pending (pos->prereq_id)))
     {
+      if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) &&
+          (GNUNET_YES == is_pending (pos->prereq_id)))
+        {
+          pos = pos->next;
+          continue;
+        }
+      if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+        {
+          to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
+          if (timeout->rel_value > to.rel_value)
+            *timeout = to;
+        }
+      if (pos->read_fd != -1)
+        GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
+      if (pos->write_fd != -1)
+        GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
+      if (pos->read_set != NULL)
+        GNUNET_NETWORK_fdset_add (rs, pos->read_set);
+      if (pos->write_set != NULL)
+        GNUNET_NETWORK_fdset_add (ws, pos->write_set);
+      if (pos->reason != 0)
+        *timeout = GNUNET_TIME_UNIT_ZERO;
       pos = pos->next;
-      continue;
     }
-    if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
-    {
-      to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-      if (timeout->rel_value > to.rel_value)
-        *timeout = to;
-    }
-    if (pos->read_fd != -1)
-      GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
-    if (pos->write_fd != -1)
-      GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
-    if (pos->read_set != NULL)
-      GNUNET_NETWORK_fdset_add (rs, pos->read_set);
-    if (pos->write_set != NULL)
-      GNUNET_NETWORK_fdset_add (ws, pos->write_set);
-    if (pos->reason != 0)
-      *timeout = GNUNET_TIME_UNIT_ZERO;
-    pos = pos->next;
-  }
 }
 
 
@@ -408,17 +408,17 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
  */
 static int
 set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
-              struct GNUNET_NETWORK_FDSet *want)
+              struct GNUNET_NETWORK_FDSet *want)
 {
   if ((NULL == want) || (NULL == ready))
     return GNUNET_NO;
   if (GNUNET_NETWORK_fdset_overlap (ready, want))
-  {
-    /* copy all over (yes, there maybe unrelated bits,
-     * but this should not hurt well-written clients) */
-    GNUNET_NETWORK_fdset_copy (want, ready);
-    return GNUNET_YES;
-  }
+    {
+      /* copy all over (yes, there maybe unrelated bits,
+       * but this should not hurt well-written clients) */
+      GNUNET_NETWORK_fdset_copy (want, ready);
+      return GNUNET_YES;
+    }
   return GNUNET_NO;
 }
 
@@ -435,8 +435,8 @@ set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
  */
 static int
 is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
-          const struct GNUNET_NETWORK_FDSet *rs,
-          const struct GNUNET_NETWORK_FDSet *ws)
+          const struct GNUNET_NETWORK_FDSet *rs,
+          const struct GNUNET_NETWORK_FDSet *ws)
 {
   enum GNUNET_SCHEDULER_Reason reason;
 
@@ -445,25 +445,25 @@ is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
     reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
       (((task->read_fd != -1) &&
-        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, task->read_fd))) ||
-       (set_overlaps (rs, task->read_set))))
+        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, task->read_fd)))
+       || (set_overlaps (rs, task->read_set))))
     reason |= GNUNET_SCHEDULER_REASON_READ_READY;
   if ((0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
       (((task->write_fd != -1) &&
-        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd)))
+        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd)))
        || (set_overlaps (ws, task->write_set))))
     reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
   if (reason == 0)
-    return GNUNET_NO;           /* not ready */
+    return GNUNET_NO;           /* not ready */
   if (task->prereq_id != GNUNET_SCHEDULER_NO_TASK)
-  {
-    if (GNUNET_YES == is_pending (task->prereq_id))
     {
-      task->reason = reason;
-      return GNUNET_NO;         /* prereq waiting */
+      if (GNUNET_YES == is_pending (task->prereq_id))
+        {
+          task->reason = reason;
+          return GNUNET_NO;     /* prereq waiting */
+        }
+      reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
     }
-    reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
-  }
   task->reason = reason;
   return GNUNET_YES;
 }
@@ -496,7 +496,7 @@ queue_ready_task (struct Task *task)
  */
 static void
 check_ready (const struct GNUNET_NETWORK_FDSet *rs,
-             const struct GNUNET_NETWORK_FDSet *ws)
+             const struct GNUNET_NETWORK_FDSet *ws)
 {
   struct Task *pos;
   struct Task *prev;
@@ -507,40 +507,41 @@ check_ready (const struct GNUNET_NETWORK_FDSet *rs,
   prev = NULL;
   pos = pending_timeout;
   while (pos != NULL)
-  {
-    next = pos->next;
-    if (now.abs_value >= pos->timeout.abs_value)
-      pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
-    if (0 == pos->reason)
-      break;
-    pending_timeout = next;
-    if (pending_timeout_last == pos)
-      pending_timeout_last = NULL;
-    queue_ready_task (pos);
-    pos = next;
-  }
+    {
+      next = pos->next;
+      if (now.abs_value >= pos->timeout.abs_value)
+        pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+      if (0 == pos->reason)
+        break;
+      pending_timeout = next;
+      if (pending_timeout_last == pos)
+        pending_timeout_last = NULL;
+      queue_ready_task (pos);
+      pos = next;
+    }
   pos = pending;
   while (pos != NULL)
-  {
+    {
 #if DEBUG_TASKS
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Checking readiness of task: %llu / %p\n", pos->id,
-                pos->callback_cls);
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "util",
+                       "Checking readiness of task: %llu / %p\n", pos->id,
+                       pos->callback_cls);
 #endif
-    next = pos->next;
-    if (GNUNET_YES == is_ready (pos, now, rs, ws))
-    {
-      if (prev == NULL)
-        pending = next;
-      else
-        prev->next = next;
-      queue_ready_task (pos);
+      next = pos->next;
+      if (GNUNET_YES == is_ready (pos, now, rs, ws))
+        {
+          if (prev == NULL)
+            pending = next;
+          else
+            prev->next = next;
+          queue_ready_task (pos);
+          pos = next;
+          continue;
+        }
+      prev = pos;
       pos = next;
-      continue;
     }
-    prev = pos;
-    pos = next;
-  }
 }
 
 
@@ -559,26 +560,15 @@ GNUNET_SCHEDULER_shutdown ()
 
   pos = pending_timeout;
   while (pos != NULL)
-  {
-    pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
-    /* we don't move the task into the ready queue yet; check_ready
-     * will do that later, possibly adding additional
-     * readiness-factors */
-    pos = pos->next;
-  }
+    {
+      pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
+      /* we don't move the task into the ready queue yet; check_ready
+       * will do that later, possibly adding additional
+       * readiness-factors */
+      pos = pos->next;
+    }
   pos = pending;
   while (pos != NULL)
-  {
-    pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
-    /* we don't move the task into the ready queue yet; check_ready
-     * will do that later, possibly adding additional
-     * readiness-factors */
-    pos = pos->next;
-  }
-  for (i = 0; i < GNUNET_SCHEDULER_PRIORITY_COUNT; i++)
-  {
-    pos = ready[i];
-    while (pos != NULL)
     {
       pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
       /* we don't move the task into the ready queue yet; check_ready
@@ -586,7 +576,18 @@ GNUNET_SCHEDULER_shutdown ()
        * readiness-factors */
       pos = pos->next;
     }
-  }
+  for (i = 0; i < GNUNET_SCHEDULER_PRIORITY_COUNT; i++)
+    {
+      pos = ready[i];
+      while (pos != NULL)
+        {
+          pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
+          /* we don't move the task into the ready queue yet; check_ready
+           * will do that later, possibly adding additional
+           * readiness-factors */
+          pos = pos->next;
+        }
+    }
 }
 
 
@@ -628,69 +629,74 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
 
   max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
   do
-  {
-    if (ready_count == 0)
-      return;
-    GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
-    /* yes, p>0 is correct, 0 is "KEEP" which should
-     * always be an empty queue (see assertion)! */
-    for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
     {
-      pos = ready[p];
-      if (pos != NULL)
-        break;
-    }
-    GNUNET_assert (pos != NULL);        /* ready_count wrong? */
-    ready[p] = pos->next;
-    ready_count--;
-    if (current_priority != pos->priority)
-    {
-      current_priority = pos->priority;
-      (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (),
-                                             pos->priority);
-    }
-    current_lifeness = pos->lifeness;
-    active_task = pos;
+      if (ready_count == 0)
+        return;
+      GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
+      /* yes, p>0 is correct, 0 is "KEEP" which should
+       * always be an empty queue (see assertion)! */
+      for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
+        {
+          pos = ready[p];
+          if (pos != NULL)
+            break;
+        }
+      GNUNET_assert (pos != NULL);      /* ready_count wrong? */
+      ready[p] = pos->next;
+      ready_count--;
+      if (current_priority != pos->priority)
+        {
+          current_priority = pos->priority;
+          (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (),
+                                                 pos->priority);
+        }
+      current_lifeness = pos->lifeness;
+      active_task = pos;
 #if PROFILE_DELAYS
-    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value >
-        DELAY_THRESHOLD.rel_value)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Task %llu took %llums to be scheduled\n", pos->id,
-                  (unsigned long long)
-                  GNUNET_TIME_absolute_get_duration
-                  (pos->start_time).rel_value);
-    }
+      if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value >
+          DELAY_THRESHOLD.rel_value)
+        {
+          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                           "util",
+                           "Task %llu took %llums to be scheduled\n", pos->id,
+                           (unsigned long long)
+                           GNUNET_TIME_absolute_get_duration
+                           (pos->start_time).rel_value);
+        }
 #endif
-    tc.reason = pos->reason;
-    tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set;
-    if ((pos->read_fd != -1) &&
-        (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)))
-      GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
-    tc.write_ready = (pos->write_set == NULL) ? ws : pos->write_set;
-    if ((pos->write_fd != -1) &&
-        (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
-      GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
-    if (((tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY) != 0) &&
-        (pos->write_fd != -1) &&
-        (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
-      abort ();                 // added to ready in previous select loop!
+      tc.reason = pos->reason;
+      tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set;
+      if ((pos->read_fd != -1) &&
+          (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)))
+        GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
+      tc.write_ready = (pos->write_set == NULL) ? ws : pos->write_set;
+      if ((pos->write_fd != -1) &&
+          (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
+        GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
+      if (((tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY) != 0) &&
+          (pos->write_fd != -1) &&
+          (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
+        abort ();               // added to ready in previous select loop!
 #if DEBUG_TASKS
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running task: %llu / %p\n", pos->id,
-                pos->callback_cls);
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "util",
+                       "Running task: %llu / %p\n", pos->id,
+                       pos->callback_cls);
 #endif
-    pos->callback (pos->callback_cls, &tc);
+      pos->callback (pos->callback_cls, &tc);
 #if EXECINFO
-    int i;
+      int i;
 
-    for (i = 0; i < pos->num_backtrace_strings; i++)
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Task %llu trace %d: %s\n", pos->id,
-                  i, pos->backtrace_strings[i]);
+      for (i = 0; i < pos->num_backtrace_strings; i++)
+        GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                         "util",
+                         "Task %llu trace %d: %s\n", pos->id,
+                         i, pos->backtrace_strings[i]);
 #endif
-    active_task = NULL;
-    destroy_task (pos);
-    tasks_run++;
-  }
+      active_task = NULL;
+      destroy_task (pos);
+      tasks_run++;
+    }
   while ((pending == NULL) || (p >= max_priority_added));
 }
 
@@ -716,11 +722,11 @@ static void
 sighandler_shutdown ()
 {
   static char c;
-  int old_errno = errno;        /* backup errno */
+  int old_errno = errno;        /* backup errno */
 
   GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
-                          (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
-                          &c, sizeof (c));
+                          (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
+                          &c, sizeof (c));
   errno = old_errno;
 }
 
@@ -746,10 +752,10 @@ check_lifeness ()
     if (t->lifeness == GNUNET_YES)
       return GNUNET_OK;
   if ((NULL != pending) || (NULL != pending_timeout))
-  {
-    GNUNET_SCHEDULER_shutdown ();
-    return GNUNET_OK;
-  }
+    {
+      GNUNET_SCHEDULER_shutdown ();
+      return GNUNET_OK;
+    }
   return GNUNET_NO;
 }
 
@@ -795,7 +801,7 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO);
   GNUNET_assert (shutdown_pipe_handle != NULL);
   pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
-                                GNUNET_DISK_PIPE_END_READ);
+                                GNUNET_DISK_PIPE_END_READ);
   GNUNET_assert (pr != NULL);
   shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown);
   shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown);
@@ -807,77 +813,79 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
   current_lifeness = GNUNET_YES;
   GNUNET_SCHEDULER_add_continuation (task, task_cls,
-                                     GNUNET_SCHEDULER_REASON_STARTUP);
+                                     GNUNET_SCHEDULER_REASON_STARTUP);
 #if ENABLE_WINDOWS_WORKAROUNDS
-  active_task = (void *) (long) -1;     /* force passing of sanity check */
+  active_task = (void *) (long) -1;     /* force passing of sanity check */
   GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
-                                          &GNUNET_OS_install_parent_control_handler,
-                                          NULL);
+                                          &GNUNET_OS_install_parent_control_handler,
+                                          NULL);
   active_task = NULL;
 #endif
   last_tr = 0;
   busy_wait_warning = 0;
   while (GNUNET_OK == check_lifeness ())
-  {
-    GNUNET_NETWORK_fdset_zero (rs);
-    GNUNET_NETWORK_fdset_zero (ws);
-    timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-    update_sets (rs, ws, &timeout);
-    GNUNET_NETWORK_fdset_handle_set (rs, pr);
-    if (ready_count > 0)
-    {
-      /* no blocking, more work already ready! */
-      timeout = GNUNET_TIME_UNIT_ZERO;
-    }
-    if (NULL == scheduler_select)
-      ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout);
-    else
-      ret = scheduler_select (scheduler_select_cls, rs, ws, NULL, timeout);
-    if (ret == GNUNET_SYSERR)
     {
-      if (errno == EINTR)
-        continue;
-
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");
+      GNUNET_NETWORK_fdset_zero (rs);
+      GNUNET_NETWORK_fdset_zero (ws);
+      timeout = GNUNET_TIME_UNIT_FOREVER_REL;
+      update_sets (rs, ws, &timeout);
+      GNUNET_NETWORK_fdset_handle_set (rs, pr);
+      if (ready_count > 0)
+        {
+          /* no blocking, more work already ready! */
+          timeout = GNUNET_TIME_UNIT_ZERO;
+        }
+      if (NULL == scheduler_select)
+        ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout);
+      else
+        ret = scheduler_select (scheduler_select_cls, rs, ws, NULL, timeout);
+      if (ret == GNUNET_SYSERR)
+        {
+          if (errno == EINTR)
+            continue;
+
+          GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_ERROR, "util",
+                                    "select");
 #ifndef MINGW
 #if USE_LSOF
-      char lsof[512];
-
-      snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
-      (void) close (1);
-      (void) dup2 (2, 1);
-      if (0 != system (lsof))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "system");
+          char lsof[512];
+
+          snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
+          (void) close (1);
+          (void) dup2 (2, 1);
+          if (0 != system (lsof))
+            GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_WARNING, "util",
+                                      "system");
 #endif
 #endif
-      abort ();
-      break;
-    }
-    if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Looks like we're busy waiting...\n"));
-      sleep (1);                /* mitigate */
-    }
-    check_ready (rs, ws);
-    run_ready (rs, ws);
-    if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
-    {
-      /* consume the signal */
-      GNUNET_DISK_file_read (pr, &c, sizeof (c));
-      /* mark all active tasks as ready due to shutdown */
-      GNUNET_SCHEDULER_shutdown ();
-    }
-    if (last_tr == tasks_run)
-    {
-      busy_wait_warning++;
-    }
-    else
-    {
-      last_tr = tasks_run;
-      busy_wait_warning = 0;
+          abort ();
+          break;
+        }
+      if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
+        {
+          GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                           "util", _("Looks like we're busy waiting...\n"));
+          sleep (1);            /* mitigate */
+        }
+      check_ready (rs, ws);
+      run_ready (rs, ws);
+      if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
+        {
+          /* consume the signal */
+          GNUNET_DISK_file_read (pr, &c, sizeof (c));
+          /* mark all active tasks as ready due to shutdown */
+          GNUNET_SCHEDULER_shutdown ();
+        }
+      if (last_tr == tasks_run)
+        {
+          busy_wait_warning++;
+        }
+      else
+        {
+          last_tr = tasks_run;
+          busy_wait_warning = 0;
+        }
     }
-  }
   GNUNET_SIGNAL_handler_uninstall (shc_int);
   GNUNET_SIGNAL_handler_uninstall (shc_term);
 #ifndef MINGW
@@ -930,10 +938,10 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
   ret = 0;
   pos = ready[check_priority (p)];
   while (pos != NULL)
-  {
-    pos = pos->next;
-    ret++;
-  }
+    {
+      pos = pos->next;
+      ret++;
+    }
   return ret;
 }
 
@@ -959,77 +967,79 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
   prev = NULL;
   t = pending;
   while (t != NULL)
-  {
-    if (t->id == task)
-      break;
-    prev = t;
-    t = t->next;
-  }
-  if (t == NULL)
-  {
-    prev = NULL;
-    to = 1;
-    t = pending_timeout;
-    while (t != NULL)
     {
       if (t->id == task)
-        break;
+        break;
       prev = t;
       t = t->next;
     }
-    if (pending_timeout_last == t)
-      pending_timeout_last = NULL;
-  }
-  p = 0;
-  while (t == NULL)
-  {
-    p++;
-    if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT)
+  if (t == NULL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Attempt to cancel dead task %llu!\n"),
-                  (unsigned long long) task);
-      GNUNET_assert (0);
+      prev = NULL;
+      to = 1;
+      t = pending_timeout;
+      while (t != NULL)
+        {
+          if (t->id == task)
+            break;
+          prev = t;
+          t = t->next;
+        }
+      if (pending_timeout_last == t)
+        pending_timeout_last = NULL;
     }
-    prev = NULL;
-    t = ready[p];
-    while (t != NULL)
+  p = 0;
+  while (t == NULL)
     {
-      if (t->id == task)
-      {
-        ready_count--;
-        break;
-      }
-      prev = t;
-      t = t->next;
+      p++;
+      if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT)
+        {
+          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                           "util",
+                           _("Attempt to cancel dead task %llu!\n"),
+                           (unsigned long long) task);
+          GNUNET_assert (0);
+        }
+      prev = NULL;
+      t = ready[p];
+      while (t != NULL)
+        {
+          if (t->id == task)
+            {
+              ready_count--;
+              break;
+            }
+          prev = t;
+          t = t->next;
+        }
     }
-  }
   if (prev == NULL)
-  {
-    if (p == 0)
     {
-      if (to == 0)
-      {
-        pending = t->next;
-      }
+      if (p == 0)
+        {
+          if (to == 0)
+            {
+              pending = t->next;
+            }
+          else
+            {
+              pending_timeout = t->next;
+            }
+        }
       else
-      {
-        pending_timeout = t->next;
-      }
+        {
+          ready[p] = t->next;
+        }
     }
-    else
+  else
     {
-      ready[p] = t->next;
+      prev->next = t->next;
     }
-  }
-  else
-  {
-    prev->next = t->next;
-  }
   ret = t->callback_cls;
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task,
-              t->callback_cls);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "util",
+                   "Canceling task: %llu / %p\n", task, t->callback_cls);
 #endif
   destroy_task (t);
   return ret;
@@ -1047,7 +1057,7 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
  */
 void
 GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
-                                   enum GNUNET_SCHEDULER_Reason reason)
+                                   enum GNUNET_SCHEDULER_Reason reason)
 {
   struct Task *t;
 
@@ -1057,12 +1067,12 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
 
   GNUNET_assert (NULL != task);
   GNUNET_assert ((active_task != NULL) ||
-                 (reason == GNUNET_SCHEDULER_REASON_STARTUP));
+                 (reason == GNUNET_SCHEDULER_REASON_STARTUP));
   t = GNUNET_malloc (sizeof (struct Task));
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, 50);
   t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+    backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
@@ -1076,8 +1086,10 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
   t->priority = current_priority;
   t->lifeness = current_lifeness;
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n",
-              t->id, t->callback_cls);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "util",
+                   "Adding continuation task: %llu / %p\n",
+                   t->id, t->callback_cls);
 #endif
   queue_ready_task (t);
 }
@@ -1102,11 +1114,12 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
-                            GNUNET_SCHEDULER_Task task, void *task_cls)
+                            GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      prerequisite_task, GNUNET_TIME_UNIT_ZERO,
-                                      NULL, NULL, task, task_cls);
+                                      prerequisite_task,
+                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                      task_cls);
 }
 
 
@@ -1121,11 +1134,12 @@ GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
-                                    GNUNET_SCHEDULER_Task task, void *task_cls)
+                                    GNUNET_SCHEDULER_Task task,
+                                    void *task_cls)
 {
   return GNUNET_SCHEDULER_add_select (prio, GNUNET_SCHEDULER_NO_TASK,
-                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                      task_cls);
+                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                      task_cls);
 }
 
 
@@ -1144,7 +1158,7 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
-                              GNUNET_SCHEDULER_Task task, void *task_cls)
+                              GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if 1
   /* new, optimized version */
@@ -1164,7 +1178,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+    backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
@@ -1179,24 +1193,24 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
    * appending to a long list of tasks with timeouts) */
   prev = pending_timeout_last;
   if (prev != NULL)
-  {
-    if (prev->timeout.abs_value > t->timeout.abs_value)
-      prev = NULL;
-    else
-      pos = prev->next;         /* heuristic success! */
-  }
+    {
+      if (prev->timeout.abs_value > t->timeout.abs_value)
+        prev = NULL;
+      else
+        pos = prev->next;       /* heuristic success! */
+    }
   if (prev == NULL)
-  {
-    /* heuristic failed, do traversal of timeout list */
-    pos = pending_timeout;
-  }
+    {
+      /* heuristic failed, do traversal of timeout list */
+      pos = pending_timeout;
+    }
   while ((pos != NULL) &&
-         ((pos->timeout.abs_value <= t->timeout.abs_value) ||
-          (pos->reason != 0)))
-  {
-    prev = pos;
-    pos = pos->next;
-  }
+         ((pos->timeout.abs_value <= t->timeout.abs_value) ||
+          (pos->reason != 0)))
+    {
+      prev = pos;
+      pos = pos->next;
+    }
   if (prev == NULL)
     pending_timeout = t;
   else
@@ -1206,23 +1220,26 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
   pending_timeout_last = t;
 
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
-              t->callback_cls);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "util",
+                   "Adding task: %llu / %p\n", t->id, t->callback_cls);
 #endif
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
-                t->backtrace_strings[i]);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "util",
+                     "Task %llu trace %d: %s\n", t->id, i,
+                     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);
+                                      GNUNET_SCHEDULER_NO_TASK, delay, NULL,
+                                      NULL, task, task_cls);
 #endif
 }
 
@@ -1241,9 +1258,9 @@ 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);
+                                      GNUNET_SCHEDULER_NO_TASK,
+                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                      task_cls);
 }
 
 
@@ -1263,16 +1280,16 @@ GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls)
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
-                                        GNUNET_SCHEDULER_Task task,
-                                        void *task_cls)
+                                        GNUNET_SCHEDULER_Task task,
+                                        void *task_cls)
 {
   GNUNET_SCHEDULER_TaskIdentifier ret;
 
   ret =
-      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                   GNUNET_SCHEDULER_NO_TASK,
-                                   GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                   task_cls);
+    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                 GNUNET_SCHEDULER_NO_TASK,
+                                 GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                 task_cls);
   GNUNET_assert (pending->id == ret);
   pending->lifeness = lifeness;
   return ret;
@@ -1310,7 +1327,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 #ifndef MINGW
 GNUNET_SCHEDULER_TaskIdentifier
 add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
-                  GNUNET_SCHEDULER_Task task, void *task_cls)
+                  GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
 
@@ -1326,45 +1343,45 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+    backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
 #if DEBUG_FDS
   if (-1 != rfd)
-  {
-    int flags = fcntl (rfd, F_GETFD);
-
-    if (flags == -1 && errno == EBADF)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n",
-                  rfd);
+      int flags = fcntl (rfd, F_GETFD);
+
+      if ((flags == -1) && (errno == EBADF))
+        {
+          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                           "util", "Got invalid file descriptor %d!\n", rfd);
 #if EXECINFO
-      int i;
+          int i;
 
-      for (i = 0; i < t->num_backtrace_strings; i++)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n",
-                    t->backtrace_strings[i]);
+          for (i = 0; i < t->num_backtrace_strings; i++)
+            GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                             "util", "Trace: %s\n", t->backtrace_strings[i]);
 #endif
-      GNUNET_assert (0);
+          GNUNET_assert (0);
+        }
     }
-  }
   if (-1 != wfd)
-  {
-    int flags = fcntl (wfd, F_GETFD);
-
-    if (flags == -1 && errno == EBADF)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n",
-                  wfd);
+      int flags = fcntl (wfd, F_GETFD);
+
+      if (flags == -1 && errno == EBADF)
+        {
+          GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                           "util", "Got invalid file descriptor %d!\n", wfd);
 #if EXECINFO
-      int i;
+          int i;
 
-      for (i = 0; i < t->num_backtrace_strings; i++)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n",
-                    t->backtrace_strings[i]);
+          for (i = 0; i < t->num_backtrace_strings; i++)
+            GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                             "util", "Trace: %s\n", t->backtrace_strings[i]);
 #endif
-      GNUNET_assert (0);
+          GNUNET_assert (0);
+        }
     }
-  }
 #endif
   t->read_fd = rfd;
   GNUNET_assert (wfd >= -1);
@@ -1381,15 +1398,17 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
-              t->callback_cls);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "util",
+                   "Adding task: %llu / %p\n", t->id, t->callback_cls);
 #endif
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
-                t->backtrace_strings[i]);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "util",
+                     "Task %llu trace %d: %s\n", t->id, i,
+                     t->backtrace_strings[i]);
 #endif
   return t->id;
 }
@@ -1415,8 +1434,8 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
-                               struct GNUNET_NETWORK_Handle *rfd,
-                               GNUNET_SCHEDULER_Task task, void *task_cls)
+                               struct GNUNET_NETWORK_Handle * rfd,
+                               GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if MINGW
   struct GNUNET_NETWORK_FDSet *rs;
@@ -1426,14 +1445,14 @@ 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 (check_priority (current_priority),
+                                 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,
-                           task_cls);
+                           task_cls);
 #endif
 }
 
@@ -1456,8 +1475,8 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
-                                struct GNUNET_NETWORK_Handle *wfd,
-                                GNUNET_SCHEDULER_Task task, void *task_cls)
+                                struct GNUNET_NETWORK_Handle * wfd,
+                                GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if MINGW
   struct GNUNET_NETWORK_FDSet *ws;
@@ -1467,15 +1486,15 @@ 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,
-                                   task, task_cls);
+    GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+                                 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,
-                           task_cls);
+                           task_cls);
 #endif
 }
 
@@ -1498,8 +1517,8 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
-                                const struct GNUNET_DISK_FileHandle *rfd,
-                                GNUNET_SCHEDULER_Task task, void *task_cls)
+                                const struct GNUNET_DISK_FileHandle * rfd,
+                                GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if MINGW
   struct GNUNET_NETWORK_FDSet *rs;
@@ -1509,9 +1528,9 @@ 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_NO_TASK, delay, rs, NULL,
-                                   task, task_cls);
+    GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+                                 GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
+                                 task, task_cls);
   GNUNET_NETWORK_fdset_destroy (rs);
   return ret;
 #else
@@ -1542,8 +1561,8 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
-                                 const struct GNUNET_DISK_FileHandle *wfd,
-                                 GNUNET_SCHEDULER_Task task, void *task_cls)
+                                 const struct GNUNET_DISK_FileHandle * wfd,
+                                 GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if MINGW
   struct GNUNET_NETWORK_FDSet *ws;
@@ -1553,9 +1572,9 @@ 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_NO_TASK, delay, NULL, ws,
-                                   task, task_cls);
+    GNUNET_SCHEDULER_add_select (check_priority (current_priority),
+                                 GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
+                                 task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
   return ret;
 #else
@@ -1604,11 +1623,12 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
-                             GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
-                             struct GNUNET_TIME_Relative delay,
-                             const struct GNUNET_NETWORK_FDSet *rs,
-                             const struct GNUNET_NETWORK_FDSet *ws,
-                             GNUNET_SCHEDULER_Task task, void *task_cls)
+                             GNUNET_SCHEDULER_TaskIdentifier
+                             prerequisite_task,
+                             struct GNUNET_TIME_Relative delay,
+                             const struct GNUNET_NETWORK_FDSet * rs,
+                             const struct GNUNET_NETWORK_FDSet * ws,
+                             GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
 
@@ -1624,20 +1644,20 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+    backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
   if (rs != NULL)
-  {
-    t->read_set = GNUNET_NETWORK_fdset_create ();
-    GNUNET_NETWORK_fdset_copy (t->read_set, rs);
-  }
+    {
+      t->read_set = GNUNET_NETWORK_fdset_create ();
+      GNUNET_NETWORK_fdset_copy (t->read_set, rs);
+    }
   if (ws != NULL)
-  {
-    t->write_set = GNUNET_NETWORK_fdset_create ();
-    GNUNET_NETWORK_fdset_copy (t->write_set, ws);
-  }
+    {
+      t->write_set = GNUNET_NETWORK_fdset_create ();
+      GNUNET_NETWORK_fdset_copy (t->write_set, ws);
+    }
   t->id = ++last_id;
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
@@ -1645,23 +1665,26 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
   t->prereq_id = prerequisite_task;
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
   t->priority =
-      check_priority ((prio ==
-                       GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
-                      prio);
+    check_priority ((prio ==
+                     GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
+                    prio);
   t->lifeness = current_lifeness;
   t->next = pending;
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
 #if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
-              t->callback_cls);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "util",
+                   "Adding task: %llu / %p\n", t->id, t->callback_cls);
 #endif
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
-                t->backtrace_strings[i]);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "util",
+                     "Task %llu trace %d: %s\n", t->id, i,
+                     t->backtrace_strings[i]);
 #endif
   return t->id;
 }