gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[GNUnet-SVN] r20032 - gnunet/src/fs


From: gnunet
Subject: [GNUnet-SVN] r20032 - gnunet/src/fs
Date: Sun, 26 Feb 2012 15:02:10 +0100

Author: grothoff
Date: 2012-02-26 15:02:09 +0100 (Sun, 26 Feb 2012)
New Revision: 20032

Modified:
   gnunet/src/fs/fs_download.c
   gnunet/src/fs/fs_tree.c
   gnunet/src/fs/fs_unindex.c
   gnunet/src/fs/gnunet-service-fs.c
   gnunet/src/fs/gnunet-service-fs.h
   gnunet/src/fs/gnunet-service-fs_cp.c
   gnunet/src/fs/gnunet-service-fs_indexing.c
   gnunet/src/fs/gnunet-service-fs_lc.c
   gnunet/src/fs/gnunet-service-fs_pe.c
   gnunet/src/fs/gnunet-service-fs_pr.c
   gnunet/src/fs/gnunet-service-fs_push.c
   gnunet/src/fs/gnunet-service-fs_put.c
Log:
-eliminating #if DEBUG checks

Modified: gnunet/src/fs/fs_download.c
===================================================================
--- gnunet/src/fs/fs_download.c 2012-02-26 13:45:30 UTC (rev 20031)
+++ gnunet/src/fs/fs_download.c 2012-02-26 14:02:09 UTC (rev 20032)
@@ -31,7 +31,6 @@
 #include "fs_api.h"
 #include "fs_tree.h"
 
-#define DEBUG_DOWNLOAD GNUNET_EXTRA_LOGGING
 
 /**
  * Determine if the given download (options and meta data) should cause
@@ -240,11 +239,9 @@
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Matching block for `%s' at offset %llu already present, no need 
for download!\n",
               dc->filename, (unsigned long long) dr->offset);
-#endif
   /* already got it! */
   prc.dc = dc;
   prc.data = enc;
@@ -564,10 +561,8 @@
 
   if (type != EXTRACTOR_METATYPE_GNUNET_FULL_DATA)
     return 0;
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found %u bytes of FD!\n",
               (unsigned int) data_len);
-#endif
   if (GNUNET_FS_uri_chk_get_file_size (dc->uri) != data_len)
   {
     GNUNET_break_op (0);
@@ -731,12 +726,10 @@
     GNUNET_break (0);
     return;
   }
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Scheduling download at offset %llu and depth %u for `%s'\n",
               (unsigned long long) dr->offset, dr->depth,
               GNUNET_h2s (&dr->chk.query));
-#endif
   if (GNUNET_NO !=
       GNUNET_CONTAINER_multihashmap_contains_value (dc->active, &dr->chk.query,
                                                     dr))
@@ -882,13 +875,11 @@
   }
 
   temp_name = NULL;
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Triggering recursive download of size %llu with %u bytes MD\n",
               (unsigned long long) GNUNET_FS_uri_chk_get_file_size (uri),
               (unsigned int)
               GNUNET_CONTAINER_meta_data_get_serialized_size (meta));
-#endif
   GNUNET_FS_download_start (dc->h, uri, meta, full_name, temp_name, 0,
                             GNUNET_FS_uri_chk_get_file_size (uri),
                             dc->anonymity, dc->options, NULL, dc);
@@ -945,14 +936,11 @@
   int i;
   struct ContentHashKey *chkarr;
 
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received block `%s' matching pending request at depth %u and 
offset %llu/%llu\n",
               GNUNET_h2s (key), dr->depth, (unsigned long long) dr->offset,
               (unsigned long long) GNUNET_ntohll (dc->uri->data.
                                                   chk.file_length));
-
-#endif
   bs = GNUNET_FS_tree_calculate_block_size (GNUNET_ntohll
                                             (dc->uri->data.chk.file_length),
                                             dr->offset, dr->depth);
@@ -1013,11 +1001,9 @@
                        dc->filename, STRERROR (errno));
       goto signal_error;
     }
-#if DEBUG_DOWNLOAD
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Saving decrypted block to disk at offset %llu\n",
                 (unsigned long long) off);
