25 files changed, 128 insertions, 122 deletions

diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index 9676f2e3c..91c568554 100644
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -164,7 +164,7 @@ process_job_queue (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       run_time = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2);
       end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
       rst = GNUNET_TIME_absolute_get_remaining (end_time);
-      if (0 == rst.rel_value)
+      if (0 == rst.rel_value_us)
       {
         num_probes_expired++;
         stop_job (qe);
@@ -181,7 +181,7 @@ process_job_queue (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                        qe->blocks * qe->start_times);
       end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
       rst = GNUNET_TIME_absolute_get_remaining (end_time);
-      if (0 == rst.rel_value)
+      if (0 == rst.rel_value_us)
       {
         num_downloads_expired++;
         stop_job (qe);
@@ -781,7 +781,7 @@ write_start_time (struct GNUNET_BIO_WriteHandle *wh,
   struct GNUNET_TIME_Relative dur;
 
   dur = GNUNET_TIME_absolute_get_duration (timestamp);
-  return GNUNET_BIO_write_int64 (wh, dur.rel_value);
+  return GNUNET_BIO_write_int64 (wh, dur.rel_value_us);
 }
 
 
@@ -805,7 +805,7 @@ read_start_time (struct GNUNET_BIO_ReadHandle *rh,
 {
   struct GNUNET_TIME_Relative dur;
 
-  if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dur.rel_value))
+  if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dur.rel_value_us))
     return GNUNET_SYSERR;
   *timestamp = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (), dur);
   return GNUNET_OK;
@@ -871,7 +871,7 @@ deserialize_fi_node (struct GNUNET_FS_Handle *h, const char *fn,
       || (GNUNET_OK !=
           GNUNET_BIO_read_string (rh, "fn", &ret->filename, 16 * 1024)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_int64 (rh, &ret->bo.expiration_time.abs_value)) ||
+       GNUNET_BIO_read_int64 (rh, &ret->bo.expiration_time.abs_value_us)) ||
       (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &ret->bo.anonymity_level)) ||
       (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &ret->bo.content_priority)) ||
       (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &ret->bo.replication_level)))
@@ -1273,7 +1273,7 @@ GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *fi)
       (GNUNET_OK != GNUNET_BIO_write_string (wh, fi->emsg)) ||
       (GNUNET_OK != GNUNET_BIO_write_string (wh, fi->filename)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_write_int64 (wh, fi->bo.expiration_time.abs_value)) ||
