status.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. /* Copyright (c) 2010-2013, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file status.c
  5. * \brief Keep status information and log the heartbeat messages.
  6. **/
  7. #define STATUS_PRIVATE
  8. #include "or.h"
  9. #include "circuituse.h"
  10. #include "config.h"
  11. #include "status.h"
  12. #include "nodelist.h"
  13. #include "relay.h"
  14. #include "router.h"
  15. #include "circuitlist.h"
  16. #include "main.h"
  17. #include "rephist.h"
  18. #include "hibernate.h"
  19. #include "rephist.h"
  20. #include "statefile.h"
  21. static void log_accounting(const time_t now, const or_options_t *options);
  22. /** Return the total number of circuits. */
  23. STATIC int
  24. count_circuits(void)
  25. {
  26. return smartlist_len(circuit_get_global_list());
  27. }
  28. /** Take seconds <b>secs</b> and return a newly allocated human-readable
  29. * uptime string */
  30. STATIC char *
  31. secs_to_uptime(long secs)
  32. {
  33. long int days = secs / 86400;
  34. int hours = (int)((secs - (days * 86400)) / 3600);
  35. int minutes = (int)((secs - (days * 86400) - (hours * 3600)) / 60);
  36. char *uptime_string = NULL;
  37. switch (days) {
  38. case 0:
  39. tor_asprintf(&uptime_string, "%d:%02d hours", hours, minutes);
  40. break;
  41. case 1:
  42. tor_asprintf(&uptime_string, "%ld day %d:%02d hours",
  43. days, hours, minutes);
  44. break;
  45. default:
  46. tor_asprintf(&uptime_string, "%ld days %d:%02d hours",
  47. days, hours, minutes);
  48. break;
  49. }
  50. return uptime_string;
  51. }
  52. /** Take <b>bytes</b> and returns a newly allocated human-readable usage
  53. * string. */
  54. STATIC char *
  55. bytes_to_usage(uint64_t bytes)
  56. {
  57. char *bw_string = NULL;
  58. if (bytes < (1<<20)) { /* Less than a megabyte. */
  59. tor_asprintf(&bw_string, U64_FORMAT" kB", U64_PRINTF_ARG(bytes>>10));
  60. } else if (bytes < (1<<30)) { /* Megabytes. Let's add some precision. */
  61. double bw = U64_TO_DBL(bytes);
  62. tor_asprintf(&bw_string, "%.2f MB", bw/(1<<20));
  63. } else { /* Gigabytes. */
  64. double bw = U64_TO_DBL(bytes);
  65. tor_asprintf(&bw_string, "%.2f GB", bw/(1<<30));
  66. }
  67. return bw_string;
  68. }
  69. /** Log a "heartbeat" message describing Tor's status and history so that the
  70. * user can know that there is indeed a running Tor. Return 0 on success and
  71. * -1 on failure. */
  72. int
  73. log_heartbeat(time_t now)
  74. {
  75. char *bw_sent = NULL;
  76. char *bw_rcvd = NULL;
  77. char *uptime = NULL;
  78. const routerinfo_t *me;
  79. double r = tls_get_write_overhead_ratio();
  80. const int hibernating = we_are_hibernating();
  81. const or_options_t *options = get_options();
  82. (void)now;
  83. if (public_server_mode(options) && !hibernating) {
  84. /* Let's check if we are in the current cached consensus. */
  85. if (!(me = router_get_my_routerinfo()))
  86. return -1; /* Something stinks, we won't even attempt this. */
  87. else
  88. if (!node_get_by_id(me->cache_info.identity_digest))
  89. log_fn(LOG_NOTICE, LD_HEARTBEAT, "Heartbeat: It seems like we are not "
  90. "in the cached consensus.");
  91. }
  92. uptime = secs_to_uptime(get_uptime());
  93. bw_rcvd = bytes_to_usage(get_bytes_read());
  94. bw_sent = bytes_to_usage(get_bytes_written());
  95. log_fn(LOG_NOTICE, LD_HEARTBEAT, "Heartbeat: Tor's uptime is %s, with %d "
  96. "circuits open. I've sent %s and received %s.%s",
  97. uptime, count_circuits(),bw_sent,bw_rcvd,
  98. hibernating?" We are currently hibernating.":"");
  99. if (server_mode(options) && accounting_is_enabled(options) && !hibernating) {
  100. log_accounting(now, options);
  101. }
  102. if (stats_n_data_cells_packaged && !hibernating)
  103. log_notice(LD_HEARTBEAT, "Average packaged cell fullness: %2.3f%%",
  104. 100*(U64_TO_DBL(stats_n_data_bytes_packaged) /
  105. U64_TO_DBL(stats_n_data_cells_packaged*RELAY_PAYLOAD_SIZE)) );
  106. if (r > 1.0) {
  107. double overhead = ( r - 1.0 ) * 100.0;
  108. log_notice(LD_HEARTBEAT, "TLS write overhead: %.f%%", overhead);
  109. }
  110. if (public_server_mode(options))
  111. rep_hist_log_circuit_handshake_stats(now);
  112. circuit_log_ancient_one_hop_circuits(1800);
  113. tor_free(uptime);
  114. tor_free(bw_sent);
  115. tor_free(bw_rcvd);
  116. return 0;
  117. }
  118. static void
  119. log_accounting(const time_t now, const or_options_t *options)
  120. {
  121. or_state_t *state = get_or_state();
  122. char *acc_rcvd = bytes_to_usage(state->AccountingBytesReadInInterval);
  123. char *acc_sent = bytes_to_usage(state->AccountingBytesWrittenInInterval);
  124. char *acc_max = bytes_to_usage(options->AccountingMax);
  125. time_t interval_end = accounting_get_end_time();
  126. char end_buf[ISO_TIME_LEN + 1];
  127. char *remaining = NULL;
  128. format_local_iso_time(end_buf, interval_end);
  129. remaining = secs_to_uptime(interval_end - now);
  130. log_notice(LD_HEARTBEAT, "Heartbeat: Accounting enabled. "
  131. "Sent: %s / %s, Received: %s / %s. The "
  132. "current accounting interval ends on %s, in %s.",
  133. acc_sent, acc_max, acc_rcvd, acc_max, end_buf, remaining);
  134. tor_free(acc_rcvd);
  135. tor_free(acc_sent);
  136. tor_free(acc_max);
  137. tor_free(remaining);
  138. }