-#endif
     if ((off != GNUNET_DISK_file_seek (fh, off, GNUNET_DISK_SEEK_SET)))
     {
       GNUNET_asprintf (&dc->emsg,
@@ -1089,12 +1075,10 @@
   if (dc->completed == dc->length)
   {
     /* download completed, signal */
-#if DEBUG_DOWNLOAD
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Download completed, truncating file to desired length %llu\n",
                 (unsigned long long) GNUNET_ntohll (dc->uri->data.
                                                     chk.file_length));
-#endif
     /* truncate file to size (since we store IBlocks at the end) */
     if (dc->filename != NULL)
     {
@@ -1114,11 +1098,9 @@
     return GNUNET_YES;
   }
 
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Triggering downloads of children (this block was at depth %u 
and offset %llu)\n",
               dr->depth, (unsigned long long) dr->offset);
-#endif
   GNUNET_assert (0 == (prc->size % sizeof (struct ContentHashKey)));
   chkarr = (struct ContentHashKey *) pt;
   for (i = (prc->size / sizeof (struct ContentHashKey)) - 1; i >= 0; i--)
@@ -1210,11 +1192,9 @@
   prc.do_store = GNUNET_YES;
   prc.last_transmission = last_transmission;
   GNUNET_CRYPTO_hash (data, size, &prc.query);
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received result for query `%s' from `%s'-service\n",
               GNUNET_h2s (&prc.query), "FS");
-#endif
   GNUNET_CONTAINER_multihashmap_get_multiple (dc->active, &prc.query,
                                               &process_result_with_request,
                                               &prc);
@@ -1278,10 +1258,8 @@
   dc->th = NULL;
   if (NULL == buf)
   {
-#if DEBUG_DOWNLOAD
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Transmitting download request failed, trying to reconnect\n");
-#endif
     try_reconnect (dc);
     return 0;
   }
@@ -1291,11 +1269,9 @@
   while ((NULL != (dr = dc->pending_head)) &&
          (size >= msize + sizeof (struct SearchMessage)))
   {
-#if DEBUG_DOWNLOAD
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Transmitting download request for `%s' to `%s'-service\n",
                 GNUNET_h2s (&dr->chk.query), "FS");
-#endif
     memset (sm, 0, sizeof (struct SearchMessage));
     sm->header.size = htons (sizeof (struct SearchMessage));
     sm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
@@ -1405,10 +1381,8 @@
 
   if (NULL != dc->client)
   {
-#if DEBUG_DOWNLOAD
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Moving all requests back to pending list\n");
-#endif
     if (NULL != dc->th)
     {
       GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
@@ -1422,9 +1396,7 @@
     dc->in_receive = GNUNET_NO;
     dc->client = NULL;
   }
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Will try to reconnect in 1s\n");
-#endif
   dc->task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &do_reconnect,
                                     dc);
@@ -1443,9 +1415,7 @@
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download activated\n");
-#endif
   GNUNET_assert (NULL != client);
   GNUNET_assert (dc->client == NULL);
   GNUNET_assert (dc->th == NULL);
@@ -1455,10 +1425,8 @@
   dc->pending_head = NULL;
   dc->pending_tail = NULL;
   GNUNET_CONTAINER_multihashmap_iterate (dc->active, &retry_entry, dc);
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asking for transmission to FS service\n");
-#endif
   if (dc->pending_head != NULL)
   {
     dc->th =
@@ -1483,9 +1451,7 @@
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download deactivated\n");
-#endif
   if (NULL != dc->th)
   {
     GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
@@ -1705,12 +1671,10 @@
       if (dc->completed == dc->length)
       {
        /* download completed, signal */
-#if DEBUG_DOWNLOAD
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Download completed, truncating file to desired length 
%llu\n",
                    (unsigned long long) GNUNET_ntohll (dc->uri->data.
                                                        chk.file_length));
-#endif
        /* truncate file to size (since we store IBlocks at the end) */
        if (dc->filename != NULL)
        {
@@ -1792,9 +1756,7 @@
   struct GNUNET_FS_ProgressInfo pi;
   struct GNUNET_DISK_FileHandle *fh;
 
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start task running...\n");
-#endif
   dc->task = GNUNET_SCHEDULER_NO_TASK;
   if (dc->length == 0)
   {
@@ -1850,10 +1812,8 @@
     if (dc->rfh != NULL)
     {
       /* first, try top-down */
-#if DEBUG_DOWNLOAD
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Trying top-down reconstruction for `%s'\n", dc->filename);
-#endif
       try_top_down_reconstruction (dc, dc->top_request);
       switch (dc->top_request->state)
       {
@@ -1888,13 +1848,11 @@
   if ((GNUNET_FS_uri_chk_get_file_size (dc->uri) <= MAX_INLINE_SIZE) &&
       (NULL != dc->meta))
   {
-#if DEBUG_DOWNLOAD
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Trying to find embedded meta data for download of size %llu 
with %u bytes MD\n",
                 (unsigned long long) GNUNET_FS_uri_chk_get_file_size (dc->uri),
                 (unsigned int)
                 GNUNET_CONTAINER_meta_data_get_serialized_size (dc->meta));
-#endif
     GNUNET_CONTAINER_meta_data_iterate (dc->meta, &match_full_data, dc);
     if (dc->top_request->state == BRS_DOWNLOAD_UP)
     {
@@ -1911,10 +1869,8 @@
   if (dc->rfh != NULL)
   {
     /* finally, try bottom-up */
-#if DEBUG_DOWNLOAD
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Trying bottom-up reconstruction of file `%s'\n", 
dc->filename);
-#endif
     dc->te =
         GNUNET_FS_tree_encoder_create (dc->h, dc->old_file_size, dc, 
&fh_reader,
                                        &reconstruct_cb, NULL,
@@ -2041,10 +1997,8 @@
     GNUNET_break (0);
     return NULL;
   }
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting download `%s' of %llu 
bytes\n",
               filename, (unsigned long long) length);
-#endif
   dc = GNUNET_malloc (sizeof (struct GNUNET_FS_DownloadContext));
   dc->h = h;
   dc->parent = parent;
@@ -2081,10 +2035,8 @@
       dc->temp_filename = GNUNET_DISK_mktemp ("gnunet-directory-download-tmp");
   }
 
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download tree has depth %u\n",
               dc->treedepth);
-#endif
   if (parent == NULL)
   {
     dc->top =
@@ -2153,10 +2105,8 @@
     GNUNET_break (0);
     return NULL;
   }
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting download `%s' of %llu 
bytes\n",
               filename, (unsigned long long) length);
-#endif
   dc = GNUNET_malloc (sizeof (struct GNUNET_FS_DownloadContext));
   dc->h = h;
   dc->search = sr;
@@ -2195,10 +2145,8 @@
       dc->temp_filename = GNUNET_DISK_mktemp ("gnunet-directory-download-tmp");
   }
 
-#if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download tree has depth %u\n",
               dc->treedepth);
-#endif
   dc->task = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, dc);
   return dc;
 }