+       GNUNET_BIO_write_int64 (wh, fi->bo.expiration_time.abs_value_us)) ||
       (GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->bo.anonymity_level)) ||
       (GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->bo.content_priority)) ||
       (GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->bo.replication_level)))
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index 2371e6544..a86df253a 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -1082,7 +1082,7 @@ process_result_with_request (void *cls, const struct GNUNET_HashCode * key,
   pi.value.download.specifics.progress.depth = dr->depth;
   pi.value.download.specifics.progress.respect_offered = prc->respect_offered;
   pi.value.download.specifics.progress.num_transmissions = prc->num_transmissions;
-  if (prc->last_transmission.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+  if (prc->last_transmission.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
     pi.value.download.specifics.progress.block_download_duration 
       = GNUNET_TIME_absolute_get_duration (prc->last_transmission);
   else
@@ -1437,7 +1437,7 @@ try_reconnect (struct GNUNET_FS_DownloadContext *dc)
     dc->in_receive = GNUNET_NO;
     dc->client = NULL;
   }
-  if (0 == dc->reconnect_backoff.rel_value)
+  if (0 == dc->reconnect_backoff.rel_value_us)
     dc->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
   else
     dc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (dc->reconnect_backoff);
diff --git a/src/fs/fs_misc.c b/src/fs/fs_misc.c
index 89dc48683..ee24fa250 100644
--- a/src/fs/fs_misc.c
+++ b/src/fs/fs_misc.c
@@ -202,7 +202,7 @@ GNUNET_FS_year_to_time (unsigned int year)
   t.tm_yday = 1;
   tp = mktime (&t);
   GNUNET_break (tp != (time_t) - 1);
-  ret.abs_value = tp * 1000LL;  /* seconds to ms */
+  ret.abs_value_us = tp * 1000LL * 1000LL;  /* seconds to microseconds */
   return ret;
 }
 
@@ -219,7 +219,7 @@ GNUNET_FS_time_to_year (struct GNUNET_TIME_Absolute at)
   struct tm *t;
   time_t tp;
 
-  tp = at.abs_value / 1000;    /* ms to seconds */
+  tp = at.abs_value_us / 1000LL / 1000LL;    /* microseconds to seconds */
   t = gmtime (&tp);
   if (t == NULL)
     return 0;
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index 9bc254254..38bd55caa 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -342,7 +342,7 @@ GNUNET_FS_search_probe_progress_ (void *cls,
     {
       /* should only happen if the cancel task was already
          created on 'DOWNLOAD_INACTIVE' as we were out of time */
-      GNUNET_break (0 == sr->remaining_probe_time.rel_value);
+      GNUNET_break (0 == sr->remaining_probe_time.rel_value_us);
     }
     break;
   case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
@@ -354,7 +354,7 @@ GNUNET_FS_search_probe_progress_ (void *cls,
     dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
     sr->remaining_probe_time =
         GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur);
-    if (0 == sr->remaining_probe_time.rel_value)
+    if (0 == sr->remaining_probe_time.rel_value_us)
       sr->probe_cancel_task =
         GNUNET_SCHEDULER_add_now (&probe_failure_handler, sr);
     GNUNET_FS_search_result_sync_ (sr);
@@ -843,7 +843,7 @@ process_result (struct GNUNET_FS_SearchContext *sc,
                 const void *data,
                 size_t size)
 {
-  if (GNUNET_TIME_absolute_get_duration (expiration).rel_value > 0)
+  if (GNUNET_TIME_absolute_get_duration (expiration).rel_value_us > 0)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Result received has already expired.\n");
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index e0bdc7ed6..6724dc625 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -638,7 +638,7 @@ uri_loc_parse (const char *s, char **emsg)
   }
   ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
   ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
-  et.abs_value = exptime;
+  et.abs_value_us = exptime * 1000LL * 1000LL;
   ass.exptime = GNUNET_TIME_absolute_hton (et);
   if (GNUNET_OK !=
       GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT,
@@ -2030,13 +2030,14 @@ uri_loc_to_string (const struct GNUNET_FS_Uri *uri)
   peerSig =
       bin2enc (&uri->data.loc.contentSignature,
                sizeof (struct GNUNET_CRYPTO_EccSignature));
-  GNUNET_asprintf (&ret, "%s%s%s.%s.%llu.%s.%s.%llu", GNUNET_FS_URI_PREFIX,
+  GNUNET_asprintf (&ret, 
+                   "%s%s%s.%s.%llu.%s.%s.%llu", GNUNET_FS_URI_PREFIX,
                    GNUNET_FS_URI_LOC_INFIX, (const char *) &keyhash,
                    (const char *) &queryhash,
                    (unsigned long long) GNUNET_ntohll (uri->data.loc.
                                                        fi.file_length), peerId,
                    peerSig,
-                   (unsigned long long) uri->data.loc.expirationTime.abs_value);
+                   (unsigned long long) uri->data.loc.expirationTime.abs_value_us / 1000LL / 1000LL);
   GNUNET_free (peerSig);
   GNUNET_free (peerId);
   return ret;
diff --git a/src/fs/gnunet-daemon-fsprofiler.c b/src/fs/gnunet-daemon-fsprofiler.c
index 16a74b8a0..30a127559 100644
--- a/src/fs/gnunet-daemon-fsprofiler.c
+++ b/src/fs/gnunet-daemon-fsprofiler.c
@@ -189,7 +189,7 @@ parse_pattern (struct Pattern **head,
     p = GNUNET_malloc (sizeof (struct Pattern));
     p->x = x;
     p->y = y;
-    p->delay.rel_value = (uint64_t) t;
+    p->delay.rel_value_us = (uint64_t) t;
     GNUNET_CONTAINER_DLL_insert (*head, *tail, p);
     pattern = strstr (pattern, ")");
     GNUNET_assert (NULL != pattern);
@@ -397,7 +397,7 @@ progress_cb (void *cls,
     p = info->value.publish.cctx;
     GNUNET_STATISTICS_update (stats_handle,
                               "# publishing time (ms)", 
-                              (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value, 
+                              (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value_us / 1000LL, 
                               GNUNET_NO);
     p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
     return p;
@@ -425,8 +425,9 @@ progress_cb (void *cls,
     p = info->value.download.cctx;
     GNUNET_STATISTICS_update (stats_handle,
                               "# download time (ms)", 
-                              (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value, 
-                              GNUNET_NO);    p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
+                              (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value_us / 1000LL, 
+                              GNUNET_NO); 
+    p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
     return p;
   case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
     p = info->value.download.cctx;
@@ -450,7 +451,7 @@ progress_cb (void *cls,
       return NULL; /* not what we want */
     GNUNET_STATISTICS_update (stats_handle,
                               "# search time (ms)", 
-                              (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value, 
+                              (long long) GNUNET_TIME_absolute_get_duration (p->start_time).rel_value_us / 1000LL, 
                               GNUNET_NO);
     p->start_time = GNUNET_TIME_absolute_get ();
     p->ctx = GNUNET_FS_download_start (fs_handle, uri,
diff --git a/src/fs/gnunet-download.c b/src/fs/gnunet-download.c
index 04edc66c8..30081f0b4 100644
--- a/src/fs/gnunet-download.c
+++ b/src/fs/gnunet-download.c
@@ -142,8 +142,8 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
     {
       s = GNUNET_strdup (GNUNET_STRINGS_relative_time_to_string (info->value.download.eta,
                                                                  GNUNET_YES));
-      if (info->value.download.specifics.progress.block_download_duration.rel_value 
-          == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+      if (info->value.download.specifics.progress.block_download_duration.rel_value_us 
+          == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
         s2 = _("<unknown time>");
       else
         s2 = GNUNET_STRINGS_relative_time_to_string (
@@ -152,7 +152,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
       t = GNUNET_STRINGS_byte_size_fancy (info->value.download.completed *
                                           1000LL /
                                           (info->value.download.
-                                           duration.rel_value + 1));
+                                           duration.rel_value_us + 1));
       FPRINTF (stdout,
                _("Downloading `%s' at %llu/%llu (%s remaining, %s/s). Block took %s to download\n"),
                info->value.download.filename,
@@ -183,7 +183,7 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
   case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
     s = GNUNET_STRINGS_byte_size_fancy (info->value.download.completed * 1000 /
                                         (info->value.download.
-                                         duration.rel_value + 1));
+                                         duration.rel_value_us + 1));
 #if !WINDOWS
     if (0 != isatty (1))
       fprintf (stdout, "\n");
diff --git a/src/fs/gnunet-fs-profiler.c b/src/fs/gnunet-fs-profiler.c
index 9bc3ff253..cde70ae88 100644
--- a/src/fs/gnunet-fs-profiler.c
+++ b/src/fs/gnunet-fs-profiler.c
@@ -145,7 +145,7 @@ test_master (void *cls, unsigned int num_peers,
   // FIXME: enable clients to signal 'completion' before timeout;
   // in that case, run the 'terminate_task' "immediately"
 
-  if (0 != timeout.rel_value)
+  if (0 != timeout.rel_value_us)
     terminate_taskid = GNUNET_SCHEDULER_add_delayed (timeout,
                                                      &terminate_task, NULL);
   else
diff --git a/src/fs/gnunet-search.c b/src/fs/gnunet-search.c
index e90b761d7..df544c21b 100644
--- a/src/fs/gnunet-search.c
+++ b/src/fs/gnunet-search.c
@@ -259,7 +259,7 @@ run (void *cls, char *const *args, const char *cfgfile,
     ret = 1;
     return;
   }
-  if (0 != timeout.rel_value)
+  if (0 != timeout.rel_value_us)
     GNUNET_SCHEDULER_add_delayed (timeout, &shutdown_task, NULL);
   else
     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index 9074f053e..a8fbda84b 100644
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -202,7 +202,7 @@ GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start)
   struct GNUNET_TIME_Relative delay;
 
   delay = GNUNET_TIME_absolute_get_duration (start);
-  GNUNET_LOAD_update (datastore_get_load, delay.rel_value);
+  GNUNET_LOAD_update (datastore_get_load, delay.rel_value_us);
 }
 
 
@@ -260,16 +260,16 @@ update_latencies (void *cls,
   {
     if (GNUNET_ATS_QUALITY_NET_DELAY != ntohl (ats[i].type))
       continue;
-    latency.rel_value = ntohl (ats[i].value);
+    latency.rel_value_us = ntohl (ats[i].value);
     GSF_update_peer_latency_ (&address->peer,
                               latency);
-    GSF_avg_latency.rel_value =
-      (GSF_avg_latency.rel_value * 31 +
+    GSF_avg_latency.rel_value_us =
+      (GSF_avg_latency.rel_value_us * 31 +
        GNUNET_MIN (5000, ntohl (ats[i].value))) / 32;
     GNUNET_STATISTICS_set (GSF_stats,
                            gettext_noop
                            ("# running average P2P latency (ms)"),
-                           GSF_avg_latency.rel_value, GNUNET_NO);
+                           GSF_avg_latency.rel_value_us / 1000LL, GNUNET_NO);
     break;    
   }
 }
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index e1a3e1ac9..5f047665e 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -488,7 +488,7 @@ peer_transmit_ready_cb (void *cls, size_t size, void *buf)
   }
   GNUNET_LOAD_update (cp->ppd.transmission_delay,
                       GNUNET_TIME_absolute_get_duration
-                      (pth->transmission_request_start_time).rel_value);
+                      (pth->transmission_request_start_time).rel_value_us);
   ret = pth->gmc (pth->gmc_cls, size, buf);
   if (NULL != (pos = cp->pth_head))
   {
@@ -621,7 +621,7 @@ revive_migration (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   cp->mig_revive_task = GNUNET_SCHEDULER_NO_TASK;
   bt = GNUNET_TIME_absolute_get_remaining (cp->ppd.migration_blocked_until);
-  if (0 != bt.rel_value)
+  if (0 != bt.rel_value_us)
   {
     /* still time left... */
     cp->mig_revive_task =
@@ -833,12 +833,12 @@ get_randomized_delay ()
       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
                                      GNUNET_CRYPTO_random_u32
                                      (GNUNET_CRYPTO_QUALITY_WEAK,
-                                      2 * GSF_avg_latency.rel_value + 1));
+                                      2 * GSF_avg_latency.rel_value_us + 1));
 #if INSANE_STATISTICS
   GNUNET_STATISTICS_update (GSF_stats,
                             gettext_noop
                             ("# artificial delays introduced (ms)"),
-                            ret.rel_value, GNUNET_NO);
+                            ret.rel_value_us / 1000LL, GNUNET_NO);
 #endif
   return ret;
 }
@@ -1216,7 +1216,7 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
   spid = 0;
   if ((GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1 + priority))
       || (GNUNET_LOAD_get_average (cp->ppd.transmission_delay) >
-          GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value * 2 +
+          GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value_us * 2 +
           GNUNET_LOAD_get_average (GSF_rt_entry_lifetime)))
   {
     /* don't have BW to send to peer, or would likely take longer than we have for it,
@@ -1253,7 +1253,7 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
     prd = GSF_pending_request_get_data_ (pr);
     if (prd->type == type) 
     {
-      if (prd->ttl.abs_value >= GNUNET_TIME_absolute_get ().abs_value + ttl)
+      if (prd->ttl.abs_value_us >= GNUNET_TIME_absolute_get ().abs_value_us + ttl * 1000LL)
       {
         /* existing request has higher TTL, drop new one! */
         prd->priority += priority;
@@ -1425,9 +1425,9 @@ GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp,
   struct GNUNET_TIME_Relative delay;
 
   delay = GNUNET_TIME_absolute_get_duration (request_time);
-  cp->ppd.avg_reply_delay.rel_value =
-      (cp->ppd.avg_reply_delay.rel_value * (RUNAVG_DELAY_N - 1) +
-       delay.rel_value) / RUNAVG_DELAY_N;
+  cp->ppd.avg_reply_delay.rel_value_us =
+      (cp->ppd.avg_reply_delay.rel_value_us * (RUNAVG_DELAY_N - 1) +
+       delay.rel_value_us) / RUNAVG_DELAY_N;
   cp->ppd.avg_priority =
       (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1) +
        request_priority) / RUNAVG_DELAY_N;
@@ -1678,7 +1678,7 @@ void
 GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
                            struct GNUNET_TIME_Absolute block_time)
 {
-  if (cp->last_migration_block.abs_value > block_time.abs_value)
+  if (cp->last_migration_block.abs_value_us > block_time.abs_value_us)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Migration already blocked for another %s\n",
@@ -1686,8 +1686,9 @@ GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
                                                         (cp->last_migration_block), GNUNET_YES));
     return;                     /* already blocked */
   }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %llu ms\n",
-              (unsigned long long) GNUNET_TIME_absolute_get_remaining (block_time).rel_value);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %s\n",
+              GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (block_time),
+                                                      GNUNET_YES));
   cp->last_migration_block = block_time;
   if (NULL != cp->migration_pth)
     GSF_peer_transmit_cancel_ (cp->migration_pth);
diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index 5c63e7b66..21f028a2d 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -283,11 +283,11 @@ plan (struct PeerPlan *pp, struct GSF_RequestPlan *rp)
     delay =
         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                        8 + (1LL << 24));
