1 /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
2 * Copyright (c) 2007-2009, The Tor Project, Inc. */
3 /* See LICENSE for licensing information */
7 * \brief Basic history and "reputation" functionality to remember
8 * which servers have worked in the past, how much bandwidth we've
9 * been using, which ports we tend to want, and so on.
15 static void bw_arrays_init(void);
16 static void predicted_ports_init(void);
17 static void hs_usage_init(void);
19 /** Total number of bytes currently allocated in fields used by rephist.c. */
20 uint64_t rephist_total_alloc
=0;
21 /** Number of or_history_t objects currently allocated. */
22 uint32_t rephist_total_num
=0;
24 /** If the total weighted run count of all runs for a router ever falls
25 * below this amount, the router can be treated as having 0 MTBF. */
26 #define STABILITY_EPSILON 0.0001
27 /** Value by which to discount all old intervals for MTBF purposes. This
28 * is compounded every STABILITY_INTERVAL. */
29 #define STABILITY_ALPHA 0.95
30 /** Interval at which to discount all old intervals for MTBF purposes. */
31 #define STABILITY_INTERVAL (12*60*60)
32 /* (This combination of ALPHA, INTERVAL, and EPSILON makes it so that an
33 * interval that just ended counts twice as much as one that ended a week ago,
34 * 20X as much as one that ended a month ago, and routers that have had no
35 * uptime data for about half a year will get forgotten.) */
37 /** History of an OR-\>OR link. */
38 typedef struct link_history_t
{
39 /** When did we start tracking this list? */
41 /** When did we most recently note a change to this link */
43 /** How many times did extending from OR1 to OR2 succeed? */
44 unsigned long n_extend_ok
;
45 /** How many times did extending from OR1 to OR2 fail? */
46 unsigned long n_extend_fail
;
49 /** History of an OR. */
50 typedef struct or_history_t
{
51 /** When did we start tracking this OR? */
53 /** When did we most recently note a change to this OR? */
55 /** How many times did we successfully connect? */
56 unsigned long n_conn_ok
;
57 /** How many times did we try to connect and fail?*/
58 unsigned long n_conn_fail
;
59 /** How many seconds have we been connected to this OR before
62 /** How many seconds have we been unable to connect to this OR before
64 unsigned long downtime
;
65 /** If nonzero, we have been connected since this time. */
67 /** If nonzero, we have been unable to connect since this time. */
70 /* === For MTBF tracking: */
71 /** Weighted sum total of all times that this router has been online.
73 unsigned long weighted_run_length
;
74 /** If the router is now online (according to stability-checking rules),
75 * when did it come online? */
77 /** Sum of weights for runs in weighted_run_length. */
78 double total_run_weights
;
79 /* === For fractional uptime tracking: */
80 time_t start_of_downtime
;
81 unsigned long weighted_uptime
;
82 unsigned long total_weighted_time
;
84 /** Map from hex OR2 identity digest to a link_history_t for the link
85 * from this OR to OR2. */
86 digestmap_t
*link_history_map
;
89 /** When did we last multiply all routers' weighted_run_length and
90 * total_run_weights by STABILITY_ALPHA? */
91 static time_t stability_last_downrated
= 0;
94 static time_t started_tracking_stability
= 0;
96 /** Map from hex OR identity digest to or_history_t. */
97 static digestmap_t
*history_map
= NULL
;
99 /** Return the or_history_t for the OR with identity digest <b>id</b>,
100 * creating it if necessary. */
101 static or_history_t
*
102 get_or_history(const char* id
)
106 if (tor_mem_is_zero(id
, DIGEST_LEN
))
109 hist
= digestmap_get(history_map
, id
);
111 hist
= tor_malloc_zero(sizeof(or_history_t
));
112 rephist_total_alloc
+= sizeof(or_history_t
);
114 hist
->link_history_map
= digestmap_new();
115 hist
->since
= hist
->changed
= time(NULL
);
116 digestmap_set(history_map
, id
, hist
);
121 /** Return the link_history_t for the link from the first named OR to
122 * the second, creating it if necessary. (ORs are identified by
125 static link_history_t
*
126 get_link_history(const char *from_id
, const char *to_id
)
128 or_history_t
*orhist
;
129 link_history_t
*lhist
;
130 orhist
= get_or_history(from_id
);
133 if (tor_mem_is_zero(to_id
, DIGEST_LEN
))
135 lhist
= (link_history_t
*) digestmap_get(orhist
->link_history_map
, to_id
);
137 lhist
= tor_malloc_zero(sizeof(link_history_t
));
138 rephist_total_alloc
+= sizeof(link_history_t
);
139 lhist
->since
= lhist
->changed
= time(NULL
);
140 digestmap_set(orhist
->link_history_map
, to_id
, lhist
);
145 /** Helper: free storage held by a single link history entry. */
147 _free_link_history(void *val
)
149 rephist_total_alloc
-= sizeof(link_history_t
);
153 /** Helper: free storage held by a single OR history entry. */
155 free_or_history(void *_hist
)
157 or_history_t
*hist
= _hist
;
158 digestmap_free(hist
->link_history_map
, _free_link_history
);
159 rephist_total_alloc
-= sizeof(or_history_t
);
164 /** Update an or_history_t object <b>hist</b> so that its uptime/downtime
165 * count is up-to-date as of <b>when</b>.
168 update_or_history(or_history_t
*hist
, time_t when
)
171 if (hist
->up_since
) {
172 tor_assert(!hist
->down_since
);
173 hist
->uptime
+= (when
- hist
->up_since
);
174 hist
->up_since
= when
;
175 } else if (hist
->down_since
) {
176 hist
->downtime
+= (when
- hist
->down_since
);
177 hist
->down_since
= when
;
181 /** Initialize the static data structures for tracking history. */
185 history_map
= digestmap_new();
187 predicted_ports_init();
191 /** Helper: note that we are no longer connected to the router with history
192 * <b>hist</b>. If <b>failed</b>, the connection failed; otherwise, it was
193 * closed correctly. */
195 mark_or_down(or_history_t
*hist
, time_t when
, int failed
)
197 if (hist
->up_since
) {
198 hist
->uptime
+= (when
- hist
->up_since
);
201 if (failed
&& !hist
->down_since
) {
202 hist
->down_since
= when
;
206 /** Helper: note that we are connected to the router with history
209 mark_or_up(or_history_t
*hist
, time_t when
)
211 if (hist
->down_since
) {
212 hist
->downtime
+= (when
- hist
->down_since
);
213 hist
->down_since
= 0;
215 if (!hist
->up_since
) {
216 hist
->up_since
= when
;
220 /** Remember that an attempt to connect to the OR with identity digest
221 * <b>id</b> failed at <b>when</b>.
224 rep_hist_note_connect_failed(const char* id
, time_t when
)
227 hist
= get_or_history(id
);
231 mark_or_down(hist
, when
, 1);
232 hist
->changed
= when
;
235 /** Remember that an attempt to connect to the OR with identity digest
236 * <b>id</b> succeeded at <b>when</b>.
239 rep_hist_note_connect_succeeded(const char* id
, time_t when
)
242 hist
= get_or_history(id
);
246 mark_or_up(hist
, when
);
247 hist
->changed
= when
;
250 /** Remember that we intentionally closed our connection to the OR
251 * with identity digest <b>id</b> at <b>when</b>.
254 rep_hist_note_disconnect(const char* id
, time_t when
)
257 hist
= get_or_history(id
);
260 mark_or_down(hist
, when
, 0);
261 hist
->changed
= when
;
264 /** Remember that our connection to the OR with identity digest
265 * <b>id</b> had an error and stopped working at <b>when</b>.
268 rep_hist_note_connection_died(const char* id
, time_t when
)
272 /* If conn has no identity, it didn't complete its handshake, or something
273 * went wrong. Ignore it.
277 hist
= get_or_history(id
);
280 mark_or_down(hist
, when
, 1);
281 hist
->changed
= when
;
284 /** We have just decided that this router with identity digest <b>id</b> is
285 * reachable, meaning we will give it a "Running" flag for the next while. */
287 rep_hist_note_router_reachable(const char *id
, time_t when
)
289 or_history_t
*hist
= get_or_history(id
);
291 char tbuf
[ISO_TIME_LEN
+1];
295 if (!started_tracking_stability
)
296 started_tracking_stability
= time(NULL
);
297 if (!hist
->start_of_run
) {
298 hist
->start_of_run
= when
;
301 if (hist
->start_of_downtime
) {
304 format_local_iso_time(tbuf
, hist
->start_of_downtime
);
305 log_info(LD_HIST
, "Router %s is now Running; it had been down since %s.",
306 hex_str(id
, DIGEST_LEN
), tbuf
);
308 log_info(LD_HIST
, " (Paradoxically, it was already Running too.)");
310 down_length
= when
- hist
->start_of_downtime
;
311 hist
->total_weighted_time
+= down_length
;
312 hist
->start_of_downtime
= 0;
314 format_local_iso_time(tbuf
, hist
->start_of_run
);
316 log_debug(LD_HIST
, "Router %s is still Running; it has been Running "
317 "since %s", hex_str(id
, DIGEST_LEN
), tbuf
);
319 log_info(LD_HIST
,"Router %s is now Running; it was previously untracked",
320 hex_str(id
, DIGEST_LEN
));
324 /** We have just decided that this router is unreachable, meaning
325 * we are taking away its "Running" flag. */
327 rep_hist_note_router_unreachable(const char *id
, time_t when
)
329 or_history_t
*hist
= get_or_history(id
);
330 char tbuf
[ISO_TIME_LEN
+1];
332 if (!started_tracking_stability
)
333 started_tracking_stability
= time(NULL
);
336 if (hist
->start_of_run
) {
337 /*XXXX We could treat failed connections differently from failed
338 * connect attempts. */
339 long run_length
= when
- hist
->start_of_run
;
340 format_local_iso_time(tbuf
, hist
->start_of_run
);
342 hist
->weighted_run_length
+= run_length
;
343 hist
->total_run_weights
+= 1.0;
344 hist
->start_of_run
= 0;
345 hist
->weighted_uptime
+= run_length
;
346 hist
->total_weighted_time
+= run_length
;
349 log_info(LD_HIST
, "Router %s is now non-Running: it had previously been "
350 "Running since %s. Its total weighted uptime is %lu/%lu.",
351 hex_str(id
, DIGEST_LEN
), tbuf
, hist
->weighted_uptime
,
352 hist
->total_weighted_time
);
354 if (!hist
->start_of_downtime
) {
355 hist
->start_of_downtime
= when
;
358 log_info(LD_HIST
, "Router %s is now non-Running; it was previously "
359 "untracked.", hex_str(id
, DIGEST_LEN
));
362 format_local_iso_time(tbuf
, hist
->start_of_downtime
);
364 log_info(LD_HIST
, "Router %s is still non-Running; it has been "
365 "non-Running since %s.", hex_str(id
, DIGEST_LEN
), tbuf
);
370 /** Helper: Discount all old MTBF data, if it is time to do so. Return
371 * the time at which we should next discount MTBF data. */
373 rep_hist_downrate_old_runs(time_t now
)
375 digestmap_iter_t
*orhist_it
;
382 history_map
= digestmap_new();
383 if (!stability_last_downrated
)
384 stability_last_downrated
= now
;
385 if (stability_last_downrated
+ STABILITY_INTERVAL
> now
)
386 return stability_last_downrated
+ STABILITY_INTERVAL
;
388 /* Okay, we should downrate the data. By how much? */
389 while (stability_last_downrated
+ STABILITY_INTERVAL
< now
) {
390 stability_last_downrated
+= STABILITY_INTERVAL
;
391 alpha
*= STABILITY_ALPHA
;
394 log_info(LD_HIST
, "Discounting all old stability info by a factor of %lf",
397 /* Multiply every w_r_l, t_r_w pair by alpha. */
398 for (orhist_it
= digestmap_iter_init(history_map
);
399 !digestmap_iter_done(orhist_it
);
400 orhist_it
= digestmap_iter_next(history_map
,orhist_it
)) {
401 digestmap_iter_get(orhist_it
, &digest1
, &hist_p
);
404 hist
->weighted_run_length
=
405 (unsigned long)(hist
->weighted_run_length
* alpha
);
406 hist
->total_run_weights
*= alpha
;
408 hist
->weighted_uptime
= (unsigned long)(hist
->weighted_uptime
* alpha
);
409 hist
->total_weighted_time
= (unsigned long)
410 (hist
->total_weighted_time
* alpha
);
413 return stability_last_downrated
+ STABILITY_INTERVAL
;
416 /** Helper: Return the weighted MTBF of the router with history <b>hist</b>. */
418 get_stability(or_history_t
*hist
, time_t when
)
420 unsigned long total
= hist
->weighted_run_length
;
421 double total_weights
= hist
->total_run_weights
;
423 if (hist
->start_of_run
) {
424 /* We're currently in a run. Let total and total_weights hold the values
425 * they would hold if the current run were to end now. */
426 total
+= (when
-hist
->start_of_run
);
427 total_weights
+= 1.0;
429 if (total_weights
< STABILITY_EPSILON
) {
430 /* Round down to zero, and avoid divide-by-zero. */
434 return total
/ total_weights
;
437 /** Return the total amount of time we've been observing, with each run of
438 * time downrated by the appropriate factor. */
440 get_total_weighted_time(or_history_t
*hist
, time_t when
)
442 long total
= hist
->total_weighted_time
;
443 if (hist
->start_of_run
) {
444 total
+= (when
- hist
->start_of_run
);
445 } else if (hist
->start_of_downtime
) {
446 total
+= (when
- hist
->start_of_downtime
);
451 /** Helper: Return the weighted percent-of-time-online of the router with
452 * history <b>hist</b>. */
454 get_weighted_fractional_uptime(or_history_t
*hist
, time_t when
)
456 unsigned long total
= hist
->total_weighted_time
;
457 unsigned long up
= hist
->weighted_uptime
;
459 if (hist
->start_of_run
) {
460 long run_length
= (when
- hist
->start_of_run
);
463 } else if (hist
->start_of_downtime
) {
464 total
+= (when
- hist
->start_of_downtime
);
468 /* Avoid calling anybody's uptime infinity (which should be impossible if
469 * the code is working), or NaN (which can happen for any router we haven't
470 * observed up or down yet). */
474 return ((double) up
) / total
;
477 /** Return an estimated MTBF for the router whose identity digest is
478 * <b>id</b>. Return 0 if the router is unknown. */
480 rep_hist_get_stability(const char *id
, time_t when
)
482 or_history_t
*hist
= get_or_history(id
);
486 return get_stability(hist
, when
);
489 /** Return an estimated percent-of-time-online for the router whose identity
490 * digest is <b>id</b>. Return 0 if the router is unknown. */
492 rep_hist_get_weighted_fractional_uptime(const char *id
, time_t when
)
494 or_history_t
*hist
= get_or_history(id
);
498 return get_weighted_fractional_uptime(hist
, when
);
501 /** Return a number representing how long we've known about the router whose
502 * digest is <b>id</b>. Return 0 if the router is unknown.
504 * Be careful: this measure increases monotonically as we know the router for
505 * longer and longer, but it doesn't increase linearly.
508 rep_hist_get_weighted_time_known(const char *id
, time_t when
)
510 or_history_t
*hist
= get_or_history(id
);
514 return get_total_weighted_time(hist
, when
);
517 /** Return true if we've been measuring MTBFs for long enough to
518 * pronounce on Stability. */
520 rep_hist_have_measured_enough_stability(void)
522 /* XXXX021 This doesn't do so well when we change our opinion
523 * as to whether we're tracking router stability. */
524 return started_tracking_stability
< time(NULL
) - 4*60*60;
527 /** Remember that we successfully extended from the OR with identity
528 * digest <b>from_id</b> to the OR with identity digest
532 rep_hist_note_extend_succeeded(const char *from_id
, const char *to_id
)
534 link_history_t
*hist
;
535 /* log_fn(LOG_WARN, "EXTEND SUCCEEDED: %s->%s",from_name,to_name); */
536 hist
= get_link_history(from_id
, to_id
);
540 hist
->changed
= time(NULL
);
543 /** Remember that we tried to extend from the OR with identity digest
544 * <b>from_id</b> to the OR with identity digest <b>to_name</b>, but
548 rep_hist_note_extend_failed(const char *from_id
, const char *to_id
)
550 link_history_t
*hist
;
551 /* log_fn(LOG_WARN, "EXTEND FAILED: %s->%s",from_name,to_name); */
552 hist
= get_link_history(from_id
, to_id
);
555 ++hist
->n_extend_fail
;
556 hist
->changed
= time(NULL
);
559 /** Log all the reliability data we have remembered, with the chosen
563 rep_hist_dump_stats(time_t now
, int severity
)
565 digestmap_iter_t
*lhist_it
;
566 digestmap_iter_t
*orhist_it
;
567 const char *name1
, *name2
, *digest1
, *digest2
;
568 char hexdigest1
[HEX_DIGEST_LEN
+1];
569 or_history_t
*or_history
;
570 link_history_t
*link_history
;
571 void *or_history_p
, *link_history_p
;
576 unsigned long upt
, downt
;
579 rep_history_clean(now
- get_options()->RephistTrackTime
);
581 log(severity
, LD_HIST
, "--------------- Dumping history information:");
583 for (orhist_it
= digestmap_iter_init(history_map
);
584 !digestmap_iter_done(orhist_it
);
585 orhist_it
= digestmap_iter_next(history_map
,orhist_it
)) {
588 digestmap_iter_get(orhist_it
, &digest1
, &or_history_p
);
589 or_history
= (or_history_t
*) or_history_p
;
591 if ((r
= router_get_by_digest(digest1
)))
595 base16_encode(hexdigest1
, sizeof(hexdigest1
), digest1
, DIGEST_LEN
);
596 update_or_history(or_history
, now
);
597 upt
= or_history
->uptime
;
598 downt
= or_history
->downtime
;
599 s
= get_stability(or_history
, now
);
602 uptime
= ((double)upt
) / (upt
+downt
);
606 log(severity
, LD_HIST
,
607 "OR %s [%s]: %ld/%ld good connections; uptime %ld/%ld sec (%.2f%%); "
608 "wmtbf %lu:%02lu:%02lu",
610 or_history
->n_conn_ok
, or_history
->n_conn_fail
+or_history
->n_conn_ok
,
611 upt
, upt
+downt
, uptime
*100.0,
612 stability
/3600, (stability
/60)%60, stability
%60);
614 if (!digestmap_isempty(or_history
->link_history_map
)) {
615 strlcpy(buffer
, " Extend attempts: ", sizeof(buffer
));
616 len
= strlen(buffer
);
617 for (lhist_it
= digestmap_iter_init(or_history
->link_history_map
);
618 !digestmap_iter_done(lhist_it
);
619 lhist_it
= digestmap_iter_next(or_history
->link_history_map
,
621 digestmap_iter_get(lhist_it
, &digest2
, &link_history_p
);
622 if ((r
= router_get_by_digest(digest2
)))
627 link_history
= (link_history_t
*) link_history_p
;
629 ret
= tor_snprintf(buffer
+len
, 2048-len
, "%s(%ld/%ld); ", name2
,
630 link_history
->n_extend_ok
,
631 link_history
->n_extend_ok
+link_history
->n_extend_fail
);
637 log(severity
, LD_HIST
, "%s", buffer
);
642 /** Remove history info for routers/links that haven't changed since
646 rep_history_clean(time_t before
)
648 int authority
= authdir_mode(get_options());
649 or_history_t
*or_history
;
650 link_history_t
*link_history
;
651 void *or_history_p
, *link_history_p
;
652 digestmap_iter_t
*orhist_it
, *lhist_it
;
655 orhist_it
= digestmap_iter_init(history_map
);
656 while (!digestmap_iter_done(orhist_it
)) {
658 digestmap_iter_get(orhist_it
, &d1
, &or_history_p
);
659 or_history
= or_history_p
;
661 remove
= authority
? (or_history
->total_run_weights
< STABILITY_EPSILON
&&
662 !or_history
->start_of_run
)
663 : (or_history
->changed
< before
);
665 orhist_it
= digestmap_iter_next_rmv(history_map
, orhist_it
);
666 free_or_history(or_history
);
669 for (lhist_it
= digestmap_iter_init(or_history
->link_history_map
);
670 !digestmap_iter_done(lhist_it
); ) {
671 digestmap_iter_get(lhist_it
, &d2
, &link_history_p
);
672 link_history
= link_history_p
;
673 if (link_history
->changed
< before
) {
674 lhist_it
= digestmap_iter_next_rmv(or_history
->link_history_map
,
676 rephist_total_alloc
-= sizeof(link_history_t
);
677 tor_free(link_history
);
680 lhist_it
= digestmap_iter_next(or_history
->link_history_map
,lhist_it
);
682 orhist_it
= digestmap_iter_next(history_map
, orhist_it
);
686 /** Write MTBF data to disk. Return 0 on success, negative on failure.
688 * If <b>missing_means_down</b>, then if we're about to write an entry
689 * that is still considered up but isn't in our routerlist, consider it
692 rep_hist_record_mtbf_data(time_t now
, int missing_means_down
)
694 char time_buf
[ISO_TIME_LEN
+1];
696 digestmap_iter_t
*orhist_it
;
700 open_file_t
*open_file
= NULL
;
704 char *filename
= get_datadir_fname("router-stability");
705 f
= start_writing_to_stdio_file(filename
, OPEN_FLAGS_REPLACE
|O_TEXT
, 0600,
713 * FormatLine *KeywordLine Data
715 * FormatLine = "format 1" NL
716 * KeywordLine = Keyword SP Arguments NL
717 * Data = "data" NL *RouterMTBFLine "." NL
718 * RouterMTBFLine = Fingerprint SP WeightedRunLen SP
719 * TotalRunWeights [SP S=StartRunTime] NL
721 #define PUT(s) STMT_BEGIN if (fputs((s),f)<0) goto err; STMT_END
722 #define PRINTF(args) STMT_BEGIN if (fprintf args <0) goto err; STMT_END
726 format_iso_time(time_buf
, time(NULL
));
727 PRINTF((f
, "stored-at %s\n", time_buf
));
729 if (started_tracking_stability
) {
730 format_iso_time(time_buf
, started_tracking_stability
);
731 PRINTF((f
, "tracked-since %s\n", time_buf
));
733 if (stability_last_downrated
) {
734 format_iso_time(time_buf
, stability_last_downrated
);
735 PRINTF((f
, "last-downrated %s\n", time_buf
));
740 /* XXX Nick: now bridge auths record this for all routers too.
741 * Should we make them record it only for bridge routers? -RD
742 * Not for 0.2.0. -NM */
743 for (orhist_it
= digestmap_iter_init(history_map
);
744 !digestmap_iter_done(orhist_it
);
745 orhist_it
= digestmap_iter_next(history_map
,orhist_it
)) {
746 char dbuf
[HEX_DIGEST_LEN
+1];
747 const char *t
= NULL
;
748 digestmap_iter_get(orhist_it
, &digest
, &or_history_p
);
749 hist
= (or_history_t
*) or_history_p
;
751 base16_encode(dbuf
, sizeof(dbuf
), digest
, DIGEST_LEN
);
753 if (missing_means_down
&& hist
->start_of_run
&&
754 !router_get_by_digest(digest
)) {
755 /* We think this relay is running, but it's not listed in our
756 * routerlist. Somehow it fell out without telling us it went
757 * down. Complain and also correct it. */
759 "Relay '%s' is listed as up in rephist, but it's not in "
760 "our routerlist. Correcting.", dbuf
);
761 rep_hist_note_router_unreachable(digest
, now
);
764 PRINTF((f
, "R %s\n", dbuf
));
765 if (hist
->start_of_run
> 0) {
766 format_iso_time(time_buf
, hist
->start_of_run
);
769 PRINTF((f
, "+MTBF %lu %.5lf%s%s\n",
770 hist
->weighted_run_length
, hist
->total_run_weights
,
771 t
? " S=" : "", t
? t
: ""));
773 if (hist
->start_of_downtime
> 0) {
774 format_iso_time(time_buf
, hist
->start_of_downtime
);
777 PRINTF((f
, "+WFU %lu %lu%s%s\n",
778 hist
->weighted_uptime
, hist
->total_weighted_time
,
779 t
? " S=" : "", t
? t
: ""));
787 return finish_writing_to_file(open_file
);
789 abort_writing_to_file(open_file
);
793 /** Format the current tracked status of the router in <b>hist</b> at time
794 * <b>now</b> for analysis; return it in a newly allocated string. */
796 rep_hist_format_router_status(or_history_t
*hist
, time_t now
)
799 char sor_buf
[ISO_TIME_LEN
+1];
800 char sod_buf
[ISO_TIME_LEN
+1];
803 int up
= 0, down
= 0;
805 if (hist
->start_of_run
) {
806 format_iso_time(sor_buf
, hist
->start_of_run
);
809 if (hist
->start_of_downtime
) {
810 format_iso_time(sod_buf
, hist
->start_of_downtime
);
814 wfu
= get_weighted_fractional_uptime(hist
, now
);
815 mtbf
= get_stability(hist
, now
);
816 tor_snprintf(buf
, sizeof(buf
),
820 " weighted-time %lu\n"
821 " weighted-uptime %lu\n"
823 " weighted-run-length %lu\n"
824 " total-run-weights %lf\n",
825 up
?"uptime-started ":"", up
?sor_buf
:"", up
?" UTC\n":"",
826 down
?"downtime-started ":"", down
?sod_buf
:"", down
?" UTC\n":"",
828 hist
->total_weighted_time
,
829 hist
->weighted_uptime
,
831 hist
->weighted_run_length
,
832 hist
->total_run_weights
835 return tor_strdup(buf
);
838 /** The last stability analysis document that we created, or NULL if we never
839 * have created one. */
840 static char *last_stability_doc
= NULL
;
841 /** The last time we created a stability analysis document, or 0 if we never
842 * have created one. */
843 static time_t built_last_stability_doc_at
= 0;
844 /** Shortest allowable time between building two stability documents. */
845 #define MAX_STABILITY_DOC_BUILD_RATE (3*60)
847 /** Return a pointer to a NUL-terminated document describing our view of the
848 * stability of the routers we've been tracking. Return NULL on failure. */
850 rep_hist_get_router_stability_doc(time_t now
)
854 if (built_last_stability_doc_at
+ MAX_STABILITY_DOC_BUILD_RATE
> now
)
855 return last_stability_doc
;
860 tor_free(last_stability_doc
);
861 chunks
= smartlist_create();
863 if (rep_hist_have_measured_enough_stability()) {
864 smartlist_add(chunks
, tor_strdup("we-have-enough-measurements\n"));
866 smartlist_add(chunks
, tor_strdup("we-do-not-have-enough-measurements\n"));
869 DIGESTMAP_FOREACH(history_map
, id
, or_history_t
*, hist
) {
871 char dbuf
[BASE64_DIGEST_LEN
+1];
872 char header_buf
[512];
874 digest_to_base64(dbuf
, id
);
875 ri
= router_get_by_digest(id
);
877 char *ip
= tor_dup_ip(ri
->addr
);
878 char tbuf
[ISO_TIME_LEN
+1];
879 format_iso_time(tbuf
, ri
->cache_info
.published_on
);
880 tor_snprintf(header_buf
, sizeof(header_buf
),
883 "relevant-flags %s%s%s\n"
884 "declared-uptime %ld\n",
885 dbuf
, ri
->nickname
, ip
,
887 ri
->is_running
? "Running " : "",
888 ri
->is_valid
? "Valid " : "",
889 ri
->is_hibernating
? "Hibernating " : "",
893 tor_snprintf(header_buf
, sizeof(header_buf
),
894 "router %s {no descriptor}\n", dbuf
);
896 smartlist_add(chunks
, tor_strdup(header_buf
));
897 info
= rep_hist_format_router_status(hist
, now
);
899 smartlist_add(chunks
, info
);
901 } DIGESTMAP_FOREACH_END
;
903 result
= smartlist_join_strings(chunks
, "", 0, NULL
);
904 SMARTLIST_FOREACH(chunks
, char *, cp
, tor_free(cp
));
905 smartlist_free(chunks
);
907 last_stability_doc
= result
;
908 built_last_stability_doc_at
= time(NULL
);
912 /** Helper: return the first j >= i such that !strcmpstart(sl[j], prefix) and
913 * such that no line sl[k] with i <= k < j starts with "R ". Return -1 if no
914 * such line exists. */
916 find_next_with(smartlist_t
*sl
, int i
, const char *prefix
)
918 for ( ; i
< smartlist_len(sl
); ++i
) {
919 const char *line
= smartlist_get(sl
, i
);
920 if (!strcmpstart(line
, prefix
))
922 if (!strcmpstart(line
, "R "))
928 /** How many bad times has parse_possibly_bad_iso_time parsed? */
929 static int n_bogus_times
= 0;
930 /** Parse the ISO-formatted time in <b>s</b> into *<b>time_out</b>, but
931 * rounds any pre-1970 date to Jan 1, 1970. */
933 parse_possibly_bad_iso_time(const char *s
, time_t *time_out
)
937 strlcpy(b
, s
, sizeof(b
));
939 year
= (int)tor_parse_long(b
, 10, 0, INT_MAX
, NULL
, NULL
);
945 return parse_iso_time(s
, time_out
);
948 /** We've read a time <b>t</b> from a file stored at <b>stored_at</b>, which
949 * says we started measuring at <b>started_measuring</b>. Return a new number
950 * that's about as much before <b>now</b> as <b>t</b> was before
954 correct_time(time_t t
, time_t now
, time_t stored_at
, time_t started_measuring
)
956 if (t
< started_measuring
- 24*60*60*365)
958 else if (t
< started_measuring
)
959 return started_measuring
;
960 else if (t
> stored_at
)
963 long run_length
= stored_at
- t
;
964 t
= now
- run_length
;
965 if (t
< started_measuring
)
966 t
= started_measuring
;
971 /** Load MTBF data from disk. Returns 0 on success or recoverable error, -1
974 rep_hist_load_mtbf_data(time_t now
)
976 /* XXXX won't handle being called while history is already populated. */
978 const char *line
= NULL
;
980 time_t last_downrated
= 0, stored_at
= 0, tracked_since
= 0;
981 time_t latest_possible_start
= now
;
985 char *filename
= get_datadir_fname("router-stability");
986 char *d
= read_file_to_str(filename
, RFTS_IGNORE_MISSING
, NULL
);
990 lines
= smartlist_create();
991 smartlist_split_string(lines
, d
, "\n", SPLIT_SKIP_SPACE
, 0);
996 const char *firstline
;
997 if (smartlist_len(lines
)>4) {
998 firstline
= smartlist_get(lines
, 0);
999 if (!strcmpstart(firstline
, "format "))
1000 format
= tor_parse_long(firstline
+strlen("format "),
1001 10, -1, LONG_MAX
, NULL
, NULL
);
1004 if (format
!= 1 && format
!= 2) {
1006 "Unrecognized format in mtbf history file. Skipping.");
1009 for (i
= 1; i
< smartlist_len(lines
); ++i
) {
1010 line
= smartlist_get(lines
, i
);
1011 if (!strcmp(line
, "data"))
1013 if (!strcmpstart(line
, "last-downrated ")) {
1014 if (parse_iso_time(line
+strlen("last-downrated "), &last_downrated
)<0)
1015 log_warn(LD_HIST
,"Couldn't parse downrate time in mtbf "
1018 if (!strcmpstart(line
, "stored-at ")) {
1019 if (parse_iso_time(line
+strlen("stored-at "), &stored_at
)<0)
1020 log_warn(LD_HIST
,"Couldn't parse stored time in mtbf "
1023 if (!strcmpstart(line
, "tracked-since ")) {
1024 if (parse_iso_time(line
+strlen("tracked-since "), &tracked_since
)<0)
1025 log_warn(LD_HIST
,"Couldn't parse started-tracking time in mtbf "
1029 if (last_downrated
> now
)
1030 last_downrated
= now
;
1031 if (tracked_since
> now
)
1032 tracked_since
= now
;
1035 log_warn(LD_HIST
, "No stored time recorded.");
1039 if (line
&& !strcmp(line
, "data"))
1044 for (; i
< smartlist_len(lines
); ++i
) {
1045 char digest
[DIGEST_LEN
];
1046 char hexbuf
[HEX_DIGEST_LEN
+1];
1047 char mtbf_timebuf
[ISO_TIME_LEN
+1];
1048 char wfu_timebuf
[ISO_TIME_LEN
+1];
1049 time_t start_of_run
= 0;
1050 time_t start_of_downtime
= 0;
1051 int have_mtbf
= 0, have_wfu
= 0;
1054 long wt_uptime
= 0, total_wt_time
= 0;
1057 line
= smartlist_get(lines
, i
);
1058 if (!strcmp(line
, "."))
1061 mtbf_timebuf
[0] = '\0';
1062 wfu_timebuf
[0] = '\0';
1065 n
= sscanf(line
, "%40s %ld %lf S=%10s %8s",
1066 hexbuf
, &wrl
, &trw
, mtbf_timebuf
, mtbf_timebuf
+11);
1067 if (n
!= 3 && n
!= 5) {
1068 log_warn(LD_HIST
, "Couldn't scan line %s", escaped(line
));
1074 int mtbf_idx
, wfu_idx
;
1075 if (strcmpstart(line
, "R ") || strlen(line
) < 2+HEX_DIGEST_LEN
)
1077 strlcpy(hexbuf
, line
+2, sizeof(hexbuf
));
1078 mtbf_idx
= find_next_with(lines
, i
+1, "+MTBF ");
1079 wfu_idx
= find_next_with(lines
, i
+1, "+WFU ");
1080 if (mtbf_idx
>= 0) {
1081 const char *mtbfline
= smartlist_get(lines
, mtbf_idx
);
1082 n
= sscanf(mtbfline
, "+MTBF %lu %lf S=%10s %8s",
1083 &wrl
, &trw
, mtbf_timebuf
, mtbf_timebuf
+11);
1084 if (n
== 2 || n
== 4) {
1087 log_warn(LD_HIST
, "Couldn't scan +MTBF line %s",
1092 const char *wfuline
= smartlist_get(lines
, wfu_idx
);
1093 n
= sscanf(wfuline
, "+WFU %lu %lu S=%10s %8s",
1094 &wt_uptime
, &total_wt_time
,
1095 wfu_timebuf
, wfu_timebuf
+11);
1096 if (n
== 2 || n
== 4) {
1099 log_warn(LD_HIST
, "Couldn't scan +WFU line %s", escaped(wfuline
));
1107 if (base16_decode(digest
, DIGEST_LEN
, hexbuf
, HEX_DIGEST_LEN
) < 0) {
1108 log_warn(LD_HIST
, "Couldn't hex string %s", escaped(hexbuf
));
1111 hist
= get_or_history(digest
);
1116 if (mtbf_timebuf
[0]) {
1117 mtbf_timebuf
[10] = ' ';
1118 if (parse_possibly_bad_iso_time(mtbf_timebuf
, &start_of_run
)<0)
1119 log_warn(LD_HIST
, "Couldn't parse time %s",
1120 escaped(mtbf_timebuf
));
1122 hist
->start_of_run
= correct_time(start_of_run
, now
, stored_at
,
1124 if (hist
->start_of_run
< latest_possible_start
+ wrl
)
1125 latest_possible_start
= hist
->start_of_run
- wrl
;
1127 hist
->weighted_run_length
= wrl
;
1128 hist
->total_run_weights
= trw
;
1131 if (wfu_timebuf
[0]) {
1132 wfu_timebuf
[10] = ' ';
1133 if (parse_possibly_bad_iso_time(wfu_timebuf
, &start_of_downtime
)<0)
1134 log_warn(LD_HIST
, "Couldn't parse time %s", escaped(wfu_timebuf
));
1137 hist
->start_of_downtime
= correct_time(start_of_downtime
, now
, stored_at
,
1139 hist
->weighted_uptime
= wt_uptime
;
1140 hist
->total_weighted_time
= total_wt_time
;
1142 if (strcmp(line
, "."))
1143 log_warn(LD_HIST
, "Truncated MTBF file.");
1145 if (tracked_since
< 86400*365) /* Recover from insanely early value. */
1146 tracked_since
= latest_possible_start
;
1148 stability_last_downrated
= last_downrated
;
1149 started_tracking_stability
= tracked_since
;
1155 SMARTLIST_FOREACH(lines
, char *, cp
, tor_free(cp
));
1156 smartlist_free(lines
);
1160 /** For how many seconds do we keep track of individual per-second bandwidth
1162 #define NUM_SECS_ROLLING_MEASURE 10
1163 /** How large are the intervals for which we track and report bandwidth use? */
1164 #define NUM_SECS_BW_SUM_INTERVAL (15*60)
1165 /** How far in the past do we remember and publish bandwidth use? */
1166 #define NUM_SECS_BW_SUM_IS_VALID (24*60*60)
1167 /** How many bandwidth usage intervals do we remember? (derived) */
1168 #define NUM_TOTALS (NUM_SECS_BW_SUM_IS_VALID/NUM_SECS_BW_SUM_INTERVAL)
1170 /** Structure to track bandwidth use, and remember the maxima for a given
1173 typedef struct bw_array_t
{
1174 /** Observation array: Total number of bytes transferred in each of the last
1175 * NUM_SECS_ROLLING_MEASURE seconds. This is used as a circular array. */
1176 uint64_t obs
[NUM_SECS_ROLLING_MEASURE
];
1177 int cur_obs_idx
; /**< Current position in obs. */
1178 time_t cur_obs_time
; /**< Time represented in obs[cur_obs_idx] */
1179 uint64_t total_obs
; /**< Total for all members of obs except
1180 * obs[cur_obs_idx] */
1181 uint64_t max_total
; /**< Largest value that total_obs has taken on in the
1182 * current period. */
1183 uint64_t total_in_period
; /**< Total bytes transferred in the current
1186 /** When does the next period begin? */
1188 /** Where in 'maxima' should the maximum bandwidth usage for the current
1189 * period be stored? */
1191 /** How many values in maxima/totals have been set ever? */
1193 /** Circular array of the maximum
1194 * bandwidth-per-NUM_SECS_ROLLING_MEASURE usage for the last
1195 * NUM_TOTALS periods */
1196 uint64_t maxima
[NUM_TOTALS
];
1197 /** Circular array of the total bandwidth usage for the last NUM_TOTALS
1199 uint64_t totals
[NUM_TOTALS
];
1202 /** Shift the current period of b forward by one. */
1204 commit_max(bw_array_t
*b
)
1206 /* Store total from current period. */
1207 b
->totals
[b
->next_max_idx
] = b
->total_in_period
;
1208 /* Store maximum from current period. */
1209 b
->maxima
[b
->next_max_idx
++] = b
->max_total
;
1210 /* Advance next_period and next_max_idx */
1211 b
->next_period
+= NUM_SECS_BW_SUM_INTERVAL
;
1212 if (b
->next_max_idx
== NUM_TOTALS
)
1213 b
->next_max_idx
= 0;
1214 if (b
->num_maxes_set
< NUM_TOTALS
)
1216 /* Reset max_total. */
1218 /* Reset total_in_period. */
1219 b
->total_in_period
= 0;
1222 /** Shift the current observation time of 'b' forward by one second. */
1224 advance_obs(bw_array_t
*b
)
1229 /* Calculate the total bandwidth for the last NUM_SECS_ROLLING_MEASURE
1230 * seconds; adjust max_total as needed.*/
1231 total
= b
->total_obs
+ b
->obs
[b
->cur_obs_idx
];
1232 if (total
> b
->max_total
)
1233 b
->max_total
= total
;
1235 nextidx
= b
->cur_obs_idx
+1;
1236 if (nextidx
== NUM_SECS_ROLLING_MEASURE
)
1239 b
->total_obs
= total
- b
->obs
[nextidx
];
1241 b
->cur_obs_idx
= nextidx
;
1243 if (++b
->cur_obs_time
>= b
->next_period
)
1247 /** Add <b>n</b> bytes to the number of bytes in <b>b</b> for second
1250 add_obs(bw_array_t
*b
, time_t when
, uint64_t n
)
1252 /* Don't record data in the past. */
1253 if (when
<b
->cur_obs_time
)
1255 /* If we're currently adding observations for an earlier second than
1256 * 'when', advance b->cur_obs_time and b->cur_obs_idx by an
1257 * appropriate number of seconds, and do all the other housekeeping */
1258 while (when
>b
->cur_obs_time
)
1261 b
->obs
[b
->cur_obs_idx
] += n
;
1262 b
->total_in_period
+= n
;
1265 /** Allocate, initialize, and return a new bw_array. */
1271 b
= tor_malloc_zero(sizeof(bw_array_t
));
1272 rephist_total_alloc
+= sizeof(bw_array_t
);
1274 b
->cur_obs_time
= start
;
1275 b
->next_period
= start
+ NUM_SECS_BW_SUM_INTERVAL
;
1279 /** Recent history of bandwidth observations for read operations. */
1280 static bw_array_t
*read_array
= NULL
;
1281 /** Recent history of bandwidth observations for write operations. */
1282 static bw_array_t
*write_array
= NULL
;
1284 /** Set up read_array and write_array. */
1286 bw_arrays_init(void)
1288 read_array
= bw_array_new();
1289 write_array
= bw_array_new();
1292 /** We read <b>num_bytes</b> more bytes in second <b>when</b>.
1294 * Add num_bytes to the current running total for <b>when</b>.
1296 * <b>when</b> can go back to time, but it's safe to ignore calls
1297 * earlier than the latest <b>when</b> you've heard of.
1300 rep_hist_note_bytes_written(size_t num_bytes
, time_t when
)
1302 /* Maybe a circular array for recent seconds, and step to a new point
1303 * every time a new second shows up. Or simpler is to just to have
1304 * a normal array and push down each item every second; it's short.
1306 /* When a new second has rolled over, compute the sum of the bytes we've
1307 * seen over when-1 to when-1-NUM_SECS_ROLLING_MEASURE, and stick it
1308 * somewhere. See rep_hist_bandwidth_assess() below.
1310 add_obs(write_array
, when
, num_bytes
);
1313 /** We wrote <b>num_bytes</b> more bytes in second <b>when</b>.
1314 * (like rep_hist_note_bytes_written() above)
1317 rep_hist_note_bytes_read(size_t num_bytes
, time_t when
)
1319 /* if we're smart, we can make this func and the one above share code */
1320 add_obs(read_array
, when
, num_bytes
);
1323 /* Some constants */
1324 /** To what multiple should byte numbers be rounded up? */
1325 #define EXIT_STATS_ROUND_UP_BYTES 1024
1326 /** To what multiple should stream counts be rounded up? */
1327 #define EXIT_STATS_ROUND_UP_STREAMS 4
1328 /** Number of TCP ports */
1329 #define EXIT_STATS_NUM_PORTS 65536
1330 /** Reciprocal of threshold (= 0.01%) of total bytes that a port needs to
1331 * see in order to be included in exit stats. */
1332 #define EXIT_STATS_THRESHOLD_RECIPROCAL 10000
1334 /* The following data structures are arrays and no fancy smartlists or maps,
1335 * so that all write operations can be done in constant time. This comes at
1336 * the price of some memory (1.25 MB) and linear complexity when writing
1337 * stats for measuring relays. */
1338 /** Number of bytes read in current period by exit port */
1339 static uint64_t *exit_bytes_read
= NULL
;
1340 /** Number of bytes written in current period by exit port */
1341 static uint64_t *exit_bytes_written
= NULL
;
1342 /** Number of streams opened in current period by exit port */
1343 static uint32_t *exit_streams
= NULL
;
1345 /** When does the current exit stats period end? */
1346 static time_t start_of_exit_stats_interval
;
1348 /** Initialize exit port stats. */
1350 rep_hist_exit_stats_init(time_t now
)
1352 start_of_exit_stats_interval
= now
;
1353 exit_bytes_read
= tor_malloc_zero(EXIT_STATS_NUM_PORTS
*
1355 exit_bytes_written
= tor_malloc_zero(EXIT_STATS_NUM_PORTS
*
1357 exit_streams
= tor_malloc_zero(EXIT_STATS_NUM_PORTS
*
1361 /** Write exit stats to $DATADIR/stats/exit-stats and reset counters. */
1363 rep_hist_exit_stats_write(time_t now
)
1365 char t
[ISO_TIME_LEN
+1];
1367 uint64_t *b
, total_bytes
, threshold_bytes
, other_bytes
;
1368 uint32_t other_streams
;
1370 char *statsdir
= NULL
, *filename
= NULL
;
1371 open_file_t
*open_file
= NULL
;
1375 return; /* Not initialized */
1377 statsdir
= get_datadir_fname("stats");
1378 if (check_private_dir(statsdir
, CPD_CREATE
) < 0)
1380 filename
= get_datadir_fname("stats"PATH_SEPARATOR
"exit-stats");
1381 format_iso_time(t
, now
);
1382 log_info(LD_HIST
, "Writing exit port statistics to disk for period "
1383 "ending at %s.", t
);
1386 out
= start_writing_to_stdio_file(filename
, OPEN_FLAGS_APPEND
,
1389 log_warn(LD_HIST
, "Couldn't open '%s'.", filename
);
1394 /* written yyyy-mm-dd HH:MM:SS (n s) */
1395 if (fprintf(out
, "exit-stats-end %s (%d s)\n", t
,
1396 (unsigned) (now
- start_of_exit_stats_interval
)) < 0)
1399 /* Count the total number of bytes, so that we can attribute all
1400 * observations below a threshold of 1 / EXIT_STATS_THRESHOLD_RECIPROCAL
1401 * of all bytes to a special port 'other'. */
1403 for (i
= 1; i
< EXIT_STATS_NUM_PORTS
; i
++) {
1404 total_bytes
+= exit_bytes_read
[i
];
1405 total_bytes
+= exit_bytes_written
[i
];
1407 threshold_bytes
= total_bytes
/ EXIT_STATS_THRESHOLD_RECIPROCAL
;
1409 /* exit-kibibytes-(read|written) port=kibibytes,.. */
1410 for (r
= 0; r
< 2; r
++) {
1411 b
= r
? exit_bytes_read
: exit_bytes_written
;
1413 if (fprintf(out
, "%s ",
1414 r
? "exit-kibibytes-read"
1415 : "exit-kibibytes-written") < 0)
1420 for (i
= 1; i
< EXIT_STATS_NUM_PORTS
; i
++) {
1422 if (exit_bytes_read
[i
] + exit_bytes_written
[i
] > threshold_bytes
) {
1423 uint64_t num
= round_uint64_to_next_multiple_of(b
[i
],
1424 EXIT_STATS_ROUND_UP_BYTES
);
1426 if (fprintf(out
, "%s%d="U64_FORMAT
,
1427 comma
++ ? "," : "", i
,
1428 U64_PRINTF_ARG(num
)) < 0)
1431 other_bytes
+= b
[i
];
1434 other_bytes
= round_uint64_to_next_multiple_of(other_bytes
,
1435 EXIT_STATS_ROUND_UP_BYTES
);
1436 other_bytes
/= 1024;
1437 if (fprintf(out
, "%sother="U64_FORMAT
"\n",
1438 comma
? "," : "", U64_PRINTF_ARG(other_bytes
))<0)
1441 /* exit-streams-opened port=num,.. */
1442 if (fprintf(out
, "exit-streams-opened ") < 0)
1446 for (i
= 1; i
< EXIT_STATS_NUM_PORTS
; i
++) {
1447 if (exit_streams
[i
] > 0) {
1448 if (exit_bytes_read
[i
] + exit_bytes_written
[i
] > threshold_bytes
) {
1449 uint32_t num
= round_uint32_to_next_multiple_of(exit_streams
[i
],
1450 EXIT_STATS_ROUND_UP_STREAMS
);
1451 if (fprintf(out
, "%s%d=%u",
1452 comma
++ ? "," : "", i
, num
)<0)
1455 other_streams
+= exit_streams
[i
];
1458 other_streams
= round_uint32_to_next_multiple_of(other_streams
,
1459 EXIT_STATS_ROUND_UP_STREAMS
);
1460 if (fprintf(out
, "%sother=%u\n",
1461 comma
? "," : "", other_streams
)<0)
1463 /* Reset counters */
1464 memset(exit_bytes_read
, 0, EXIT_STATS_NUM_PORTS
* sizeof(uint64_t));
1465 memset(exit_bytes_written
, 0, EXIT_STATS_NUM_PORTS
* sizeof(uint64_t));
1466 memset(exit_streams
, 0, EXIT_STATS_NUM_PORTS
* sizeof(uint32_t));
1467 start_of_exit_stats_interval
= now
;
1470 finish_writing_to_file(open_file
);
1474 abort_writing_to_file(open_file
);
1479 /** Note that we wrote <b>num_bytes</b> to an exit connection to
1482 rep_hist_note_exit_bytes_written(uint16_t port
, size_t num_bytes
)
1484 if (!get_options()->ExitPortStatistics
)
1486 if (!exit_bytes_written
)
1487 return; /* Not initialized */
1488 exit_bytes_written
[port
] += num_bytes
;
1489 log_debug(LD_HIST
, "Written %lu bytes to exit connection to port %d.",
1490 (unsigned long)num_bytes
, port
);
1493 /** Note that we read <b>num_bytes</b> from an exit connection to
1496 rep_hist_note_exit_bytes_read(uint16_t port
, size_t num_bytes
)
1498 if (!get_options()->ExitPortStatistics
)
1500 if (!exit_bytes_read
)
1501 return; /* Not initialized */
1502 exit_bytes_read
[port
] += num_bytes
;
1503 log_debug(LD_HIST
, "Read %lu bytes from exit connection to port %d.",
1504 (unsigned long)num_bytes
, port
);
1507 /** Note that we opened an exit stream to <b>port</b>. */
1509 rep_hist_note_exit_stream_opened(uint16_t port
)
1511 if (!get_options()->ExitPortStatistics
)
1514 return; /* Not initialized */
1515 exit_streams
[port
]++;
1516 log_debug(LD_HIST
, "Opened exit stream to port %d", port
);
1519 /** Helper: Return the largest value in b->maxima. (This is equal to the
1520 * most bandwidth used in any NUM_SECS_ROLLING_MEASURE period for the last
1521 * NUM_SECS_BW_SUM_IS_VALID seconds.)
1524 find_largest_max(bw_array_t
*b
)
1529 for (i
=0; i
<NUM_TOTALS
; ++i
) {
1530 if (b
->maxima
[i
]>max
)
1536 /** Find the largest sums in the past NUM_SECS_BW_SUM_IS_VALID (roughly)
1537 * seconds. Find one sum for reading and one for writing. They don't have
1538 * to be at the same time.
1540 * Return the smaller of these sums, divided by NUM_SECS_ROLLING_MEASURE.
1543 rep_hist_bandwidth_assess(void)
1546 r
= find_largest_max(read_array
);
1547 w
= find_largest_max(write_array
);
1549 return (int)(U64_TO_DBL(w
)/NUM_SECS_ROLLING_MEASURE
);
1551 return (int)(U64_TO_DBL(r
)/NUM_SECS_ROLLING_MEASURE
);
1554 /** Print the bandwidth history of b (either read_array or write_array)
1555 * into the buffer pointed to by buf. The format is simply comma
1556 * separated numbers, from oldest to newest.
1558 * It returns the number of bytes written.
1561 rep_hist_fill_bandwidth_history(char *buf
, size_t len
, bw_array_t
*b
)
1565 or_options_t
*options
= get_options();
1568 if (b
->num_maxes_set
<= b
->next_max_idx
) {
1569 /* We haven't been through the circular array yet; time starts at i=0.*/
1572 /* We've been around the array at least once. The next i to be
1573 overwritten is the oldest. */
1574 i
= b
->next_max_idx
;
1577 if (options
->RelayBandwidthRate
) {
1578 /* We don't want to report that we used more bandwidth than the max we're
1579 * willing to relay; otherwise everybody will know how much traffic
1580 * we used ourself. */
1581 cutoff
= options
->RelayBandwidthRate
* NUM_SECS_BW_SUM_INTERVAL
;
1583 cutoff
= UINT64_MAX
;
1586 for (n
=0; n
<b
->num_maxes_set
; ++n
,++i
) {
1588 if (i
>= NUM_TOTALS
)
1590 tor_assert(i
< NUM_TOTALS
);
1591 /* Round the bandwidth used down to the nearest 1k. */
1592 total
= b
->totals
[i
] & ~0x3ff;
1596 if (n
==(b
->num_maxes_set
-1))
1597 tor_snprintf(cp
, len
-(cp
-buf
), U64_FORMAT
, U64_PRINTF_ARG(total
));
1599 tor_snprintf(cp
, len
-(cp
-buf
), U64_FORMAT
",", U64_PRINTF_ARG(total
));
1605 /** Allocate and return lines for representing this server's bandwidth
1606 * history in its descriptor.
1609 rep_hist_get_bandwidth_lines(int for_extrainfo
)
1612 char t
[ISO_TIME_LEN
+1];
1617 /* opt (read|write)-history yyyy-mm-dd HH:MM:SS (n s) n,n,n,n,n... */
1618 len
= (60+20*NUM_TOTALS
)*2;
1619 buf
= tor_malloc_zero(len
);
1622 b
= r
?read_array
:write_array
;
1624 format_iso_time(t
, b
->next_period
-NUM_SECS_BW_SUM_INTERVAL
);
1625 tor_snprintf(cp
, len
-(cp
-buf
), "%s%s %s (%d s) ",
1626 for_extrainfo
? "" : "opt ",
1627 r
? "read-history" : "write-history", t
,
1628 NUM_SECS_BW_SUM_INTERVAL
);
1630 cp
+= rep_hist_fill_bandwidth_history(cp
, len
-(cp
-buf
), b
);
1631 strlcat(cp
, "\n", len
-(cp
-buf
));
1637 /** Update <b>state</b> with the newest bandwidth history. */
1639 rep_hist_update_state(or_state_t
*state
)
1643 smartlist_t
**s_values
;
1648 len
= 20*NUM_TOTALS
+1;
1649 buf
= tor_malloc_zero(len
);
1652 b
= r
?read_array
:write_array
;
1653 s_begins
= r
?&state
->BWHistoryReadEnds
:&state
->BWHistoryWriteEnds
;
1654 s_interval
= r
?&state
->BWHistoryReadInterval
:&state
->BWHistoryWriteInterval
;
1655 s_values
= r
?&state
->BWHistoryReadValues
:&state
->BWHistoryWriteValues
;
1658 SMARTLIST_FOREACH(*s_values
, char *, val
, tor_free(val
));
1659 smartlist_free(*s_values
);
1661 if (! server_mode(get_options())) {
1662 /* Clients don't need to store bandwidth history persistently;
1663 * force these values to the defaults. */
1664 /* FFFF we should pull the default out of config.c's state table,
1665 * so we don't have two defaults. */
1666 if (*s_begins
!= 0 || *s_interval
!= 900) {
1667 time_t now
= time(NULL
);
1668 time_t save_at
= get_options()->AvoidDiskWrites
? now
+3600 : now
+600;
1669 or_state_mark_dirty(state
, save_at
);
1673 *s_values
= smartlist_create();
1676 *s_begins
= b
->next_period
;
1677 *s_interval
= NUM_SECS_BW_SUM_INTERVAL
;
1679 cp
+= rep_hist_fill_bandwidth_history(cp
, len
, b
);
1680 tor_snprintf(cp
, len
-(cp
-buf
), cp
== buf
? U64_FORMAT
: ","U64_FORMAT
,
1681 U64_PRINTF_ARG(b
->total_in_period
));
1682 *s_values
= smartlist_create();
1683 if (server_mode(get_options()))
1684 smartlist_split_string(*s_values
, buf
, ",", SPLIT_SKIP_SPACE
, 0);
1687 if (server_mode(get_options())) {
1688 or_state_mark_dirty(get_or_state(), time(NULL
)+(2*3600));
1692 /** Set bandwidth history from our saved state. */
1694 rep_hist_load_state(or_state_t
*state
, char **err
)
1696 time_t s_begins
, start
;
1697 time_t now
= time(NULL
);
1702 smartlist_t
*s_values
;
1705 /* Assert they already have been malloced */
1706 tor_assert(read_array
&& write_array
);
1709 b
= r
?read_array
:write_array
;
1710 s_begins
= r
?state
->BWHistoryReadEnds
:state
->BWHistoryWriteEnds
;
1711 s_interval
= r
?state
->BWHistoryReadInterval
:state
->BWHistoryWriteInterval
;
1712 s_values
= r
?state
->BWHistoryReadValues
:state
->BWHistoryWriteValues
;
1713 if (s_values
&& s_begins
>= now
- NUM_SECS_BW_SUM_INTERVAL
*NUM_TOTALS
) {
1714 start
= s_begins
- s_interval
*(smartlist_len(s_values
));
1717 b
->cur_obs_time
= start
;
1718 b
->next_period
= start
+ NUM_SECS_BW_SUM_INTERVAL
;
1719 SMARTLIST_FOREACH(s_values
, char *, cp
, {
1720 v
= tor_parse_uint64(cp
, 10, 0, UINT64_MAX
, &ok
, NULL
);
1723 log_notice(LD_HIST
, "Could not parse '%s' into a number.'", cp
);
1726 add_obs(b
, start
, v
);
1727 start
+= NUM_SECS_BW_SUM_INTERVAL
;
1732 /* Clean up maxima and observed */
1733 /* Do we really want to zero this for the purpose of max capacity? */
1734 for (i
=0; i
<NUM_SECS_ROLLING_MEASURE
; ++i
) {
1738 for (i
=0; i
<NUM_TOTALS
; ++i
) {
1745 *err
= tor_strdup("Parsing of bandwidth history values failed");
1746 /* and create fresh arrays */
1747 tor_free(read_array
);
1748 tor_free(write_array
);
1749 read_array
= bw_array_new();
1750 write_array
= bw_array_new();
1756 /*********************************************************************/
1758 /** A list of port numbers that have been used recently. */
1759 static smartlist_t
*predicted_ports_list
=NULL
;
1760 /** The corresponding most recently used time for each port. */
1761 static smartlist_t
*predicted_ports_times
=NULL
;
1763 /** We just got an application request for a connection with
1764 * port <b>port</b>. Remember it for the future, so we can keep
1765 * some circuits open that will exit to this port.
1768 add_predicted_port(time_t now
, uint16_t port
)
1770 /* XXXX we could just use uintptr_t here, I think. */
1771 uint16_t *tmp_port
= tor_malloc(sizeof(uint16_t));
1772 time_t *tmp_time
= tor_malloc(sizeof(time_t));
1775 rephist_total_alloc
+= sizeof(uint16_t) + sizeof(time_t);
1776 smartlist_add(predicted_ports_list
, tmp_port
);
1777 smartlist_add(predicted_ports_times
, tmp_time
);
1780 /** Initialize whatever memory and structs are needed for predicting
1781 * which ports will be used. Also seed it with port 80, so we'll build
1782 * circuits on start-up.
1785 predicted_ports_init(void)
1787 predicted_ports_list
= smartlist_create();
1788 predicted_ports_times
= smartlist_create();
1789 add_predicted_port(time(NULL
), 80); /* add one to kickstart us */
1792 /** Free whatever memory is needed for predicting which ports will
1796 predicted_ports_free(void)
1798 rephist_total_alloc
-= smartlist_len(predicted_ports_list
)*sizeof(uint16_t);
1799 SMARTLIST_FOREACH(predicted_ports_list
, char *, cp
, tor_free(cp
));
1800 smartlist_free(predicted_ports_list
);
1801 rephist_total_alloc
-= smartlist_len(predicted_ports_times
)*sizeof(time_t);
1802 SMARTLIST_FOREACH(predicted_ports_times
, char *, cp
, tor_free(cp
));
1803 smartlist_free(predicted_ports_times
);
1806 /** Remember that <b>port</b> has been asked for as of time <b>now</b>.
1807 * This is used for predicting what sorts of streams we'll make in the
1808 * future and making exit circuits to anticipate that.
1811 rep_hist_note_used_port(time_t now
, uint16_t port
)
1817 tor_assert(predicted_ports_list
);
1818 tor_assert(predicted_ports_times
);
1820 if (!port
) /* record nothing */
1823 for (i
= 0; i
< smartlist_len(predicted_ports_list
); ++i
) {
1824 tmp_port
= smartlist_get(predicted_ports_list
, i
);
1825 tmp_time
= smartlist_get(predicted_ports_times
, i
);
1826 if (*tmp_port
== port
) {
1831 /* it's not there yet; we need to add it */
1832 add_predicted_port(now
, port
);
1835 /** For this long after we've seen a request for a given port, assume that
1836 * we'll want to make connections to the same port in the future. */
1837 #define PREDICTED_CIRCS_RELEVANCE_TIME (60*60)
1839 /** Return a pointer to the list of port numbers that
1840 * are likely to be asked for in the near future.
1842 * The caller promises not to mess with it.
1845 rep_hist_get_predicted_ports(time_t now
)
1851 tor_assert(predicted_ports_list
);
1852 tor_assert(predicted_ports_times
);
1854 /* clean out obsolete entries */
1855 for (i
= 0; i
< smartlist_len(predicted_ports_list
); ++i
) {
1856 tmp_time
= smartlist_get(predicted_ports_times
, i
);
1857 if (*tmp_time
+ PREDICTED_CIRCS_RELEVANCE_TIME
< now
) {
1858 tmp_port
= smartlist_get(predicted_ports_list
, i
);
1859 log_debug(LD_CIRC
, "Expiring predicted port %d", *tmp_port
);
1860 smartlist_del(predicted_ports_list
, i
);
1861 smartlist_del(predicted_ports_times
, i
);
1862 rephist_total_alloc
-= sizeof(uint16_t)+sizeof(time_t);
1868 return predicted_ports_list
;
1871 /** The user asked us to do a resolve. Rather than keeping track of
1872 * timings and such of resolves, we fake it for now by treating
1873 * it the same way as a connection to port 80. This way we will continue
1874 * to have circuits lying around if the user only uses Tor for resolves.
1877 rep_hist_note_used_resolve(time_t now
)
1879 rep_hist_note_used_port(now
, 80);
1882 /** The last time at which we needed an internal circ. */
1883 static time_t predicted_internal_time
= 0;
1884 /** The last time we needed an internal circ with good uptime. */
1885 static time_t predicted_internal_uptime_time
= 0;
1886 /** The last time we needed an internal circ with good capacity. */
1887 static time_t predicted_internal_capacity_time
= 0;
1889 /** Remember that we used an internal circ at time <b>now</b>. */
1891 rep_hist_note_used_internal(time_t now
, int need_uptime
, int need_capacity
)
1893 predicted_internal_time
= now
;
1895 predicted_internal_uptime_time
= now
;
1897 predicted_internal_capacity_time
= now
;
1900 /** Return 1 if we've used an internal circ recently; else return 0. */
1902 rep_hist_get_predicted_internal(time_t now
, int *need_uptime
,
1905 if (!predicted_internal_time
) { /* initialize it */
1906 predicted_internal_time
= now
;
1907 predicted_internal_uptime_time
= now
;
1908 predicted_internal_capacity_time
= now
;
1910 if (predicted_internal_time
+ PREDICTED_CIRCS_RELEVANCE_TIME
< now
)
1911 return 0; /* too long ago */
1912 if (predicted_internal_uptime_time
+ PREDICTED_CIRCS_RELEVANCE_TIME
>= now
)
1914 if (predicted_internal_capacity_time
+ PREDICTED_CIRCS_RELEVANCE_TIME
>= now
)
1919 /** Any ports used lately? These are pre-seeded if we just started
1920 * up or if we're running a hidden service. */
1922 any_predicted_circuits(time_t now
)
1924 return smartlist_len(predicted_ports_list
) ||
1925 predicted_internal_time
+ PREDICTED_CIRCS_RELEVANCE_TIME
>= now
;
1928 /** Return 1 if we have no need for circuits currently, else return 0. */
1930 rep_hist_circbuilding_dormant(time_t now
)
1932 if (any_predicted_circuits(now
))
1935 /* see if we'll still need to build testing circuits */
1936 if (server_mode(get_options()) &&
1937 (!check_whether_orport_reachable() || !circuit_enough_testing_circs()))
1939 if (!check_whether_dirport_reachable())
1945 /** Structure to track how many times we've done each public key operation. */
1947 /** How many directory objects have we signed? */
1948 unsigned long n_signed_dir_objs
;
1949 /** How many routerdescs have we signed? */
1950 unsigned long n_signed_routerdescs
;
1951 /** How many directory objects have we verified? */
1952 unsigned long n_verified_dir_objs
;
1953 /** How many routerdescs have we verified */
1954 unsigned long n_verified_routerdescs
;
1955 /** How many onionskins have we encrypted to build circuits? */
1956 unsigned long n_onionskins_encrypted
;
1957 /** How many onionskins have we decrypted to do circuit build requests? */
1958 unsigned long n_onionskins_decrypted
;
1959 /** How many times have we done the TLS handshake as a client? */
1960 unsigned long n_tls_client_handshakes
;
1961 /** How many times have we done the TLS handshake as a server? */
1962 unsigned long n_tls_server_handshakes
;
1963 /** How many PK operations have we done as a hidden service client? */
1964 unsigned long n_rend_client_ops
;
1965 /** How many PK operations have we done as a hidden service midpoint? */
1966 unsigned long n_rend_mid_ops
;
1967 /** How many PK operations have we done as a hidden service provider? */
1968 unsigned long n_rend_server_ops
;
1969 } pk_op_counts
= {0,0,0,0,0,0,0,0,0,0,0};
1971 /** Increment the count of the number of times we've done <b>operation</b>. */
1973 note_crypto_pk_op(pk_op_t operation
)
1978 pk_op_counts
.n_signed_dir_objs
++;
1981 pk_op_counts
.n_signed_routerdescs
++;
1984 pk_op_counts
.n_verified_dir_objs
++;
1987 pk_op_counts
.n_verified_routerdescs
++;
1990 pk_op_counts
.n_onionskins_encrypted
++;
1993 pk_op_counts
.n_onionskins_decrypted
++;
1995 case TLS_HANDSHAKE_C
:
1996 pk_op_counts
.n_tls_client_handshakes
++;
1998 case TLS_HANDSHAKE_S
:
1999 pk_op_counts
.n_tls_server_handshakes
++;
2002 pk_op_counts
.n_rend_client_ops
++;
2005 pk_op_counts
.n_rend_mid_ops
++;
2008 pk_op_counts
.n_rend_server_ops
++;
2011 log_warn(LD_BUG
, "Unknown pk operation %d", operation
);
2015 /** Log the number of times we've done each public/private-key operation. */
2017 dump_pk_ops(int severity
)
2019 log(severity
, LD_HIST
,
2020 "PK operations: %lu directory objects signed, "
2021 "%lu directory objects verified, "
2022 "%lu routerdescs signed, "
2023 "%lu routerdescs verified, "
2024 "%lu onionskins encrypted, "
2025 "%lu onionskins decrypted, "
2026 "%lu client-side TLS handshakes, "
2027 "%lu server-side TLS handshakes, "
2028 "%lu rendezvous client operations, "
2029 "%lu rendezvous middle operations, "
2030 "%lu rendezvous server operations.",
2031 pk_op_counts
.n_signed_dir_objs
,
2032 pk_op_counts
.n_verified_dir_objs
,
2033 pk_op_counts
.n_signed_routerdescs
,
2034 pk_op_counts
.n_verified_routerdescs
,
2035 pk_op_counts
.n_onionskins_encrypted
,
2036 pk_op_counts
.n_onionskins_decrypted
,
2037 pk_op_counts
.n_tls_client_handshakes
,
2038 pk_op_counts
.n_tls_server_handshakes
,
2039 pk_op_counts
.n_rend_client_ops
,
2040 pk_op_counts
.n_rend_mid_ops
,
2041 pk_op_counts
.n_rend_server_ops
);
2044 /** Free all storage held by the OR/link history caches, by the
2045 * bandwidth history arrays, or by the port history. */
2047 rep_hist_free_all(void)
2049 digestmap_free(history_map
, free_or_history
);
2050 tor_free(read_array
);
2051 tor_free(write_array
);
2052 tor_free(last_stability_doc
);
2053 tor_free(exit_bytes_read
);
2054 tor_free(exit_bytes_written
);
2055 tor_free(exit_streams
);
2056 built_last_stability_doc_at
= 0;
2057 predicted_ports_free();
2060 /****************** hidden service usage statistics ******************/
2062 /** How large are the intervals for which we track and report hidden service
2064 #define NUM_SECS_HS_USAGE_SUM_INTERVAL (15*60)
2065 /** How far in the past do we remember and publish hidden service use? */
2066 #define NUM_SECS_HS_USAGE_SUM_IS_VALID (24*60*60)
2067 /** How many hidden service usage intervals do we remember? (derived) */
2068 #define NUM_TOTALS_HS_USAGE (NUM_SECS_HS_USAGE_SUM_IS_VALID/ \
2069 NUM_SECS_HS_USAGE_SUM_INTERVAL)
2071 /** List element containing a service id and the count. */
2072 typedef struct hs_usage_list_elem_t
{
2073 /** Service id of this elem. */
2074 char service_id
[REND_SERVICE_ID_LEN_BASE32
+1];
2075 /** Number of occurrences for the given service id. */
2077 /* Pointer to next list elem */
2078 struct hs_usage_list_elem_t
*next
;
2079 } hs_usage_list_elem_t
;
2081 /** Ordered list that stores service ids and the number of observations. It is
2082 * ordered by the number of occurrences in descending order. Its purpose is to
2083 * calculate the frequency distribution when the period is over. */
2084 typedef struct hs_usage_list_t
{
2085 /* Pointer to the first element in the list. */
2086 hs_usage_list_elem_t
*start
;
2087 /* Number of total occurrences for all list elements. */
2088 uint32_t total_count
;
2089 /* Number of service ids, i.e. number of list elements. */
2090 uint32_t total_service_ids
;
2093 /** Tracks service-related observations in the current period and their
2095 typedef struct hs_usage_service_related_observation_t
{
2096 /** Ordered list that stores service ids and the number of observations in
2097 * the current period. It is ordered by the number of occurrences in
2098 * descending order. Its purpose is to calculate the frequency distribution
2099 * when the period is over. */
2100 hs_usage_list_t
*list
;
2101 /** Circular arrays that store the history of observations. totals stores all
2102 * observations, twenty (ten, five) the number of observations related to a
2103 * service id being accounted for the top 20 (10, 5) percent of all
2105 uint32_t totals
[NUM_TOTALS_HS_USAGE
];
2106 uint32_t five
[NUM_TOTALS_HS_USAGE
];
2107 uint32_t ten
[NUM_TOTALS_HS_USAGE
];
2108 uint32_t twenty
[NUM_TOTALS_HS_USAGE
];
2109 } hs_usage_service_related_observation_t
;
2111 /** Tracks the history of general period-related observations, i.e. those that
2112 * cannot be related to a specific service id. */
2113 typedef struct hs_usage_general_period_related_observations_t
{
2114 /** Circular array that stores the history of observations. */
2115 uint32_t totals
[NUM_TOTALS_HS_USAGE
];
2116 } hs_usage_general_period_related_observations_t
;
2118 /** Keeps information about the current observation period and its relation to
2119 * the histories of observations. */
2120 typedef struct hs_usage_current_observation_period_t
{
2121 /** Where do we write the next history entry? */
2123 /** How many values in history have been set ever? (upper bound!) */
2125 /** When did this period begin? */
2126 time_t start_of_current_period
;
2127 /** When does the next period begin? */
2128 time_t start_of_next_period
;
2129 } hs_usage_current_observation_period_t
;
2131 /** Usage statistics for the current observation period. */
2132 static hs_usage_current_observation_period_t
*current_period
= NULL
;
2134 /** Total number of descriptor publish requests in the current observation
2136 static hs_usage_service_related_observation_t
*publish_total
= NULL
;
2138 /** Number of descriptor publish requests for services that have not been
2139 * seen before in the current observation period. */
2140 static hs_usage_service_related_observation_t
*publish_novel
= NULL
;
2142 /** Total number of descriptor fetch requests in the current observation
2144 static hs_usage_service_related_observation_t
*fetch_total
= NULL
;
2146 /** Number of successful descriptor fetch requests in the current
2147 * observation period. */
2148 static hs_usage_service_related_observation_t
*fetch_successful
= NULL
;
2150 /** Number of descriptors stored in the current observation period. */
2151 static hs_usage_general_period_related_observations_t
*descs
= NULL
;
2153 /** Creates an empty ordered list element. */
2154 static hs_usage_list_elem_t
*
2155 hs_usage_list_elem_new(void)
2157 hs_usage_list_elem_t
*e
;
2158 e
= tor_malloc_zero(sizeof(hs_usage_list_elem_t
));
2159 rephist_total_alloc
+= sizeof(hs_usage_list_elem_t
);
2165 /** Creates an empty ordered list. */
2166 static hs_usage_list_t
*
2167 hs_usage_list_new(void)
2170 l
= tor_malloc_zero(sizeof(hs_usage_list_t
));
2171 rephist_total_alloc
+= sizeof(hs_usage_list_t
);
2174 l
->total_service_ids
= 0;
2178 /** Creates an empty structure for storing service-related observations. */
2179 static hs_usage_service_related_observation_t
*
2180 hs_usage_service_related_observation_new(void)
2182 hs_usage_service_related_observation_t
*h
;
2183 h
= tor_malloc_zero(sizeof(hs_usage_service_related_observation_t
));
2184 rephist_total_alloc
+= sizeof(hs_usage_service_related_observation_t
);
2185 h
->list
= hs_usage_list_new();
2189 /** Creates an empty structure for storing general period-related
2191 static hs_usage_general_period_related_observations_t
*
2192 hs_usage_general_period_related_observations_new(void)
2194 hs_usage_general_period_related_observations_t
*p
;
2195 p
= tor_malloc_zero(sizeof(hs_usage_general_period_related_observations_t
));
2196 rephist_total_alloc
+= sizeof(hs_usage_general_period_related_observations_t
);
2200 /** Creates an empty structure for storing period-specific information. */
2201 static hs_usage_current_observation_period_t
*
2202 hs_usage_current_observation_period_new(void)
2204 hs_usage_current_observation_period_t
*c
;
2206 c
= tor_malloc_zero(sizeof(hs_usage_current_observation_period_t
));
2207 rephist_total_alloc
+= sizeof(hs_usage_current_observation_period_t
);
2209 c
->start_of_current_period
= now
;
2210 c
->start_of_next_period
= now
+ NUM_SECS_HS_USAGE_SUM_INTERVAL
;
2214 /** Initializes the structures for collecting hidden service usage data. */
2218 current_period
= hs_usage_current_observation_period_new();
2219 publish_total
= hs_usage_service_related_observation_new();
2220 publish_novel
= hs_usage_service_related_observation_new();
2221 fetch_total
= hs_usage_service_related_observation_new();
2222 fetch_successful
= hs_usage_service_related_observation_new();
2223 descs
= hs_usage_general_period_related_observations_new();
2226 /** Clears the given ordered list by resetting its attributes and releasing
2227 * the memory allocated by its elements. */
2229 hs_usage_list_clear(hs_usage_list_t
*lst
)
2231 /* walk through elements and free memory */
2232 hs_usage_list_elem_t
*current
= lst
->start
;
2233 hs_usage_list_elem_t
*tmp
;
2234 while (current
!= NULL
) {
2235 tmp
= current
->next
;
2236 rephist_total_alloc
-= sizeof(hs_usage_list_elem_t
);
2240 /* reset attributes */
2242 lst
->total_count
= 0;
2243 lst
->total_service_ids
= 0;
2247 /** Frees the memory used by the given list. */
2249 hs_usage_list_free(hs_usage_list_t
*lst
)
2253 hs_usage_list_clear(lst
);
2254 rephist_total_alloc
-= sizeof(hs_usage_list_t
);
2258 /** Frees the memory used by the given service-related observations. */
2260 hs_usage_service_related_observation_free(
2261 hs_usage_service_related_observation_t
*s
)
2265 hs_usage_list_free(s
->list
);
2266 rephist_total_alloc
-= sizeof(hs_usage_service_related_observation_t
);
2270 /** Frees the memory used by the given period-specific observations. */
2272 hs_usage_general_period_related_observations_free(
2273 hs_usage_general_period_related_observations_t
*s
)
2275 rephist_total_alloc
-=sizeof(hs_usage_general_period_related_observations_t
);
2279 /** Frees the memory used by period-specific information. */
2281 hs_usage_current_observation_period_free(
2282 hs_usage_current_observation_period_t
*s
)
2284 rephist_total_alloc
-= sizeof(hs_usage_current_observation_period_t
);
2288 /** Frees all memory that was used for collecting hidden service usage data. */
2290 hs_usage_free_all(void)
2292 hs_usage_general_period_related_observations_free(descs
);
2294 hs_usage_service_related_observation_free(fetch_successful
);
2295 hs_usage_service_related_observation_free(fetch_total
);
2296 hs_usage_service_related_observation_free(publish_novel
);
2297 hs_usage_service_related_observation_free(publish_total
);
2298 fetch_successful
= fetch_total
= publish_novel
= publish_total
= NULL
;
2299 hs_usage_current_observation_period_free(current_period
);
2300 current_period
= NULL
;
2303 /** Inserts a new occurrence for the given service id to the given ordered
2306 hs_usage_insert_value(hs_usage_list_t
*lst
, const char *service_id
)
2308 /* search if there is already an elem with same service_id in list */
2309 hs_usage_list_elem_t
*current
= lst
->start
;
2310 hs_usage_list_elem_t
*previous
= NULL
;
2311 while (current
!= NULL
&& strcasecmp(current
->service_id
,service_id
)) {
2313 current
= current
->next
;
2315 /* found an element with same service_id? */
2316 if (current
== NULL
) {
2317 /* not found! append to end (which could also be the end of a zero-length
2318 * list), don't need to sort (1 is smallest value). */
2320 hs_usage_list_elem_t
*e
= hs_usage_list_elem_new();
2321 /* update list attributes (one new elem, one new occurrence) */
2323 lst
->total_service_ids
++;
2324 /* copy service id to elem */
2325 strlcpy(e
->service_id
,service_id
,sizeof(e
->service_id
));
2326 /* let either l->start or previously last elem point to new elem */
2327 if (lst
->start
== NULL
) {
2328 /* this is the first elem */
2331 /* there were elems in the list before */
2335 /* found! add occurrence to elem and consider resorting */
2336 /* update list attributes (no new elem, but one new occurrence) */
2338 /* add occurrence to elem */
2340 /* is it another than the first list elem? and has previous elem fewer
2341 * count than current? then we need to resort */
2342 if (previous
!= NULL
&& previous
->count
< current
->count
) {
2343 /* yes! we need to resort */
2344 /* remove current elem first */
2345 previous
->next
= current
->next
;
2346 /* can we prepend elem to all other elements? */
2347 if (lst
->start
->count
<= current
->count
) {
2348 /* yes! prepend elem */
2349 current
->next
= lst
->start
;
2350 lst
->start
= current
;
2352 /* no! walk through list a second time and insert at correct place */
2353 hs_usage_list_elem_t
*insert_current
= lst
->start
->next
;
2354 hs_usage_list_elem_t
*insert_previous
= lst
->start
;
2355 while (insert_current
!= NULL
&&
2356 insert_current
->count
> current
->count
) {
2357 insert_previous
= insert_current
;
2358 insert_current
= insert_current
->next
;
2361 current
->next
= insert_current
;
2362 insert_previous
->next
= current
;
2368 /** Writes the current service-related observations to the history array and
2369 * clears the observations of the current period. */
2371 hs_usage_write_service_related_observations_to_history(
2372 hs_usage_current_observation_period_t
*p
,
2373 hs_usage_service_related_observation_t
*h
)
2375 /* walk through the first 20 % of list elements and calculate frequency
2377 /* maximum indices for the three frequencies */
2378 int five_percent_idx
= h
->list
->total_service_ids
/20;
2379 int ten_percent_idx
= h
->list
->total_service_ids
/10;
2380 int twenty_percent_idx
= h
->list
->total_service_ids
/5;
2382 uint32_t five_percent
= 0;
2383 uint32_t ten_percent
= 0;
2384 uint32_t twenty_percent
= 0;
2385 /* walk through list */
2386 hs_usage_list_elem_t
*current
= h
->list
->start
;
2388 while (current
!= NULL
&& i
<= twenty_percent_idx
) {
2389 twenty_percent
+= current
->count
;
2390 if (i
<= ten_percent_idx
)
2391 ten_percent
+= current
->count
;
2392 if (i
<= five_percent_idx
)
2393 five_percent
+= current
->count
;
2394 current
= current
->next
;
2397 /* copy frequencies */
2398 h
->twenty
[p
->next_idx
] = twenty_percent
;
2399 h
->ten
[p
->next_idx
] = ten_percent
;
2400 h
->five
[p
->next_idx
] = five_percent
;
2401 /* copy total number of observations */
2402 h
->totals
[p
->next_idx
] = h
->list
->total_count
;
2403 /* free memory of old list */
2404 hs_usage_list_clear(h
->list
);
2407 /** Advances to next observation period. */
2409 hs_usage_advance_current_observation_period(void)
2411 /* aggregate observations to history, including frequency distribution
2413 hs_usage_write_service_related_observations_to_history(
2414 current_period
, publish_total
);
2415 hs_usage_write_service_related_observations_to_history(
2416 current_period
, publish_novel
);
2417 hs_usage_write_service_related_observations_to_history(
2418 current_period
, fetch_total
);
2419 hs_usage_write_service_related_observations_to_history(
2420 current_period
, fetch_successful
);
2421 /* write current number of descriptors to descs history */
2422 descs
->totals
[current_period
->next_idx
] = rend_cache_size();
2423 /* advance to next period */
2424 current_period
->next_idx
++;
2425 if (current_period
->next_idx
== NUM_TOTALS_HS_USAGE
)
2426 current_period
->next_idx
= 0;
2427 if (current_period
->num_set
< NUM_TOTALS_HS_USAGE
)
2428 ++current_period
->num_set
;
2429 current_period
->start_of_current_period
=current_period
->start_of_next_period
;
2430 current_period
->start_of_next_period
+= NUM_SECS_HS_USAGE_SUM_INTERVAL
;
2433 /** Checks if the current period is up to date, and if not, advances it. */
2435 hs_usage_check_if_current_period_is_up_to_date(time_t now
)
2437 while (now
> current_period
->start_of_next_period
) {
2438 hs_usage_advance_current_observation_period();
2442 /** Adds a service-related observation, maybe after advancing to next
2443 * observation period. */
2445 hs_usage_add_service_related_observation(
2446 hs_usage_service_related_observation_t
*h
,
2448 const char *service_id
)
2450 if (now
< current_period
->start_of_current_period
) {
2451 /* don't record old data */
2454 /* check if we are up-to-date */
2455 hs_usage_check_if_current_period_is_up_to_date(now
);
2456 /* add observation */
2457 hs_usage_insert_value(h
->list
, service_id
);
2460 /** Adds the observation of storing a rendezvous service descriptor to our
2461 * cache in our role as HS authoritative directory. */
2463 hs_usage_note_publish_total(const char *service_id
, time_t now
)
2465 hs_usage_add_service_related_observation(publish_total
, now
, service_id
);
2468 /** Adds the observation of storing a novel rendezvous service descriptor to
2469 * our cache in our role as HS authoritative directory. */
2471 hs_usage_note_publish_novel(const char *service_id
, time_t now
)
2473 hs_usage_add_service_related_observation(publish_novel
, now
, service_id
);
2476 /** Adds the observation of being requested for a rendezvous service descriptor
2477 * in our role as HS authoritative directory. */
2479 hs_usage_note_fetch_total(const char *service_id
, time_t now
)
2481 hs_usage_add_service_related_observation(fetch_total
, now
, service_id
);
2484 /** Adds the observation of being requested for a rendezvous service descriptor
2485 * in our role as HS authoritative directory and being able to answer that
2486 * request successfully. */
2488 hs_usage_note_fetch_successful(const char *service_id
, time_t now
)
2490 hs_usage_add_service_related_observation(fetch_successful
, now
, service_id
);
2493 /** Writes the given circular array to a string. */
2495 hs_usage_format_history(char *buf
, size_t len
, uint32_t *data
)
2497 char *cp
= buf
; /* pointer where we are in the buffer */
2499 if (current_period
->num_set
<= current_period
->next_idx
) {
2500 i
= 0; /* not been through circular array */
2502 i
= current_period
->next_idx
;
2504 for (n
= 0; n
< current_period
->num_set
; ++n
,++i
) {
2505 if (i
>= NUM_TOTALS_HS_USAGE
)
2506 i
-= NUM_TOTALS_HS_USAGE
;
2507 tor_assert(i
< NUM_TOTALS_HS_USAGE
);
2508 if (n
== (current_period
->num_set
-1))
2509 tor_snprintf(cp
, len
-(cp
-buf
), "%d", data
[i
]);
2511 tor_snprintf(cp
, len
-(cp
-buf
), "%d,", data
[i
]);
2517 /** Writes the complete usage history as hidden service authoritative directory
2520 hs_usage_format_statistics(void)
2522 char *buf
, *cp
, *s
= NULL
;
2523 char t
[ISO_TIME_LEN
+1];
2525 uint32_t *data
= NULL
;
2527 len
= (70+20*NUM_TOTALS_HS_USAGE
)*11;
2528 buf
= tor_malloc_zero(len
);
2530 for (r
= 0; r
< 11; ++r
) {
2533 s
= (char*) "publish-total-history";
2534 data
= publish_total
->totals
;
2537 s
= (char*) "publish-novel-history";
2538 data
= publish_novel
->totals
;
2541 s
= (char*) "publish-top-5-percent-history";
2542 data
= publish_total
->five
;
2545 s
= (char*) "publish-top-10-percent-history";
2546 data
= publish_total
->ten
;
2549 s
= (char*) "publish-top-20-percent-history";
2550 data
= publish_total
->twenty
;
2553 s
= (char*) "fetch-total-history";
2554 data
= fetch_total
->totals
;
2557 s
= (char*) "fetch-successful-history";
2558 data
= fetch_successful
->totals
;
2561 s
= (char*) "fetch-top-5-percent-history";
2562 data
= fetch_total
->five
;
2565 s
= (char*) "fetch-top-10-percent-history";
2566 data
= fetch_total
->ten
;
2569 s
= (char*) "fetch-top-20-percent-history";
2570 data
= fetch_total
->twenty
;
2573 s
= (char*) "desc-total-history";
2574 data
= descs
->totals
;
2577 format_iso_time(t
, current_period
->start_of_current_period
);
2578 tor_snprintf(cp
, len
-(cp
-buf
), "%s %s (%d s) ", s
, t
,
2579 NUM_SECS_HS_USAGE_SUM_INTERVAL
);
2581 cp
+= hs_usage_format_history(cp
, len
-(cp
-buf
), data
);
2582 strlcat(cp
, "\n", len
-(cp
-buf
));
2588 /** Write current statistics about hidden service usage to file. */
2590 hs_usage_write_statistics_to_file(time_t now
)
2595 or_options_t
*options
= get_options();
2596 /* check if we are up-to-date */
2597 hs_usage_check_if_current_period_is_up_to_date(now
);
2598 buf
= hs_usage_format_statistics();
2599 len
= strlen(options
->DataDirectory
) + 16;
2600 fname
= tor_malloc(len
);
2601 tor_snprintf(fname
, len
, "%s"PATH_SEPARATOR
"hsusage",
2602 options
->DataDirectory
);
2603 write_str_to_file(fname
,buf
,0);
2608 /*** cell statistics ***/
2610 /** Start of the current buffer stats interval. */
2611 static time_t start_of_buffer_stats_interval
;
2613 /** Initialize buffer stats. */
2615 rep_hist_buffer_stats_init(time_t now
)
2617 start_of_buffer_stats_interval
= now
;
2620 typedef struct circ_buffer_stats_t
{
2621 uint32_t processed_cells
;
2622 double mean_num_cells_in_queue
;
2623 double mean_time_cells_in_queue
;
2624 uint32_t local_circ_id
;
2625 } circ_buffer_stats_t
;
2628 smartlist_t
*circuits_for_buffer_stats
= NULL
;
2630 /** Remember cell statistics for circuit <b>circ</b> at time
2631 * <b>end_of_interval</b> and reset cell counters in case the circuit
2632 * remains open in the next measurement interval. */
2634 rep_hist_buffer_stats_add_circ(circuit_t
*circ
, time_t end_of_interval
)
2636 circ_buffer_stats_t
*stat
;
2637 time_t start_of_interval
;
2638 int interval_length
;
2639 or_circuit_t
*orcirc
;
2640 if (CIRCUIT_IS_ORIGIN(circ
))
2642 orcirc
= TO_OR_CIRCUIT(circ
);
2643 if (!orcirc
->processed_cells
)
2645 if (!circuits_for_buffer_stats
)
2646 circuits_for_buffer_stats
= smartlist_create();
2647 start_of_interval
= circ
->timestamp_created
>
2648 start_of_buffer_stats_interval
?
2649 circ
->timestamp_created
:
2650 start_of_buffer_stats_interval
;
2651 interval_length
= (int) (end_of_interval
- start_of_interval
);
2652 stat
= tor_malloc_zero(sizeof(circ_buffer_stats_t
));
2653 stat
->processed_cells
= orcirc
->processed_cells
;
2654 /* 1000.0 for s -> ms; 2.0 because of app-ward and exit-ward queues */
2655 stat
->mean_num_cells_in_queue
= interval_length
== 0 ? 0.0 :
2656 (double) orcirc
->total_cell_waiting_time
/
2657 (double) interval_length
/ 1000.0 / 2.0;
2658 stat
->mean_time_cells_in_queue
=
2659 (double) orcirc
->total_cell_waiting_time
/
2660 (double) orcirc
->processed_cells
;
2661 smartlist_add(circuits_for_buffer_stats
, stat
);
2662 orcirc
->total_cell_waiting_time
= 0;
2663 orcirc
->processed_cells
= 0;
2666 /** Sorting helper: return -1, 1, or 0 based on comparison of two
2667 * circ_buffer_stats_t */
2669 _buffer_stats_compare_entries(const void **_a
, const void **_b
)
2671 const circ_buffer_stats_t
*a
= *_a
, *b
= *_b
;
2672 if (a
->processed_cells
< b
->processed_cells
)
2674 else if (a
->processed_cells
> b
->processed_cells
)
2680 /** Write buffer statistics to $DATADIR/stats/buffer-stats. */
2682 rep_hist_buffer_stats_write(time_t now
)
2684 char *statsdir
= NULL
, *filename
= NULL
;
2685 char written
[ISO_TIME_LEN
+1];
2686 open_file_t
*open_file
= NULL
;
2689 int processed_cells
[SHARES
], circs_in_share
[SHARES
],
2690 number_of_circuits
, i
;
2691 double queued_cells
[SHARES
], time_in_queue
[SHARES
];
2692 smartlist_t
*str_build
= smartlist_create();
2696 /* add current circuits to stats */
2697 for (circ
= _circuit_get_global_list(); circ
; circ
= circ
->next
)
2698 rep_hist_buffer_stats_add_circ(circ
, now
);
2699 /* calculate deciles */
2700 memset(processed_cells
, 0, SHARES
* sizeof(int));
2701 memset(circs_in_share
, 0, SHARES
* sizeof(int));
2702 memset(queued_cells
, 0, SHARES
* sizeof(double));
2703 memset(time_in_queue
, 0, SHARES
* sizeof(double));
2704 smartlist_sort(circuits_for_buffer_stats
,
2705 _buffer_stats_compare_entries
);
2706 number_of_circuits
= smartlist_len(circuits_for_buffer_stats
);
2708 SMARTLIST_FOREACH_BEGIN(circuits_for_buffer_stats
,
2709 circ_buffer_stats_t
*, stat
)
2711 int share
= i
++ * SHARES
/ number_of_circuits
;
2712 processed_cells
[share
] += stat
->processed_cells
;
2713 queued_cells
[share
] += stat
->mean_num_cells_in_queue
;
2714 time_in_queue
[share
] += stat
->mean_time_cells_in_queue
;
2715 circs_in_share
[share
]++;
2717 SMARTLIST_FOREACH_END(stat
);
2718 /* clear buffer stats history */
2719 SMARTLIST_FOREACH(circuits_for_buffer_stats
, circ_buffer_stats_t
*,
2720 stat
, tor_free(stat
));
2721 smartlist_clear(circuits_for_buffer_stats
);
2723 statsdir
= get_datadir_fname("stats");
2724 if (check_private_dir(statsdir
, CPD_CREATE
) < 0)
2726 filename
= get_datadir_fname("stats"PATH_SEPARATOR
"buffer-stats");
2727 out
= start_writing_to_stdio_file(filename
, OPEN_FLAGS_APPEND
,
2731 format_iso_time(written
, now
);
2732 if (fprintf(out
, "cell-stats-end %s (%d s)\n", written
,
2733 (unsigned) (now
- start_of_buffer_stats_interval
)) < 0)
2735 for (i
= 0; i
< SHARES
; i
++) {
2736 tor_snprintf(buf
, sizeof(buf
), "%d", !circs_in_share
[i
] ? 0 :
2737 processed_cells
[i
] / circs_in_share
[i
]);
2738 smartlist_add(str_build
, tor_strdup(buf
));
2740 str
= smartlist_join_strings(str_build
, ",", 0, NULL
);
2741 if (fprintf(out
, "cell-processed-cells %s\n", str
) < 0)
2744 SMARTLIST_FOREACH(str_build
, char *, c
, tor_free(c
));
2745 smartlist_clear(str_build
);
2746 for (i
= 0; i
< SHARES
; i
++) {
2747 tor_snprintf(buf
, sizeof(buf
), "%.2f", circs_in_share
[i
] == 0 ? 0.0 :
2748 queued_cells
[i
] / (double) circs_in_share
[i
]);
2749 smartlist_add(str_build
, tor_strdup(buf
));
2751 str
= smartlist_join_strings(str_build
, ",", 0, NULL
);
2752 if (fprintf(out
, "cell-queued-cells %s\n", str
) < 0)
2755 SMARTLIST_FOREACH(str_build
, char *, c
, tor_free(c
));
2756 smartlist_clear(str_build
);
2757 for (i
= 0; i
< SHARES
; i
++) {
2758 tor_snprintf(buf
, sizeof(buf
), "%.0f", circs_in_share
[i
] == 0 ? 0.0 :
2759 time_in_queue
[i
] / (double) circs_in_share
[i
]);
2760 smartlist_add(str_build
, tor_strdup(buf
));
2762 str
= smartlist_join_strings(str_build
, ",", 0, NULL
);
2763 if (fprintf(out
, "cell-time-in-queue %s\n", str
) < 0)
2766 SMARTLIST_FOREACH(str_build
, char *, c
, tor_free(c
));
2767 smartlist_free(str_build
);
2769 if (fprintf(out
, "cell-circuits-per-decile %d\n",
2770 (number_of_circuits
+ SHARES
- 1) / SHARES
) < 0)
2772 finish_writing_to_file(open_file
);
2774 start_of_buffer_stats_interval
= now
;
2777 abort_writing_to_file(open_file
);
2781 SMARTLIST_FOREACH(str_build
, char *, c
, tor_free(c
));
2782 smartlist_free(str_build
);