Modified: gnunet/src/fs/fs_tree.c
===================================================================
--- gnunet/src/fs/fs_tree.c     2012-02-26 13:45:30 UTC (rev 20031)
+++ gnunet/src/fs/fs_tree.c     2012-02-26 14:02:09 UTC (rev 20032)
@@ -27,7 +27,6 @@
 #include "platform.h"
 #include "fs_tree.h"
 
-#define DEBUG_TREE GNUNET_EXTRA_LOGGING
 
 /**
  * Context for an ECRS-based file encoder that computes
@@ -341,10 +340,8 @@
   if (te->chk_tree_depth == te->current_depth)
   {
     off = CHK_PER_INODE * (te->chk_tree_depth - 1);
-#if DEBUG_TREE
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TE done, reading CHK `%s' from %u\n",
                 GNUNET_h2s (&te->chk_tree[off].query), off);
-#endif
     te->uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
     te->uri->type = chk;
     te->uri->data.chk.chk = te->chk_tree[off];
@@ -374,23 +371,19 @@
     pt_block = &te->chk_tree[(te->current_depth - 1) * CHK_PER_INODE];
   }
   off = compute_chk_offset (te->current_depth, te->publish_offset);
-#if DEBUG_TREE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "TE is at offset %llu and depth %u with block size %u and 
target-CHK-offset %u\n",
               (unsigned long long) te->publish_offset, te->current_depth,
               (unsigned int) pt_size, (unsigned int) off);
-#endif
   mychk = &te->chk_tree[te->current_depth * CHK_PER_INODE + off];
   GNUNET_CRYPTO_hash (pt_block, pt_size, &mychk->key);
   GNUNET_CRYPTO_hash_to_aes_key (&mychk->key, &sk, &iv);
   GNUNET_CRYPTO_aes_encrypt (pt_block, pt_size, &sk, &iv, enc);
   GNUNET_CRYPTO_hash (enc, pt_size, &mychk->query);
-#if DEBUG_TREE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "TE calculates query to be `%s', stored at %u\n",
               GNUNET_h2s (&mychk->query),
               te->current_depth * CHK_PER_INODE + off);
-#endif
   if (NULL != te->proc)
     te->proc (te->cls, mychk, te->publish_offset, te->current_depth,
               (0 ==

Modified: gnunet/src/fs/fs_unindex.c
===================================================================
--- gnunet/src/fs/fs_unindex.c  2012-02-26 13:45:30 UTC (rev 20031)
+++ gnunet/src/fs/fs_unindex.c  2012-02-26 14:02:09 UTC (rev 20032)
@@ -31,7 +31,6 @@
 #include "fs_api.h"
 #include "fs_tree.h"
 
-#define DEBUG_UNINDEX GNUNET_EXTRA_LOGGING
 
 /**
  * Function called by the tree encoder to obtain
@@ -158,10 +157,8 @@
     signal_unindex_error (uc);
     return;
   }
-#if DEBUG_UNINDEX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Datastore REMOVE operation succeeded\n");
-#endif
   GNUNET_FS_tree_encoder_next (uc->tc);
 }
 
@@ -202,10 +199,8 @@
     odb.file_id = uc->file_id;
     data = &odb;
   }
-#if DEBUG_UNINDEX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending REMOVE request to DATASTORE service\n");
-#endif
   GNUNET_DATASTORE_remove (uc->dsh, &chk->query, size, data, -2, 1,
                            GNUNET_CONSTANTS_SERVICE_TIMEOUT, &process_cont, 
uc);
 }
@@ -299,10 +294,8 @@
     signal_unindex_error (uc);
     return;
   }
-#if DEBUG_UNINDEX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending UNINDEX message to FS service\n");
-#endif
   req.header.size = htons (sizeof (struct UnindexMessage));
   req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_UNINDEX);
   req.reserved = 0;

Modified: gnunet/src/fs/gnunet-service-fs.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs.c   2012-02-26 13:45:30 UTC (rev 20031)
+++ gnunet/src/fs/gnunet-service-fs.c   2012-02-26 14:02:09 UTC (rev 20032)
@@ -373,11 +373,9 @@
   struct GSF_PendingRequestData *prd;
 
   prd = GSF_pending_request_get_data_ (pr);
-#if DEBUG_FS_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Finished database lookup for local request `%s' with result 
%d\n",
               GNUNET_h2s (&prd->query), result);
-#endif
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
     return;                     /* we're done, 'pr' was already destroyed... */