-  delay.rel_value =
-      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                delay.rel_value + 1);
+  delay.rel_value_us =
+    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                              delay.rel_value_us + 1);
   /* Add 0.01 to avg_delay to avoid division-by-zero later */
-  avg_delay = (((avg_delay * (N - 1.0)) + delay.rel_value) / N) + 0.01;
+  avg_delay = (((avg_delay * (N - 1.0)) + delay.rel_value_us) / N) + 0.01;
 
   /*
    * For the priority, we need to consider a few basic rules:
@@ -312,27 +312,27 @@ plan (struct PeerPlan *pp, struct GSF_RequestPlan *rp)
    */
   rp->priority =
       round ((GSF_current_priorities +
-              1.0) * atan (delay.rel_value / avg_delay)) / M_PI_4;
+              1.0) * atan (delay.rel_value_us / avg_delay)) / M_PI_4;
   /* Note: usage of 'round' and 'atan' requires -lm */
 
   if (rp->transmission_counter != 0)
-    delay.rel_value += TTL_DECREMENT;
+    delay.rel_value_us += TTL_DECREMENT * 1000;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Considering (re)transmission number %u in %llu ms\n",
+              "Considering (re)transmission number %u in %s\n",
               (unsigned int) rp->transmission_counter,
-              (unsigned long long) delay.rel_value);
+              GNUNET_STRINGS_relative_time_to_string (delay,
+                                                      GNUNET_YES));
   rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Earliest (re)transmission for `%s' in %us\n",
               GNUNET_h2s (&prd->query), rp->transmission_counter);
   GNUNET_assert (rp->hn == NULL);
-  if (GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value
-      == 0)
+  if (0 == GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value_us)
     rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap, rp, rp->priority);
   else
     rp->hn =
         GNUNET_CONTAINER_heap_insert (pp->delay_heap, rp,
-                                      rp->earliest_transmission.abs_value);
+                                      rp->earliest_transmission.abs_value_us);
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_contains_value (pp->plan_map,
                                                                get_rp_key (rp),
@@ -363,8 +363,8 @@ get_latest (const struct GSF_RequestPlan *rp)
   bi = bi->next_PE; 
   while (NULL != bi)
   {
-    if (GSF_pending_request_get_data_ (bi->pr)->ttl.abs_value >
-        GSF_pending_request_get_data_ (ret)->ttl.abs_value)
+    if (GSF_pending_request_get_data_ (bi->pr)->ttl.abs_value_us >
+        GSF_pending_request_get_data_ (ret)->ttl.abs_value_us)
       ret = bi->pr;
     bi = bi->next_PE;
   }
@@ -459,8 +459,8 @@ schedule_peer_transmission (void *cls,
   }
   /* move ready requests to priority queue */
   while ((NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&
-         (GNUNET_TIME_absolute_get_remaining
-          (rp->earliest_transmission).rel_value == 0))
+         (0 == GNUNET_TIME_absolute_get_remaining
+          (rp->earliest_transmission).rel_value_us))
   {
     GNUNET_assert (rp == GNUNET_CONTAINER_heap_remove_root (pp->delay_heap));
     rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap, rp, rp->priority);
@@ -477,10 +477,12 @@ schedule_peer_transmission (void *cls,
     }
     delay = GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Sleeping for %llu ms before retrying requests on plan %p.\n",
-                (unsigned long long) delay.rel_value, pp);
-    GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# delay heap timeout"),
-                           delay.rel_value, GNUNET_NO);
+                "Sleeping for %s before retrying requests on plan %p.\n",
+                GNUNET_STRINGS_relative_time_to_string (delay,
+                                                        GNUNET_YES),
+                pp);
+    GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# delay heap timeout (ms)"),
+                           delay.rel_value_us / 1000LL, GNUNET_NO);
 
     pp->task =
         GNUNET_SCHEDULER_add_delayed (delay, &schedule_peer_transmission, pp);
@@ -551,8 +553,8 @@ merge_pr (void *cls, const struct GNUNET_HashCode * query, void *element)
                             GNUNET_NO);
 #endif
   latest = get_latest (rp);
-  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value <
-      prd->ttl.abs_value)
+  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value_us <
+      prd->ttl.abs_value_us)
   {
 #if INSANE_STATISTICS
     GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# requests refreshed"),
@@ -721,7 +723,7 @@ GSF_request_plan_reference_get_last_transmission_ (
   {
     if (bi->rp->pp->cp == sender)
     {
-      if (0 == bi->rp->last_transmission.abs_value)
+      if (0 == bi->rp->last_transmission.abs_value_us)
         *result = GNUNET_TIME_UNIT_FOREVER_ABS;
       else
         *result = bi->rp->last_transmission;
diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index a78cbf287..627d376ef 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2010, 2011, 2012 Christian Grothoff (and other contributing authors)
+     (C) 2009-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -373,7 +373,7 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
   {
     pr->hnode =
         GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap, pr,
-                                      pr->public_data.ttl.abs_value);
+                                      pr->public_data.ttl.abs_value_us);
     /* make sure we don't track too many requests */
     while (GNUNET_CONTAINER_heap_get_size (requests_by_expiration_heap) >
            max_pending_requests)
@@ -555,8 +555,8 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
   pr->public_data.respect_offered += prio;
   gm->priority = htonl (prio);
   now = GNUNET_TIME_absolute_get ();
-  ttl = (int64_t) (pr->public_data.ttl.abs_value - now.abs_value);
-  gm->ttl = htonl (ttl / 1000);
+  ttl = (int64_t) (pr->public_data.ttl.abs_value_us - now.abs_value_us);
+  gm->ttl = htonl (ttl / 1000LL / 1000LL);
   gm->filter_mutator = htonl (pr->mingle);
   gm->hash_bitmap = htonl (bm);
   gm->query = pr->public_data.query;
@@ -825,12 +825,12 @@ process_reply (void *cls, const struct GNUNET_HashCode * key, void *value)
     update_request_performance_data (prq, pr);
     GNUNET_LOAD_update (GSF_rt_entry_lifetime,
                         GNUNET_TIME_absolute_get_duration (pr->
-                                                           public_data.start_time).rel_value);
+                                                           public_data.start_time).rel_value_us);
     if (GNUNET_YES !=
         GSF_request_plan_reference_get_last_transmission_ (pr->public_data.pr_head, 
                                                            prq->sender, 
                                                            &last_transmission))
-      last_transmission.abs_value = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value;
+      last_transmission.abs_value_us = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
     /* pass on to other peers / local clients */
     pr->rh (pr->rh_cls, prq->eval, pr, prq->anonymity_level, prq->expiration,
             last_transmission, prq->type, prq->data, prq->size);
@@ -891,7 +891,7 @@ process_reply (void *cls, const struct GNUNET_HashCode * key, void *value)
   if (! GSF_request_plan_reference_get_last_transmission_ (pr->public_data.pr_head,
                                                            prq->sender, 
                                                            &last_transmission))
-    last_transmission.abs_value = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value;
+    last_transmission.abs_value_us = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
   pr->rh (pr->rh_cls, prq->eval, pr, 
           prq->anonymity_level, prq->expiration,
           last_transmission, prq->type, prq->data, prq->size);
@@ -947,13 +947,13 @@ put_migration_continuation (void *cls, int success,
     if (GNUNET_SYSERR != success)
     {
       GNUNET_LOAD_update (datastore_put_load, 
-                          GNUNET_TIME_absolute_get_duration (pmc->start).rel_value);
+                          GNUNET_TIME_absolute_get_duration (pmc->start).rel_value_us);
     }
     else
     {
       /* on queue failure / timeout, increase the put load dramatically */
       GNUNET_LOAD_update (datastore_put_load, 
-                          GNUNET_TIME_UNIT_MINUTES.rel_value);
+                          GNUNET_TIME_UNIT_MINUTES.rel_value_us);
     }
   }
   cp = GSF_peer_get_ (&pmc->origin);
@@ -962,7 +962,7 @@ put_migration_continuation (void *cls, int success,
     if (NULL != cp)
     {
       ppd = GSF_get_peer_performance_data_ (cp);
-      ppd->migration_delay.rel_value /= 2;
+      ppd->migration_delay.rel_value_us /= 2;
     }
     GNUNET_free (pmc);
     return;
@@ -972,7 +972,7 @@ put_migration_continuation (void *cls, int success,
        (NULL != cp) )
   {
     ppd = GSF_get_peer_performance_data_ (cp);
-    if (min_expiration.abs_value > 0)
+    if (min_expiration.abs_value_us > 0)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                   "Asking to stop migration for %s because datastore is full\n",
@@ -985,8 +985,8 @@ put_migration_continuation (void *cls, int success,
                                                        ppd->migration_delay);
       ppd->migration_delay = GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_HOURS,
                                                        ppd->migration_delay);
-      mig_pause.rel_value = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                                      ppd->migration_delay.rel_value);
+      mig_pause.rel_value_us = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                         ppd->migration_delay.rel_value_us);
       ppd->migration_delay = GNUNET_TIME_relative_multiply (ppd->migration_delay, 2);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                   "Replicated content already exists locally, asking to stop migration for %s\n",
@@ -1711,8 +1711,9 @@ GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
                                        (GNUNET_CRYPTO_QUALITY_WEAK,
                                         (unsigned int) (60000 * putl * putl)));
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                "Asking to stop migration for %llu ms because of load %f and events %d/%d\n",
-                (unsigned long long) block_time.rel_value,
+                "Asking to stop migration for %s because of load %f and events %d/%d\n",
+                GNUNET_STRINGS_relative_time_to_string (block_time,
+                                                        GNUNET_YES),
                 putl,
                 active_to_migration,
                 (GNUNET_NO == prq.request_found));
diff --git a/src/fs/gnunet-service-fs_push.c b/src/fs/gnunet-service-fs_push.c
index e7fbbdcaf..70c13f49f 100644
--- a/src/fs/gnunet-service-fs_push.c
+++ b/src/fs/gnunet-service-fs_push.c
@@ -482,8 +482,8 @@ process_migration_content (void *cls, const struct GNUNET_HashCode * key, size_t
     consider_gathering ();
     return;
   }
-  if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value <
-      MIN_MIGRATION_CONTENT_LIFETIME.rel_value)
+  if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us <
+      MIN_MIGRATION_CONTENT_LIFETIME.rel_value_us)
   {
     /* content will expire soon, don't bother */
     consider_gathering ();
diff --git a/src/fs/perf_gnunet_service_fs_p2p.c b/src/fs/perf_gnunet_service_fs_p2p.c
index 3a6b9fd03..b4b71be4e 100644
--- a/src/fs/perf_gnunet_service_fs_p2p.c
+++ b/src/fs/perf_gnunet_service_fs_p2p.c
@@ -254,11 +254,11 @@ do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   }
 
   del = GNUNET_TIME_absolute_get_duration (start_time);
-  if (del.rel_value == 0)
-    del.rel_value = 1;
+  if (del.rel_value_us == 0)
+    del.rel_value_us = 1;
   fancy =
     GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
-                                    1000LL / del.rel_value);
+                                    1000000LL / del.rel_value_us);
   FPRINTF (stdout, "Download speed was %s/s\n", fancy);
   GNUNET_free (fancy);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n",
diff --git a/src/fs/perf_gnunet_service_fs_p2p_respect.c b/src/fs/perf_gnunet_service_fs_p2p_respect.c
index 35425a253..c5846c8c3 100644
--- a/src/fs/perf_gnunet_service_fs_p2p_respect.c
+++ b/src/fs/perf_gnunet_service_fs_p2p_respect.c
@@ -297,11 +297,11 @@ do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;
   }
   del = GNUNET_TIME_absolute_get_duration (start_time);
-  if (del.rel_value == 0)
-    del.rel_value = 1;
+  if (del.rel_value_us == 0)
+    del.rel_value_us = 1;
   fancy =
     GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
-                                    1000LL / del.rel_value);
+                                    1000000LL / del.rel_value_us);
   FPRINTF (stderr, "Download speed of type `%s' was %s/s\n", type, fancy);
   GNUNET_free (fancy);
   if (NUM_DAEMONS != ++download_counter)
diff --git a/src/fs/test_fs_download.c b/src/fs/test_fs_download.c
index 519923450..c069875cf 100644
--- a/src/fs/test_fs_download.c
+++ b/src/fs/test_fs_download.c
@@ -142,18 +142,18 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
     fprintf (stdout,
              "Publishing complete, %llu kb/s.\n",
-             (unsigned long long) (FILESIZE * 1000LL /
+             (unsigned long long) (FILESIZE * 1000000LL /
                                    (1 +
                                     GNUNET_TIME_absolute_get_duration
-                                    (start).rel_value) / 1024LL));
+                                    (start).rel_value_us) / 1024LL));
     GAUGER ("FS", 
             (GNUNET_YES == indexed) 
             ? "Publishing speed (indexing)"
              : "Publishing speed (insertion)",
-            (unsigned long long) (FILESIZE * 1000LL /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024LL), "kb/s");
+                                   (start).rel_value_us) / 1024LL), "kb/s");
     fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
     start = GNUNET_TIME_absolute_get ();
     download =
@@ -168,18 +168,18 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
   case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
     fprintf (stdout,
              "Download complete,  %llu kb/s.\n",
-             (unsigned long long) (FILESIZE * 1000LL /
+             (unsigned long long) (FILESIZE * 1000000LL /
                                    (1 +
                                     GNUNET_TIME_absolute_get_duration
-                                    (start).rel_value) / 1024LL));
+                                    (start).rel_value_us) / 1024LL));
     GAUGER ("FS",
             (GNUNET_YES == indexed) 
             ? "Local download speed (indexed)"  
             : "Local download speed (inserted)",
-            (unsigned long long) (FILESIZE * 1000LL /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024LL), "kb/s");
+                                   (start).rel_value_us) / 1024LL), "kb/s");
     GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
     break;
   case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index d5883874d..b380fd4af 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -164,10 +164,10 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
     break;
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
     printf ("Publishing complete, %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000LL /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024LL));
+                                   (start).rel_value_us) / 1024LL));
     fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
     start = GNUNET_TIME_absolute_get ();
     GNUNET_assert (download == NULL);