Modified: gnunet/src/fs/gnunet-service-fs.h
===================================================================
--- gnunet/src/fs/gnunet-service-fs.h   2012-02-26 13:45:30 UTC (rev 20031)
+++ gnunet/src/fs/gnunet-service-fs.h   2012-02-26 14:02:09 UTC (rev 20032)
@@ -33,10 +33,7 @@
 #include "gnunet_block_lib.h"
 #include "fs.h"
 
-#define DEBUG_FS GNUNET_YES
 
-#define DEBUG_FS_CLIENT GNUNET_EXTRA_LOGGING
-
 /**
  * By which amount do we decrement the TTL for simple forwarding /
  * indirection of the query; in milli-seconds.  Set somewhat in

Modified: gnunet/src/fs/gnunet-service-fs_cp.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_cp.c        2012-02-26 13:45:30 UTC (rev 
20031)
+++ gnunet/src/fs/gnunet-service-fs_cp.c        2012-02-26 14:02:09 UTC (rev 
20032)
@@ -912,11 +912,9 @@
                                 1, GNUNET_NO);
     return;
   }
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Transmitting result for query `%s' to peer\n",
               GNUNET_h2s (&prd->query));
-#endif
   GNUNET_STATISTICS_update (GSF_stats,
                             gettext_noop ("# replies received for other 
peers"),
                             1, GNUNET_NO);
@@ -1194,7 +1192,6 @@
     cp = cps;
   if (cp == NULL)
   {
-#if DEBUG_FS
     if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Failed to find RETURN-TO peer `%4s' in connection set. 
Dropping query.\n",
@@ -1205,7 +1202,6 @@
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Failed to find peer `%4s' in connection set. Dropping 
query.\n",
                   GNUNET_i2s (other));
-#endif
     GNUNET_STATISTICS_update (GSF_stats,
                               gettext_noop
                               ("# requests dropped due to missing reverse 
route"),
@@ -1218,19 +1214,15 @@
   priority = bound_priority (ntohl (gm->priority), cps);
   if (priority < 0)
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Dropping query from `%s', this peer is too busy.\n",
                 GNUNET_i2s (other));
-#endif
     return NULL;
   }
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received request for `%s' of type %u from peer `%4s' with flags 
%u\n",
               GNUNET_h2s (&gm->query), (unsigned int) type, GNUNET_i2s (other),
               (unsigned int) bm);
-#endif
   namespace = (0 != (bm & GET_MESSAGE_BIT_SKS_NAMESPACE)) ? &opt[bits++] : 
NULL;
   if ((type == GNUNET_BLOCK_TYPE_FS_SBLOCK) && (namespace == NULL))
   {
@@ -1267,11 +1259,9 @@
                                                     TTL_DECREMENT);
   if ((ttl < 0) && (((int32_t) (ttl - ttl_decrement)) > 0))
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
                 GNUNET_i2s (other), ttl, ttl_decrement);
-#endif
     GNUNET_STATISTICS_update (GSF_stats,
                               gettext_noop
                               ("# requests dropped due TTL underflow"), 1,
@@ -1295,11 +1285,9 @@
       {
         /* existing request has higher TTL, drop new one! */
         prd->priority += priority;
-#if DEBUG_FS
         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                     "Have existing request with higher TTL, dropping new 
request.\n",
                     GNUNET_i2s (other));