@@ -179,10 +179,10 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
   case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
     consider_restart (event->status);
     printf ("Download complete,  %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000LL /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024LL));
+                                   (start).rel_value_us) / 1024LL));
     GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
     break;
   case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
diff --git a/src/fs/test_fs_list_indexed.c b/src/fs/test_fs_list_indexed.c
index 91dad7ca9..b505e8a18 100644
--- a/src/fs/test_fs_list_indexed.c
+++ b/src/fs/test_fs_list_indexed.c
@@ -95,10 +95,10 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
     ret = event->value.publish.cctx;
     printf ("Publish complete,  %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000 /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024));
+                                   (start).rel_value_us) / 1024));
     if (0 == strcmp ("list_indexed-context-dir", event->value.publish.cctx))
       GNUNET_SCHEDULER_add_continuation (&list_indexed_task, NULL,
                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c
index e51d6e5d4..7ff9c9202 100644
--- a/src/fs/test_fs_publish.c
+++ b/src/fs/test_fs_publish.c
@@ -82,10 +82,10 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
     ret = event->value.publish.cctx;
     printf ("Publish complete,  %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000 /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024));
+                                   (start).rel_value_us) / 1024));
     if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
       GNUNET_SCHEDULER_add_continuation (&abort_publish_task, NULL,
                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
diff --git a/src/fs/test_fs_publish_persistence.c b/src/fs/test_fs_publish_persistence.c
index 577831a28..1dc8c43aa 100644
--- a/src/fs/test_fs_publish_persistence.c
+++ b/src/fs/test_fs_publish_persistence.c
@@ -134,10 +134,10 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
     consider_restart (event->status);
     ret = event->value.publish.cctx;
     printf ("Publish complete,  %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000LL /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024));
+                                   (start).rel_value_us) / 1024));
     if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
       GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
     break;