-#endif
         GNUNET_STATISTICS_update (GSF_stats,
                                   gettext_noop
                                   ("# requests dropped due to higher-TTL 
request"),
@@ -1352,10 +1340,8 @@
   struct GSF_PeerTransmitHandle *pth = cls;
   struct GSF_ConnectedPeer *cp;
 
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Timeout trying to transmit to other peer\n");
-#endif
   pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   cp = pth->cp;
   GNUNET_CONTAINER_DLL_remove (cp->pth_head, cp->pth_tail, pth);
@@ -1717,19 +1703,15 @@
 {
   if (cp->last_migration_block.abs_value > block_time.abs_value)
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Migration already blocked for another %llu ms\n",
                 (unsigned long long)
                 GNUNET_TIME_absolute_get_remaining
                 (cp->last_migration_block).rel_value);
-#endif
     return;                     /* already blocked */
   }
-#if DEBUG_FS
   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);
-#endif
   cp->last_migration_block = block_time;
   if (cp->migration_pth != NULL)
     GSF_peer_transmit_cancel_ (cp->migration_pth);

Modified: gnunet/src/fs/gnunet-service-fs_indexing.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_indexing.c  2012-02-26 13:45:30 UTC (rev 
20031)
+++ gnunet/src/fs/gnunet-service-fs_indexing.c  2012-02-26 14:02:09 UTC (rev 
20032)
@@ -265,10 +265,8 @@
                 _
                 ("Hash mismatch trying to index file `%s' which has hash 
`%s'\n"),
                 ii->filename, GNUNET_h2s (res));
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Wanted `%s'\n",
                 GNUNET_h2s (&ii->file_id));
-#endif
     GNUNET_SERVER_transmit_context_append_data (ii->tc, NULL, 0,
                                                 
GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
     GNUNET_SERVER_transmit_context_run (ii->tc, GNUNET_TIME_UNIT_MINUTES);
@@ -329,11 +327,8 @@
   ii->filename = (const char *) &ii[1];
   memcpy (&ii[1], fn, slen);
   ii->file_id = ism->file_id;
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message for file `%s'\n",
               "START_INDEX", ii->filename);
-#endif
-
   ii->tc = GNUNET_SERVER_transmit_context_create (client);
   mydev = 0;
   myino = 0;
@@ -346,12 +341,10 @@
     GNUNET_free (fn);
     return;
   }
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Mismatch in file identifiers (%llu != %llu or %u != %u), need 
to hash.\n",
               (unsigned long long) ino, (unsigned long long) myino,
               (unsigned int) dev, (unsigned int) mydev);
-#endif
   /* slow validation, need to hash full file (again) */
   ii->fhc =
       GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE, fn,
@@ -457,11 +450,9 @@
     }
     pos = next;
   }
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Client requested unindexing of file `%s': %s\n",
               GNUNET_h2s (&um->file_id), found ? "found" : "not found");
-#endif
   if (GNUNET_YES == found)
     write_index_list ();
   tc = GNUNET_SERVER_transmit_context_create (client);
@@ -583,10 +574,8 @@
                              GNUNET_TIME_UNIT_FOREVER_REL, &remove_cont, NULL);
     return GNUNET_SYSERR;
   }
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "On-demand encoded block for query `%s'\n", GNUNET_h2s (key));
-#endif
   cont (cont_cls, key, nsize, edata, GNUNET_BLOCK_TYPE_FS_DBLOCK, priority,
         anonymity, expiration, uid);
   return GNUNET_OK;

Modified: gnunet/src/fs/gnunet-service-fs_lc.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_lc.c        2012-02-26 13:45:30 UTC (rev 
20031)
+++ gnunet/src/fs/gnunet-service-fs_lc.c        2012-02-26 14:02:09 UTC (rev 
20032)
@@ -270,11 +270,9 @@
     memcpy (&pm[1], data, data_len);
     GSF_local_client_transmit_ (lc, &pm->header);
   }
-#if DEBUG_FS_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Queued reply to query `%s' for local client\n",
               GNUNET_h2s (&prd->query), (unsigned int) prd->type);
-#endif
   if (eval != GNUNET_BLOCK_EVALUATION_OK_LAST)
     return;
   if (GNUNET_SCHEDULER_NO_TASK != cr->kill_task)
@@ -325,11 +323,9 @@
   sc = (msize - sizeof (struct SearchMessage)) / sizeof (GNUNET_HashCode);
   sm = (const struct SearchMessage *) message;
   type = ntohl (sm->type);
-#if DEBUG_FS_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received request for `%s' of type %u from local client\n",
               GNUNET_h2s (&sm->query), (unsigned int) type);
-#endif
   lc = GSF_local_client_lookup_ (client);
   cr = NULL;
   /* detect duplicate KBLOCK requests */