diff --git a/src/fs/test_fs_unindex.c b/src/fs/test_fs_unindex.c
index 6b89dcad8..033195f0b 100644
--- a/src/fs/test_fs_unindex.c
+++ b/src/fs/test_fs_unindex.c
@@ -92,20 +92,20 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
     break;
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
     printf ("Publishing complete, %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000 /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024));
+                                   (start).rel_value_us) / 1024));
     start = GNUNET_TIME_absolute_get ();
     unindex = GNUNET_FS_unindex_start (fs, fn, "unindex");
     GNUNET_assert (unindex != NULL);
     break;
   case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
     printf ("Unindex complete,  %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000 /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024));
+                                   (start).rel_value_us) / 1024));
     GNUNET_SCHEDULER_add_continuation (&abort_unindex_task, NULL,
                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
     break;
diff --git a/src/fs/test_fs_unindex_persistence.c b/src/fs/test_fs_unindex_persistence.c
index b11748e2a..ef143ecef 100644
--- a/src/fs/test_fs_unindex_persistence.c
+++ b/src/fs/test_fs_unindex_persistence.c
@@ -134,20 +134,20 @@ progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
     break;
   case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
     printf ("Publishing complete, %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000 /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024));
+                                   (start).rel_value_us) / 1024));
     start = GNUNET_TIME_absolute_get ();
     unindex = GNUNET_FS_unindex_start (fs, fn, "unindex");
     GNUNET_assert (unindex != NULL);
     break;
   case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
     printf ("Unindex complete,  %llu kbps.\n",
-            (unsigned long long) (FILESIZE * 1000 /
+            (unsigned long long) (FILESIZE * 1000000LL /
                                   (1 +
                                    GNUNET_TIME_absolute_get_duration
-                                   (start).rel_value) / 1024));
+                                   (start).rel_value_us) / 1024));
     GNUNET_SCHEDULER_add_continuation (&abort_unindex_task, NULL,
                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
     break;
diff --git a/src/fs/test_gnunet_service_fs_migration.c b/src/fs/test_gnunet_service_fs_migration.c
index 138e35c47..58e6374d5 100644
--- a/src/fs/test_gnunet_service_fs_migration.c
+++ b/src/fs/test_gnunet_service_fs_migration.c
@@ -73,11 +73,11 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
   {
     del = GNUNET_TIME_absolute_get_duration (start_time);
-    if (del.rel_value == 0)
-      del.rel_value = 1;
+    if (del.rel_value_us == 0)
+      del.rel_value_us = 1;
     fancy =
         GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
-                                        1000LL / del.rel_value);
+                                        1000000LL / del.rel_value_us);
     FPRINTF (stdout, "Download speed was %s/s\n", fancy);
     GNUNET_free (fancy);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n",
diff --git a/src/fs/test_gnunet_service_fs_p2p.c b/src/fs/test_gnunet_service_fs_p2p.c
index e37a322b8..63f5627c2 100644
--- a/src/fs/test_gnunet_service_fs_p2p.c
+++ b/src/fs/test_gnunet_service_fs_p2p.c
@@ -64,11 +64,11 @@ do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
   {
     del = GNUNET_TIME_absolute_get_duration (start_time);
-    if (del.rel_value == 0)
-      del.rel_value = 1;
+    if (del.rel_value_us == 0)
+      del.rel_value_us = 1;
     fancy =
-        GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
-                                        1000LL / del.rel_value);
+      GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
+                                      1000000LL / del.rel_value_us);
     FPRINTF (stdout, "Download speed was %s/s\n", fancy);
     GNUNET_free (fancy);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished download, shutting down\n",