@@ -352,10 +348,8 @@
   }
   if (cr != NULL)
   {
-#if DEBUG_FS_CLIENT
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Have existing request, merging content-seen lists.\n");
-#endif
     GSF_pending_request_update_ (cr->pr, (const GNUNET_HashCode *) &sm[1], sc);
     GNUNET_STATISTICS_update (GSF_stats,
                               gettext_noop

Modified: gnunet/src/fs/gnunet-service-fs_pe.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_pe.c        2012-02-26 13:45:30 UTC (rev 
20031)
+++ gnunet/src/fs/gnunet-service-fs_pe.c        2012-02-26 14:02:09 UTC (rev 
20032)
@@ -318,12 +318,9 @@
               (unsigned int) rp->transmission_counter,
               (unsigned long long) delay.rel_value);
   rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Earliest (re)transmission for `%s' in %us\n",
               GNUNET_h2s (&prd->query), rp->transmission_counter);
-#endif
-
   GNUNET_assert (rp->hn == NULL);
   if (GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value
       == 0)
@@ -414,11 +411,9 @@
   rp->last_transmission = GNUNET_TIME_absolute_get ();
   rp->transmission_counter++;
   total_delay++;
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Executing plan %p executed %u times, planning retransmission\n",
               rp, rp->transmission_counter);
-#endif
   plan (pp, rp);
   GNUNET_STATISTICS_update (GSF_stats,
                             gettext_noop
@@ -463,18 +458,14 @@
     rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap);
     if (NULL == rp)
     {
-#if DEBUG_FS
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No active requests for plan %p.\n",
                   pp);
-#endif
       return;                   /* both queues empty */
     }
     delay = GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission);
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Sleeping for %llu ms before retrying requests on plan %p.\n",
                 (unsigned long long) delay.rel_value, pp);
-#endif
     GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# delay heap timeout"),
                            delay.rel_value, GNUNET_NO);
 
@@ -486,9 +477,7 @@
                             1, GNUNET_NO);
   /* process from priority heap */
   rp = GNUNET_CONTAINER_heap_peek (pp->priority_heap);
-#if DEBUG_FS > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing query plan %p\n", rp);
-#endif
   GNUNET_assert (NULL != rp);
   msize = GSF_pending_request_get_message_ (get_latest (rp), 0, NULL);
   pp->pth =
@@ -608,11 +597,9 @@
   GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# query plan entries"), 
1,
                             GNUNET_NO);
   prd = GSF_pending_request_get_data_ (pr);
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Planning transmission of query `%s' to peer `%s'\n",
               GNUNET_h2s (&prd->query), GNUNET_i2s (&id));
-#endif
   rp = GNUNET_malloc (sizeof (struct GSF_RequestPlan));
   rpr = GNUNET_malloc (sizeof (struct GSF_RequestPlanReference));
   prl = GNUNET_malloc (sizeof (struct PendingRequestList));

Modified: gnunet/src/fs/gnunet-service-fs_pr.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_pr.c        2012-02-26 13:45:30 UTC (rev 
20031)
+++ gnunet/src/fs/gnunet-service-fs_pr.c        2012-02-26 14:02:09 UTC (rev 
20032)
@@ -278,11 +278,9 @@
   struct GSF_PendingRequest *pr;
   struct GSF_PendingRequest *dpr;
 
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Creating request handle for `%s' of type %d\n",
               GNUNET_h2s (query), type);
-#endif
   GNUNET_STATISTICS_update (GSF_stats,
                             gettext_noop ("# Pending requests created"), 1,
                             GNUNET_NO);
@@ -489,12 +487,10 @@
   int64_t ttl;
   int do_route;
 
-#if DEBUG_FS
   if (buf_size > 0)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Building request message for `%s' of type %d\n",
                 GNUNET_h2s (&pr->public_data.query), pr->public_data.type);
-#endif
   k = 0;
   bm = 0;
   do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY));
@@ -574,10 +570,8 @@
   struct GSF_PendingRequest *pr = value;
   GSF_LocalLookupContinuation cont;
 
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Cleaning up pending request for `%s'.\n", GNUNET_h2s (key));
-#endif
   if (NULL != (cont = pr->llc_cont))
   {
     pr->llc_cont = NULL;
@@ -778,11 +772,9 @@
 
   if (NULL == pr->rh)
     return GNUNET_YES;
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Matched result (type %u) for query `%s' with pending request\n",
               (unsigned int) prq->type, GNUNET_h2s (key));
-#endif
   GNUNET_STATISTICS_update (GSF_stats,
                             gettext_noop ("# replies received and matched"), 1,
                             GNUNET_NO);
@@ -815,10 +807,8 @@
                               gettext_noop
                               ("# duplicate replies discarded (bloomfilter)"),
                               1, GNUNET_NO);
-#if DEBUG_FS && 0
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Duplicate response `%s', discarding.\n", GNUNET_h2s (&mhash));
-#endif
+                "Duplicate response, discarding.\n");
     return GNUNET_YES;          /* duplicate */
   case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
     return GNUNET_YES;          /* wrong namespace */
@@ -838,11 +828,9 @@
   GSF_pending_request_update_ (pr, &chash, 1);
   if (NULL == prq->sender)
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Found result for query `%s' in local datastore\n",
                 GNUNET_h2s (key));
-#endif
     GNUNET_STATISTICS_update (GSF_stats,
                               gettext_noop ("# results found locally"), 1,
                               GNUNET_NO);
@@ -940,11 +928,9 @@
     ppd = GSF_get_peer_performance_data_ (cp);
     if (min_expiration.abs_value > 0)
     {
-#if DEBUG_FS
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                  "Asking to stop migration for %llu ms because datastore is 
full\n",
                  (unsigned long long) GNUNET_TIME_absolute_get_remaining 
(min_expiration).rel_value);
-#endif
       GSF_block_peer_migration_ (cp, min_expiration);      
     }
     else
@@ -956,11 +942,9 @@
       mig_pause.rel_value = GNUNET_CRYPTO_random_u64 
(GNUNET_CRYPTO_QUALITY_WEAK,
                                                      
ppd->migration_delay.rel_value);
       ppd->migration_delay = GNUNET_TIME_relative_multiply 
(ppd->migration_delay, 2);
-#if DEBUG_FS
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                  "Replicated content already exists locally, asking to stop 
migration for %llu ms\n",
                  (unsigned long long) mig_pause.rel_value);
-#endif
       GSF_block_peer_migration_ (cp, GNUNET_TIME_relative_to_absolute 
(mig_pause));
     }
   }
@@ -1042,11 +1026,9 @@
   if ((GNUNET_YES == active_to_migration) &&
       (GNUNET_NO == test_put_load_too_high (prq.priority)))
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Replicating result for query `%s' with priority %u\n",
                 GNUNET_h2s (key), prq.priority);
-#endif
     pmc = GNUNET_malloc (sizeof (struct PutMigrationContext));
     pmc->start = GNUNET_TIME_absolute_get ();
     pmc->requested = GNUNET_YES;
@@ -1220,10 +1202,8 @@
   }
   if (NULL == key)
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
                 "No further local responses available.\n");
-#endif
     if ((pr->public_data.type == GNUNET_BLOCK_TYPE_FS_DBLOCK) ||
         (pr->public_data.type == GNUNET_BLOCK_TYPE_FS_IBLOCK))
       GNUNET_STATISTICS_update (GSF_stats,
@@ -1232,17 +1212,13 @@
                                 GNUNET_NO);
     goto check_error_and_continue;
   }
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received reply for `%s' of type %d with UID %llu from 
datastore.\n",
               GNUNET_h2s (key), type, (unsigned long long) uid);
-#endif
   if (type == GNUNET_BLOCK_TYPE_FS_ONDEMAND)
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Found ONDEMAND block, performing on-demand encoding\n");
-#endif
     GNUNET_STATISTICS_update (GSF_stats,
                               gettext_noop
                               ("# on-demand blocks matched requests"), 1,
@@ -1356,9 +1332,7 @@
       ((GNUNET_YES == GSF_test_get_load_too_high_ (0)) ||
        (pr->public_data.results_found > 5 + 2 * pr->public_data.priority)))
   {
-#if DEBUG_FS > 2
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load too high, done with request\n");
-#endif
     GNUNET_STATISTICS_update (GSF_stats,
                               gettext_noop
                               ("# Datastore lookups concluded (load too 
high)"),
@@ -1557,11 +1531,9 @@
   if ((GNUNET_YES == active_to_migration) &&
       (GNUNET_NO == test_put_load_too_high (prq.priority)))
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Replicating result for query `%s' with priority %u\n",
                 GNUNET_h2s (&query), prq.priority);
-#endif
     pmc = GNUNET_malloc (sizeof (struct PutMigrationContext));
     pmc->start = GNUNET_TIME_absolute_get ();
     pmc->requested = prq.request_found;
@@ -1581,12 +1553,10 @@
   }
   else
   {
-#if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Choosing not to keep content `%s' (%d/%d)\n",
                 GNUNET_h2s (&query), active_to_migration,
                 test_put_load_too_high (prq.priority));
-#endif
   }
   putl = GNUNET_LOAD_get_load (datastore_put_load);
   if ((NULL != (cp = prq.sender)) && (GNUNET_NO == prq.request_found) &&
@@ -1601,14 +1571,12 @@
                                        GNUNET_CRYPTO_random_u32
                                        (GNUNET_CRYPTO_QUALITY_WEAK,
                                         (unsigned int) (60000 * putl * putl)));
-#if DEBUG_FS
     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,
                putl,
                active_to_migration,
                (GNUNET_NO == prq.request_found));
-#endif
     GSF_block_peer_migration_ (cp, GNUNET_TIME_relative_to_absolute 
(block_time));
   }
   return GNUNET_OK;

Modified: gnunet/src/fs/gnunet-service-fs_push.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_push.c      2012-02-26 13:45:30 UTC (rev 
20031)
+++ gnunet/src/fs/gnunet-service-fs_push.c      2012-02-26 14:02:09 UTC (rev 
20032)
@@ -31,8 +31,6 @@
 #include "gnunet-service-fs_push.h"
 
 
-#define DEBUG_FS_MIGRATION GNUNET_EXTRA_LOGGING
-
 /**
  * Maximum number of blocks we keep in memory for migration.
  */
@@ -227,10 +225,8 @@
   peer->msg = NULL;
   if (buf == NULL)
   {
-#if DEBUG_FS_MIGRATION
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Failed to migrate content to another peer (disconnect)\n");
-#endif
     GNUNET_free (msg);
     return 0;
   }
@@ -238,10 +234,8 @@
   GNUNET_assert (msize <= buf_size);
   memcpy (buf, msg, msize);
   GNUNET_free (msg);
-#if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Pushing %u bytes to another peer\n",
               msize);
-#endif
   find_content (peer);
   return msize;
 }
@@ -292,10 +286,8 @@
   {
     ret = GNUNET_NO;
   }
-#if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asking for transmission of %u bytes for migration\n", msize);
-#endif
   peer->th = GSF_peer_transmit_ (peer->peer, GNUNET_NO, 0 /* priority */ ,
                                  GNUNET_TIME_UNIT_FOREVER_REL, msize,
                                  &transmit_message, peer);
@@ -390,16 +382,12 @@
   {
     if (mig_size < MAX_MIGRATION_QUEUE)
     {
-#if DEBUG_FS_MIGRATION
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "No content found for pushing, waiting for queue to fill\n");
-#endif
       return;                   /* will fill up eventually... */
     }
-#if DEBUG_FS_MIGRATION
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "No suitable content found, purging content from full 
queue\n");
-#endif
     /* failed to find migration target AND
      * queue is full, purge most-forwarded
      * block from queue to make room for more */
@@ -419,10 +407,8 @@
     consider_gathering ();
     return;
   }
-#if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Preparing to push best content to peer\n");
-#endif
   transmit_content (mrp, best);
 }
 
@@ -459,10 +445,8 @@
   delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, mig_size);
   delay = GNUNET_TIME_relative_divide (delay, MAX_MIGRATION_QUEUE);
   delay = GNUNET_TIME_relative_max (delay, min_migration_delay);
-#if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Scheduling gathering task (queue size: %u)\n", mig_size);
-#endif
   mig_task =
       GNUNET_SCHEDULER_add_delayed (delay, &gather_migration_blocks, NULL);
 }
@@ -494,9 +478,7 @@
   mig_qe = NULL;
   if (key == NULL)
   {
-#if DEBUG_FS_MIGRATION
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No content found for 
migration...\n");
-#endif
     consider_gathering ();
     return;
   }
@@ -516,11 +498,9 @@
       consider_gathering ();
     return;
   }
-#if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Retrieved block `%s' of type %u for migration (queue size: 
%u/%u)\n",
               GNUNET_h2s (key), type, mig_size + 1, MAX_MIGRATION_QUEUE);
-#endif
   mb = GNUNET_malloc (sizeof (struct MigrationReadyBlock) + size);
   mb->query = *key;
   mb->expiration = expiration;
@@ -534,10 +514,8 @@
   {
     if (NULL == pos->th)
     {
-#if DEBUG_FS_MIGRATION
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Preparing to push best content to peer\n");
-#endif
       if (GNUNET_YES == transmit_content (pos, mb))
         break;                  /* 'mb' was freed! */
     }
@@ -563,11 +541,9 @@
     return;
   if (GSF_dsh != NULL)
   {
-#if DEBUG_FS_MIGRATION
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Asking datastore for content for replication (queue size: 
%u)\n",
                 mig_size);
-#endif
     mig_qe =
         GNUNET_DATASTORE_get_for_replication (GSF_dsh, 0, UINT_MAX,
                                               GNUNET_TIME_UNIT_FOREVER_REL,

Modified: gnunet/src/fs/gnunet-service-fs_put.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_put.c       2012-02-26 13:45:30 UTC (rev 
20031)
+++ gnunet/src/fs/gnunet-service-fs_put.c       2012-02-26 14:02:09 UTC (rev 
20032)
@@ -156,11 +156,9 @@
   }
   po->zero_anonymity_count_estimate =
       GNUNET_MAX (po->current_offset, po->zero_anonymity_count_estimate);
-#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Retrieved block `%s' of type %u for DHT PUT\n", GNUNET_h2s 
(key),
               type);
-#endif
   GNUNET_DHT_put (GSF_dht, key, 5 /* DEFAULT_PUT_REPLICATION */ ,
                   GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, type, size, data,
                   expiration, GNUNET_TIME_UNIT_FOREVER_REL,




reply via email to

[Prev in Thread] Current Thread [Next in Thread]