hibernate.c 35 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060
  1. /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  2. * Copyright (c) 2007-2015, The Tor Project, Inc. */
  3. /* See LICENSE for licensing information */
  4. /**
  5. * \file hibernate.c
  6. * \brief Functions to close listeners, stop allowing new circuits,
  7. * etc in preparation for closing down or going dormant; and to track
  8. * bandwidth and time intervals to know when to hibernate and when to
  9. * stop hibernating.
  10. **/
  11. /*
  12. hibernating, phase 1:
  13. - send destroy in response to create cells
  14. - send end (policy failed) in response to begin cells
  15. - close an OR conn when it has no circuits
  16. hibernating, phase 2:
  17. (entered when bandwidth hard limit reached)
  18. - close all OR/AP/exit conns)
  19. */
  20. #define HIBERNATE_PRIVATE
  21. #include "or.h"
  22. #include "channel.h"
  23. #include "channeltls.h"
  24. #include "config.h"
  25. #include "connection.h"
  26. #include "connection_edge.h"
  27. #include "hibernate.h"
  28. #include "main.h"
  29. #include "router.h"
  30. #include "statefile.h"
  31. extern long stats_n_seconds_working; /* published uptime */
  32. /** Are we currently awake, asleep, running out of bandwidth, or shutting
  33. * down? */
  34. static hibernate_state_t hibernate_state = HIBERNATE_STATE_INITIAL;
  35. /** If are hibernating, when do we plan to wake up? Set to 0 if we
  36. * aren't hibernating. */
  37. static time_t hibernate_end_time = 0;
  38. /** If we are shutting down, when do we plan finally exit? Set to 0 if
  39. * we aren't shutting down. */
  40. static time_t shutdown_time = 0;
  41. /** Possible accounting periods. */
  42. typedef enum {
  43. UNIT_MONTH=1, UNIT_WEEK=2, UNIT_DAY=3,
  44. } time_unit_t;
  45. /* Fields for accounting logic. Accounting overview:
  46. *
  47. * Accounting is designed to ensure that no more than N bytes are sent in
  48. * either direction over a given interval (currently, one month, one week, or
  49. * one day) We could
  50. * try to do this by choking our bandwidth to a trickle, but that
  51. * would make our streams useless. Instead, we estimate what our
  52. * bandwidth usage will be, and guess how long we'll be able to
  53. * provide that much bandwidth before hitting our limit. We then
  54. * choose a random time within the accounting interval to come up (so
  55. * that we don't get 50 Tors running on the 1st of the month and none
  56. * on the 30th).
  57. *
  58. * Each interval runs as follows:
  59. *
  60. * 1. We guess our bandwidth usage, based on how much we used
  61. * last time. We choose a "wakeup time" within the interval to come up.
  62. * 2. Until the chosen wakeup time, we hibernate.
  63. * 3. We come up at the wakeup time, and provide bandwidth until we are
  64. * "very close" to running out.
  65. * 4. Then we go into low-bandwidth mode, and stop accepting new
  66. * connections, but provide bandwidth until we run out.
  67. * 5. Then we hibernate until the end of the interval.
  68. *
  69. * If the interval ends before we run out of bandwidth, we go back to
  70. * step one.
  71. */
  72. /** How many bytes have we read in this accounting interval? */
  73. static uint64_t n_bytes_read_in_interval = 0;
  74. /** How many bytes have we written in this accounting interval? */
  75. static uint64_t n_bytes_written_in_interval = 0;
  76. /** How many seconds have we been running this interval? */
  77. static uint32_t n_seconds_active_in_interval = 0;
  78. /** How many seconds were we active in this interval before we hit our soft
  79. * limit? */
  80. static int n_seconds_to_hit_soft_limit = 0;
  81. /** When in this interval was the soft limit hit. */
  82. static time_t soft_limit_hit_at = 0;
  83. /** How many bytes had we read/written when we hit the soft limit? */
  84. static uint64_t n_bytes_at_soft_limit = 0;
  85. /** When did this accounting interval start? */
  86. static time_t interval_start_time = 0;
  87. /** When will this accounting interval end? */
  88. static time_t interval_end_time = 0;
  89. /** How far into the accounting interval should we hibernate? */
  90. static time_t interval_wakeup_time = 0;
  91. /** How much bandwidth do we 'expect' to use per minute? (0 if we have no
  92. * info from the last period.) */
  93. static uint64_t expected_bandwidth_usage = 0;
  94. /** What unit are we using for our accounting? */
  95. static time_unit_t cfg_unit = UNIT_MONTH;
  96. /** How many days,hours,minutes into each unit does our accounting interval
  97. * start? */
  98. /** @{ */
  99. static int cfg_start_day = 0,
  100. cfg_start_hour = 0,
  101. cfg_start_min = 0;
  102. /** @} */
  103. static void reset_accounting(time_t now);
  104. static int read_bandwidth_usage(void);
  105. static time_t start_of_accounting_period_after(time_t now);
  106. static time_t start_of_accounting_period_containing(time_t now);
  107. static void accounting_set_wakeup_time(void);
  108. /* ************
  109. * Functions for bandwidth accounting.
  110. * ************/
  111. /** Configure accounting start/end time settings based on
  112. * options->AccountingStart. Return 0 on success, -1 on failure. If
  113. * <b>validate_only</b> is true, do not change the current settings. */
  114. int
  115. accounting_parse_options(const or_options_t *options, int validate_only)
  116. {
  117. time_unit_t unit;
  118. int ok, idx;
  119. long d,h,m;
  120. smartlist_t *items;
  121. const char *v = options->AccountingStart;
  122. const char *s;
  123. char *cp;
  124. if (!v) {
  125. if (!validate_only) {
  126. cfg_unit = UNIT_MONTH;
  127. cfg_start_day = 1;
  128. cfg_start_hour = 0;
  129. cfg_start_min = 0;
  130. }
  131. return 0;
  132. }
  133. items = smartlist_new();
  134. smartlist_split_string(items, v, NULL,
  135. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK,0);
  136. if (smartlist_len(items)<2) {
  137. log_warn(LD_CONFIG, "Too few arguments to AccountingStart");
  138. goto err;
  139. }
  140. s = smartlist_get(items,0);
  141. if (0==strcasecmp(s, "month")) {
  142. unit = UNIT_MONTH;
  143. } else if (0==strcasecmp(s, "week")) {
  144. unit = UNIT_WEEK;
  145. } else if (0==strcasecmp(s, "day")) {
  146. unit = UNIT_DAY;
  147. } else {
  148. log_warn(LD_CONFIG,
  149. "Unrecognized accounting unit '%s': only 'month', 'week',"
  150. " and 'day' are supported.", s);
  151. goto err;
  152. }
  153. switch (unit) {
  154. case UNIT_WEEK:
  155. d = tor_parse_long(smartlist_get(items,1), 10, 1, 7, &ok, NULL);
  156. if (!ok) {
  157. log_warn(LD_CONFIG, "Weekly accounting must begin on a day between "
  158. "1 (Monday) and 7 (Sunday)");
  159. goto err;
  160. }
  161. break;
  162. case UNIT_MONTH:
  163. d = tor_parse_long(smartlist_get(items,1), 10, 1, 28, &ok, NULL);
  164. if (!ok) {
  165. log_warn(LD_CONFIG, "Monthly accounting must begin on a day between "
  166. "1 and 28");
  167. goto err;
  168. }
  169. break;
  170. case UNIT_DAY:
  171. d = 0;
  172. break;
  173. /* Coverity dislikes unreachable default cases; some compilers warn on
  174. * switch statements missing a case. Tell Coverity not to worry. */
  175. /* coverity[dead_error_begin] */
  176. default:
  177. tor_assert(0);
  178. }
  179. idx = unit==UNIT_DAY?1:2;
  180. if (smartlist_len(items) != (idx+1)) {
  181. log_warn(LD_CONFIG,"Accounting unit '%s' requires %d argument%s.",
  182. s, idx, (idx>1)?"s":"");
  183. goto err;
  184. }
  185. s = smartlist_get(items, idx);
  186. h = tor_parse_long(s, 10, 0, 23, &ok, &cp);
  187. if (!ok) {
  188. log_warn(LD_CONFIG,"Accounting start time not parseable: bad hour.");
  189. goto err;
  190. }
  191. if (!cp || *cp!=':') {
  192. log_warn(LD_CONFIG,
  193. "Accounting start time not parseable: not in HH:MM format");
  194. goto err;
  195. }
  196. m = tor_parse_long(cp+1, 10, 0, 59, &ok, &cp);
  197. if (!ok) {
  198. log_warn(LD_CONFIG, "Accounting start time not parseable: bad minute");
  199. goto err;
  200. }
  201. if (!cp || *cp!='\0') {
  202. log_warn(LD_CONFIG,
  203. "Accounting start time not parseable: not in HH:MM format");
  204. goto err;
  205. }
  206. if (!validate_only) {
  207. cfg_unit = unit;
  208. cfg_start_day = (int)d;
  209. cfg_start_hour = (int)h;
  210. cfg_start_min = (int)m;
  211. }
  212. SMARTLIST_FOREACH(items, char *, item, tor_free(item));
  213. smartlist_free(items);
  214. return 0;
  215. err:
  216. SMARTLIST_FOREACH(items, char *, item, tor_free(item));
  217. smartlist_free(items);
  218. return -1;
  219. }
  220. /** If we want to manage the accounting system and potentially
  221. * hibernate, return 1, else return 0.
  222. */
  223. MOCK_IMPL(int,
  224. accounting_is_enabled,(const or_options_t *options))
  225. {
  226. if (options->AccountingMax)
  227. return 1;
  228. return 0;
  229. }
  230. /** If accounting is enabled, return how long (in seconds) this
  231. * interval lasts. */
  232. int
  233. accounting_get_interval_length(void)
  234. {
  235. return (int)(interval_end_time - interval_start_time);
  236. }
  237. /** Return the time at which the current accounting interval will end. */
  238. MOCK_IMPL(time_t,
  239. accounting_get_end_time,(void))
  240. {
  241. return interval_end_time;
  242. }
  243. /** Called from main.c to tell us that <b>seconds</b> seconds have
  244. * passed, <b>n_read</b> bytes have been read, and <b>n_written</b>
  245. * bytes have been written. */
  246. void
  247. accounting_add_bytes(size_t n_read, size_t n_written, int seconds)
  248. {
  249. n_bytes_read_in_interval += n_read;
  250. n_bytes_written_in_interval += n_written;
  251. /* If we haven't been called in 10 seconds, we're probably jumping
  252. * around in time. */
  253. n_seconds_active_in_interval += (seconds < 10) ? seconds : 0;
  254. }
  255. /** If get_end, return the end of the accounting period that contains
  256. * the time <b>now</b>. Else, return the start of the accounting
  257. * period that contains the time <b>now</b> */
  258. static time_t
  259. edge_of_accounting_period_containing(time_t now, int get_end)
  260. {
  261. int before;
  262. struct tm tm;
  263. tor_localtime_r(&now, &tm);
  264. /* Set 'before' to true iff the current time is before the hh:mm
  265. * changeover time for today. */
  266. before = tm.tm_hour < cfg_start_hour ||
  267. (tm.tm_hour == cfg_start_hour && tm.tm_min < cfg_start_min);
  268. /* Dispatch by unit. First, find the start day of the given period;
  269. * then, if get_end is true, increment to the end day. */
  270. switch (cfg_unit)
  271. {
  272. case UNIT_MONTH: {
  273. /* If this is before the Nth, we want the Nth of last month. */
  274. if (tm.tm_mday < cfg_start_day ||
  275. (tm.tm_mday < cfg_start_day && before)) {
  276. --tm.tm_mon;
  277. }
  278. /* Otherwise, the month is correct. */
  279. tm.tm_mday = cfg_start_day;
  280. if (get_end)
  281. ++tm.tm_mon;
  282. break;
  283. }
  284. case UNIT_WEEK: {
  285. /* What is the 'target' day of the week in struct tm format? (We
  286. say Sunday==7; struct tm says Sunday==0.) */
  287. int wday = cfg_start_day % 7;
  288. /* How many days do we subtract from today to get to the right day? */
  289. int delta = (7+tm.tm_wday-wday)%7;
  290. /* If we are on the right day, but the changeover hasn't happened yet,
  291. * then subtract a whole week. */
  292. if (delta == 0 && before)
  293. delta = 7;
  294. tm.tm_mday -= delta;
  295. if (get_end)
  296. tm.tm_mday += 7;
  297. break;
  298. }
  299. case UNIT_DAY:
  300. if (before)
  301. --tm.tm_mday;
  302. if (get_end)
  303. ++tm.tm_mday;
  304. break;
  305. default:
  306. tor_assert(0);
  307. }
  308. tm.tm_hour = cfg_start_hour;
  309. tm.tm_min = cfg_start_min;
  310. tm.tm_sec = 0;
  311. tm.tm_isdst = -1; /* Autodetect DST */
  312. return mktime(&tm);
  313. }
  314. /** Return the start of the accounting period containing the time
  315. * <b>now</b>. */
  316. static time_t
  317. start_of_accounting_period_containing(time_t now)
  318. {
  319. return edge_of_accounting_period_containing(now, 0);
  320. }
  321. /** Return the start of the accounting period that comes after the one
  322. * containing the time <b>now</b>. */
  323. static time_t
  324. start_of_accounting_period_after(time_t now)
  325. {
  326. return edge_of_accounting_period_containing(now, 1);
  327. }
  328. /** Return the length of the accounting period containing the time
  329. * <b>now</b>. */
  330. static long
  331. length_of_accounting_period_containing(time_t now)
  332. {
  333. return edge_of_accounting_period_containing(now, 1) -
  334. edge_of_accounting_period_containing(now, 0);
  335. }
  336. /** Initialize the accounting subsystem. */
  337. void
  338. configure_accounting(time_t now)
  339. {
  340. time_t s_now;
  341. /* Try to remember our recorded usage. */
  342. if (!interval_start_time)
  343. read_bandwidth_usage(); /* If we fail, we'll leave values at zero, and
  344. * reset below.*/
  345. s_now = start_of_accounting_period_containing(now);
  346. if (!interval_start_time) {
  347. /* We didn't have recorded usage; Start a new interval. */
  348. log_info(LD_ACCT, "Starting new accounting interval.");
  349. reset_accounting(now);
  350. } else if (s_now == interval_start_time) {
  351. log_info(LD_ACCT, "Continuing accounting interval.");
  352. /* We are in the interval we thought we were in. Do nothing.*/
  353. interval_end_time = start_of_accounting_period_after(interval_start_time);
  354. } else {
  355. long duration =
  356. length_of_accounting_period_containing(interval_start_time);
  357. double delta = ((double)(s_now - interval_start_time)) / duration;
  358. if (-0.50 <= delta && delta <= 0.50) {
  359. /* The start of the period is now a little later or earlier than we
  360. * remembered. That's fine; we might lose some bytes we could otherwise
  361. * have written, but better to err on the side of obeying people's
  362. * accounting settings. */
  363. log_info(LD_ACCT, "Accounting interval moved by %.02f%%; "
  364. "that's fine.", delta*100);
  365. interval_end_time = start_of_accounting_period_after(now);
  366. } else if (delta >= 0.99) {
  367. /* This is the regular time-moved-forward case; don't be too noisy
  368. * about it or people will complain */
  369. log_info(LD_ACCT, "Accounting interval elapsed; starting a new one");
  370. reset_accounting(now);
  371. } else {
  372. log_warn(LD_ACCT,
  373. "Mismatched accounting interval: moved by %.02f%%. "
  374. "Starting a fresh one.", delta*100);
  375. reset_accounting(now);
  376. }
  377. }
  378. accounting_set_wakeup_time();
  379. }
  380. /** Return the relevant number of bytes sent/received this interval
  381. * based on the set AccountingRule */
  382. static uint64_t
  383. get_accounting_bytes(void)
  384. {
  385. if (get_options()->AccountingRule == ACCT_SUM)
  386. return n_bytes_read_in_interval+n_bytes_written_in_interval;
  387. else
  388. return MAX(n_bytes_read_in_interval, n_bytes_written_in_interval);
  389. }
  390. /** Set expected_bandwidth_usage based on how much we sent/received
  391. * per minute last interval (if we were up for at least 30 minutes),
  392. * or based on our declared bandwidth otherwise. */
  393. static void
  394. update_expected_bandwidth(void)
  395. {
  396. uint64_t expected;
  397. const or_options_t *options= get_options();
  398. uint64_t max_configured = (options->RelayBandwidthRate > 0 ?
  399. options->RelayBandwidthRate :
  400. options->BandwidthRate) * 60;
  401. /* max_configured is the larger of bytes read and bytes written
  402. * If we are accounting based on sum, worst case is both are
  403. * at max, doubling the expected sum of bandwidth */
  404. if (get_options()->AccountingRule == ACCT_SUM)
  405. max_configured *= 2;
  406. #define MIN_TIME_FOR_MEASUREMENT (1800)
  407. if (soft_limit_hit_at > interval_start_time && n_bytes_at_soft_limit &&
  408. (soft_limit_hit_at - interval_start_time) > MIN_TIME_FOR_MEASUREMENT) {
  409. /* If we hit our soft limit last time, only count the bytes up to that
  410. * time. This is a better predictor of our actual bandwidth than
  411. * considering the entirety of the last interval, since we likely started
  412. * using bytes very slowly once we hit our soft limit. */
  413. expected = n_bytes_at_soft_limit /
  414. (soft_limit_hit_at - interval_start_time);
  415. expected /= 60;
  416. } else if (n_seconds_active_in_interval >= MIN_TIME_FOR_MEASUREMENT) {
  417. /* Otherwise, we either measured enough time in the last interval but
  418. * never hit our soft limit, or we're using a state file from a Tor that
  419. * doesn't know to store soft-limit info. Just take rate at which
  420. * we were reading/writing in the last interval as our expected rate.
  421. */
  422. uint64_t used = get_accounting_bytes();
  423. expected = used / (n_seconds_active_in_interval / 60);
  424. } else {
  425. /* If we haven't gotten enough data last interval, set 'expected'
  426. * to 0. This will set our wakeup to the start of the interval.
  427. * Next interval, we'll choose our starting time based on how much
  428. * we sent this interval.
  429. */
  430. expected = 0;
  431. }
  432. if (expected > max_configured)
  433. expected = max_configured;
  434. expected_bandwidth_usage = expected;
  435. }
  436. /** Called at the start of a new accounting interval: reset our
  437. * expected bandwidth usage based on what happened last time, set up
  438. * the start and end of the interval, and clear byte/time totals.
  439. */
  440. static void
  441. reset_accounting(time_t now)
  442. {
  443. log_info(LD_ACCT, "Starting new accounting interval.");
  444. update_expected_bandwidth();
  445. interval_start_time = start_of_accounting_period_containing(now);
  446. interval_end_time = start_of_accounting_period_after(interval_start_time);
  447. n_bytes_read_in_interval = 0;
  448. n_bytes_written_in_interval = 0;
  449. n_seconds_active_in_interval = 0;
  450. n_bytes_at_soft_limit = 0;
  451. soft_limit_hit_at = 0;
  452. n_seconds_to_hit_soft_limit = 0;
  453. }
  454. /** Return true iff we should save our bandwidth usage to disk. */
  455. static INLINE int
  456. time_to_record_bandwidth_usage(time_t now)
  457. {
  458. /* Note every 600 sec */
  459. #define NOTE_INTERVAL (600)
  460. /* Or every 20 megabytes */
  461. #define NOTE_BYTES 20*(1024*1024)
  462. static uint64_t last_read_bytes_noted = 0;
  463. static uint64_t last_written_bytes_noted = 0;
  464. static time_t last_time_noted = 0;
  465. if (last_time_noted + NOTE_INTERVAL <= now ||
  466. last_read_bytes_noted + NOTE_BYTES <= n_bytes_read_in_interval ||
  467. last_written_bytes_noted + NOTE_BYTES <= n_bytes_written_in_interval ||
  468. (interval_end_time && interval_end_time <= now)) {
  469. last_time_noted = now;
  470. last_read_bytes_noted = n_bytes_read_in_interval;
  471. last_written_bytes_noted = n_bytes_written_in_interval;
  472. return 1;
  473. }
  474. return 0;
  475. }
  476. /** Invoked once per second. Checks whether it is time to hibernate,
  477. * record bandwidth used, etc. */
  478. void
  479. accounting_run_housekeeping(time_t now)
  480. {
  481. if (now >= interval_end_time) {
  482. configure_accounting(now);
  483. }
  484. if (time_to_record_bandwidth_usage(now)) {
  485. if (accounting_record_bandwidth_usage(now, get_or_state())) {
  486. log_warn(LD_FS, "Couldn't record bandwidth usage to disk.");
  487. }
  488. }
  489. }
  490. /** Based on our interval and our estimated bandwidth, choose a
  491. * deterministic (but random-ish) time to wake up. */
  492. static void
  493. accounting_set_wakeup_time(void)
  494. {
  495. char digest[DIGEST_LEN];
  496. crypto_digest_t *d_env;
  497. uint64_t time_to_exhaust_bw;
  498. int time_to_consider;
  499. if (! server_identity_key_is_set()) {
  500. if (init_keys() < 0) {
  501. log_err(LD_BUG, "Error initializing keys");
  502. tor_assert(0);
  503. }
  504. }
  505. if (server_identity_key_is_set()) {
  506. char buf[ISO_TIME_LEN+1];
  507. format_iso_time(buf, interval_start_time);
  508. crypto_pk_get_digest(get_server_identity_key(), digest);
  509. d_env = crypto_digest_new();
  510. crypto_digest_add_bytes(d_env, buf, ISO_TIME_LEN);
  511. crypto_digest_add_bytes(d_env, digest, DIGEST_LEN);
  512. crypto_digest_get_digest(d_env, digest, DIGEST_LEN);
  513. crypto_digest_free(d_env);
  514. } else {
  515. crypto_rand(digest, DIGEST_LEN);
  516. }
  517. if (!expected_bandwidth_usage) {
  518. char buf1[ISO_TIME_LEN+1];
  519. char buf2[ISO_TIME_LEN+1];
  520. format_local_iso_time(buf1, interval_start_time);
  521. format_local_iso_time(buf2, interval_end_time);
  522. interval_wakeup_time = interval_start_time;
  523. log_notice(LD_ACCT,
  524. "Configured hibernation. This interval begins at %s "
  525. "and ends at %s. We have no prior estimate for bandwidth, so "
  526. "we will start out awake and hibernate when we exhaust our quota.",
  527. buf1, buf2);
  528. return;
  529. }
  530. time_to_exhaust_bw =
  531. (get_options()->AccountingMax/expected_bandwidth_usage)*60;
  532. if (time_to_exhaust_bw > INT_MAX) {
  533. time_to_exhaust_bw = INT_MAX;
  534. time_to_consider = 0;
  535. } else {
  536. time_to_consider = accounting_get_interval_length() -
  537. (int)time_to_exhaust_bw;
  538. }
  539. if (time_to_consider<=0) {
  540. interval_wakeup_time = interval_start_time;
  541. } else {
  542. /* XXX can we simplify this just by picking a random (non-deterministic)
  543. * time to be up? If we go down and come up, then we pick a new one. Is
  544. * that good enough? -RD */
  545. /* This is not a perfectly unbiased conversion, but it is good enough:
  546. * in the worst case, the first half of the day is 0.06 percent likelier
  547. * to be chosen than the last half. */
  548. interval_wakeup_time = interval_start_time +
  549. (get_uint32(digest) % time_to_consider);
  550. }
  551. {
  552. char buf1[ISO_TIME_LEN+1];
  553. char buf2[ISO_TIME_LEN+1];
  554. char buf3[ISO_TIME_LEN+1];
  555. char buf4[ISO_TIME_LEN+1];
  556. time_t down_time;
  557. if (interval_wakeup_time+time_to_exhaust_bw > TIME_MAX)
  558. down_time = TIME_MAX;
  559. else
  560. down_time = (time_t)(interval_wakeup_time+time_to_exhaust_bw);
  561. if (down_time>interval_end_time)
  562. down_time = interval_end_time;
  563. format_local_iso_time(buf1, interval_start_time);
  564. format_local_iso_time(buf2, interval_wakeup_time);
  565. format_local_iso_time(buf3, down_time);
  566. format_local_iso_time(buf4, interval_end_time);
  567. log_notice(LD_ACCT,
  568. "Configured hibernation. This interval began at %s; "
  569. "the scheduled wake-up time %s %s; "
  570. "we expect%s to exhaust our quota for this interval around %s; "
  571. "the next interval begins at %s (all times local)",
  572. buf1,
  573. time(NULL)<interval_wakeup_time?"is":"was", buf2,
  574. time(NULL)<down_time?"":"ed", buf3,
  575. buf4);
  576. }
  577. }
  578. /* This rounds 0 up to 1000, but that's actually a feature. */
  579. #define ROUND_UP(x) (((x) + 0x3ff) & ~0x3ff)
  580. /** Save all our bandwidth tracking information to disk. Return 0 on
  581. * success, -1 on failure. */
  582. int
  583. accounting_record_bandwidth_usage(time_t now, or_state_t *state)
  584. {
  585. /* Just update the state */
  586. state->AccountingIntervalStart = interval_start_time;
  587. state->AccountingBytesReadInInterval = ROUND_UP(n_bytes_read_in_interval);
  588. state->AccountingBytesWrittenInInterval =
  589. ROUND_UP(n_bytes_written_in_interval);
  590. state->AccountingSecondsActive = n_seconds_active_in_interval;
  591. state->AccountingExpectedUsage = expected_bandwidth_usage;
  592. state->AccountingSecondsToReachSoftLimit = n_seconds_to_hit_soft_limit;
  593. state->AccountingSoftLimitHitAt = soft_limit_hit_at;
  594. state->AccountingBytesAtSoftLimit = n_bytes_at_soft_limit;
  595. or_state_mark_dirty(state,
  596. now+(get_options()->AvoidDiskWrites ? 7200 : 60));
  597. return 0;
  598. }
  599. #undef ROUND_UP
  600. /** Read stored accounting information from disk. Return 0 on success;
  601. * return -1 and change nothing on failure. */
  602. static int
  603. read_bandwidth_usage(void)
  604. {
  605. or_state_t *state = get_or_state();
  606. {
  607. char *fname = get_datadir_fname("bw_accounting");
  608. int res;
  609. res = unlink(fname);
  610. if (res != 0) {
  611. log_warn(LD_FS,
  612. "Failed to unlink %s: %s",
  613. fname, strerror(errno));
  614. }
  615. tor_free(fname);
  616. }
  617. if (!state)
  618. return -1;
  619. log_info(LD_ACCT, "Reading bandwidth accounting data from state file");
  620. n_bytes_read_in_interval = state->AccountingBytesReadInInterval;
  621. n_bytes_written_in_interval = state->AccountingBytesWrittenInInterval;
  622. n_seconds_active_in_interval = state->AccountingSecondsActive;
  623. interval_start_time = state->AccountingIntervalStart;
  624. expected_bandwidth_usage = state->AccountingExpectedUsage;
  625. /* Older versions of Tor (before 0.2.2.17-alpha or so) didn't generate these
  626. * fields. If you switch back and forth, you might get an
  627. * AccountingSoftLimitHitAt value from long before the most recent
  628. * interval_start_time. If that's so, then ignore the softlimit-related
  629. * values. */
  630. if (state->AccountingSoftLimitHitAt > interval_start_time) {
  631. soft_limit_hit_at = state->AccountingSoftLimitHitAt;
  632. n_bytes_at_soft_limit = state->AccountingBytesAtSoftLimit;
  633. n_seconds_to_hit_soft_limit = state->AccountingSecondsToReachSoftLimit;
  634. } else {
  635. soft_limit_hit_at = 0;
  636. n_bytes_at_soft_limit = 0;
  637. n_seconds_to_hit_soft_limit = 0;
  638. }
  639. {
  640. char tbuf1[ISO_TIME_LEN+1];
  641. char tbuf2[ISO_TIME_LEN+1];
  642. format_iso_time(tbuf1, state->LastWritten);
  643. format_iso_time(tbuf2, state->AccountingIntervalStart);
  644. log_info(LD_ACCT,
  645. "Successfully read bandwidth accounting info from state written at %s "
  646. "for interval starting at %s. We have been active for %lu seconds in "
  647. "this interval. At the start of the interval, we expected to use "
  648. "about %lu KB per second. ("U64_FORMAT" bytes read so far, "
  649. U64_FORMAT" bytes written so far)",
  650. tbuf1, tbuf2,
  651. (unsigned long)n_seconds_active_in_interval,
  652. (unsigned long)(expected_bandwidth_usage*1024/60),
  653. U64_PRINTF_ARG(n_bytes_read_in_interval),
  654. U64_PRINTF_ARG(n_bytes_written_in_interval));
  655. }
  656. return 0;
  657. }
  658. /** Return true iff we have sent/received all the bytes we are willing
  659. * to send/receive this interval. */
  660. static int
  661. hibernate_hard_limit_reached(void)
  662. {
  663. uint64_t hard_limit = get_options()->AccountingMax;
  664. if (!hard_limit)
  665. return 0;
  666. return get_accounting_bytes() >= hard_limit;
  667. }
  668. /** Return true iff we have sent/received almost all the bytes we are willing
  669. * to send/receive this interval. */
  670. static int
  671. hibernate_soft_limit_reached(void)
  672. {
  673. const uint64_t acct_max = get_options()->AccountingMax;
  674. #define SOFT_LIM_PCT (.95)
  675. #define SOFT_LIM_BYTES (500*1024*1024)
  676. #define SOFT_LIM_MINUTES (3*60)
  677. /* The 'soft limit' is a fair bit more complicated now than once it was.
  678. * We want to stop accepting connections when ALL of the following are true:
  679. * - We expect to use up the remaining bytes in under 3 hours
  680. * - We have used up 95% of our bytes.
  681. * - We have less than 500MB of bytes left.
  682. */
  683. uint64_t soft_limit = DBL_TO_U64(U64_TO_DBL(acct_max) * SOFT_LIM_PCT);
  684. if (acct_max > SOFT_LIM_BYTES && acct_max - SOFT_LIM_BYTES > soft_limit) {
  685. soft_limit = acct_max - SOFT_LIM_BYTES;
  686. }
  687. if (expected_bandwidth_usage) {
  688. const uint64_t expected_usage =
  689. expected_bandwidth_usage * SOFT_LIM_MINUTES;
  690. if (acct_max > expected_usage && acct_max - expected_usage > soft_limit)
  691. soft_limit = acct_max - expected_usage;
  692. }
  693. if (!soft_limit)
  694. return 0;
  695. return get_accounting_bytes() >= soft_limit;
  696. }
  697. /** Called when we get a SIGINT, or when bandwidth soft limit is
  698. * reached. Puts us into "loose hibernation": we don't accept new
  699. * connections, but we continue handling old ones. */
  700. static void
  701. hibernate_begin(hibernate_state_t new_state, time_t now)
  702. {
  703. const or_options_t *options = get_options();
  704. if (new_state == HIBERNATE_STATE_EXITING &&
  705. hibernate_state != HIBERNATE_STATE_LIVE) {
  706. log_notice(LD_GENERAL,"SIGINT received %s; exiting now.",
  707. hibernate_state == HIBERNATE_STATE_EXITING ?
  708. "a second time" : "while hibernating");
  709. tor_cleanup();
  710. exit(0);
  711. }
  712. if (new_state == HIBERNATE_STATE_LOWBANDWIDTH &&
  713. hibernate_state == HIBERNATE_STATE_LIVE) {
  714. soft_limit_hit_at = now;
  715. n_seconds_to_hit_soft_limit = n_seconds_active_in_interval;
  716. n_bytes_at_soft_limit = get_accounting_bytes();
  717. }
  718. /* close listeners. leave control listener(s). */
  719. connection_mark_all_noncontrol_listeners();
  720. /* XXX kill intro point circs */
  721. /* XXX upload rendezvous service descriptors with no intro points */
  722. if (new_state == HIBERNATE_STATE_EXITING) {
  723. log_notice(LD_GENERAL,"Interrupt: we have stopped accepting new "
  724. "connections, and will shut down in %d seconds. Interrupt "
  725. "again to exit now.", options->ShutdownWaitLength);
  726. shutdown_time = time(NULL) + options->ShutdownWaitLength;
  727. } else { /* soft limit reached */
  728. hibernate_end_time = interval_end_time;
  729. }
  730. hibernate_state = new_state;
  731. accounting_record_bandwidth_usage(now, get_or_state());
  732. or_state_mark_dirty(get_or_state(),
  733. get_options()->AvoidDiskWrites ? now+600 : 0);
  734. }
  735. /** Called when we've been hibernating and our timeout is reached. */
  736. static void
  737. hibernate_end(hibernate_state_t new_state)
  738. {
  739. tor_assert(hibernate_state == HIBERNATE_STATE_LOWBANDWIDTH ||
  740. hibernate_state == HIBERNATE_STATE_DORMANT ||
  741. hibernate_state == HIBERNATE_STATE_INITIAL);
  742. /* listeners will be relaunched in run_scheduled_events() in main.c */
  743. if (hibernate_state != HIBERNATE_STATE_INITIAL)
  744. log_notice(LD_ACCT,"Hibernation period ended. Resuming normal activity.");
  745. hibernate_state = new_state;
  746. hibernate_end_time = 0; /* no longer hibernating */
  747. stats_n_seconds_working = 0; /* reset published uptime */
  748. }
  749. /** A wrapper around hibernate_begin, for when we get SIGINT. */
  750. void
  751. hibernate_begin_shutdown(void)
  752. {
  753. hibernate_begin(HIBERNATE_STATE_EXITING, time(NULL));
  754. }
  755. /** Return true iff we are currently hibernating. */
  756. MOCK_IMPL(int,
  757. we_are_hibernating,(void))
  758. {
  759. return hibernate_state != HIBERNATE_STATE_LIVE;
  760. }
  761. /** If we aren't currently dormant, close all connections and become
  762. * dormant. */
  763. static void
  764. hibernate_go_dormant(time_t now)
  765. {
  766. connection_t *conn;
  767. if (hibernate_state == HIBERNATE_STATE_DORMANT)
  768. return;
  769. else if (hibernate_state == HIBERNATE_STATE_LOWBANDWIDTH)
  770. hibernate_state = HIBERNATE_STATE_DORMANT;
  771. else
  772. hibernate_begin(HIBERNATE_STATE_DORMANT, now);
  773. log_notice(LD_ACCT,"Going dormant. Blowing away remaining connections.");
  774. /* Close all OR/AP/exit conns. Leave dir conns because we still want
  775. * to be able to upload server descriptors so people know we're still
  776. * running, and download directories so we can detect if we're obsolete.
  777. * Leave control conns because we still want to be controllable.
  778. */
  779. while ((conn = connection_get_by_type(CONN_TYPE_OR)) ||
  780. (conn = connection_get_by_type(CONN_TYPE_AP)) ||
  781. (conn = connection_get_by_type(CONN_TYPE_EXIT))) {
  782. if (CONN_IS_EDGE(conn))
  783. connection_edge_end(TO_EDGE_CONN(conn), END_STREAM_REASON_HIBERNATING);
  784. log_info(LD_NET,"Closing conn type %d", conn->type);
  785. if (conn->type == CONN_TYPE_AP) /* send socks failure if needed */
  786. connection_mark_unattached_ap(TO_ENTRY_CONN(conn),
  787. END_STREAM_REASON_HIBERNATING);
  788. else if (conn->type == CONN_TYPE_OR) {
  789. if (TO_OR_CONN(conn)->chan) {
  790. channel_mark_for_close(TLS_CHAN_TO_BASE(TO_OR_CONN(conn)->chan));
  791. } else {
  792. connection_mark_for_close(conn);
  793. }
  794. } else
  795. connection_mark_for_close(conn);
  796. }
  797. if (now < interval_wakeup_time)
  798. hibernate_end_time = interval_wakeup_time;
  799. else
  800. hibernate_end_time = interval_end_time;
  801. accounting_record_bandwidth_usage(now, get_or_state());
  802. or_state_mark_dirty(get_or_state(),
  803. get_options()->AvoidDiskWrites ? now+600 : 0);
  804. }
  805. /** Called when hibernate_end_time has arrived. */
  806. static void
  807. hibernate_end_time_elapsed(time_t now)
  808. {
  809. char buf[ISO_TIME_LEN+1];
  810. /* The interval has ended, or it is wakeup time. Find out which. */
  811. accounting_run_housekeeping(now);
  812. if (interval_wakeup_time <= now) {
  813. /* The interval hasn't changed, but interval_wakeup_time has passed.
  814. * It's time to wake up and start being a server. */
  815. hibernate_end(HIBERNATE_STATE_LIVE);
  816. return;
  817. } else {
  818. /* The interval has changed, and it isn't time to wake up yet. */
  819. hibernate_end_time = interval_wakeup_time;
  820. format_iso_time(buf,interval_wakeup_time);
  821. if (hibernate_state != HIBERNATE_STATE_DORMANT) {
  822. /* We weren't sleeping before; we should sleep now. */
  823. log_notice(LD_ACCT,
  824. "Accounting period ended. Commencing hibernation until "
  825. "%s UTC", buf);
  826. hibernate_go_dormant(now);
  827. } else {
  828. log_notice(LD_ACCT,
  829. "Accounting period ended. This period, we will hibernate"
  830. " until %s UTC",buf);
  831. }
  832. }
  833. }
  834. /** Consider our environment and decide if it's time
  835. * to start/stop hibernating.
  836. */
  837. void
  838. consider_hibernation(time_t now)
  839. {
  840. int accounting_enabled = get_options()->AccountingMax != 0;
  841. char buf[ISO_TIME_LEN+1];
  842. /* If we're in 'exiting' mode, then we just shut down after the interval
  843. * elapses. */
  844. if (hibernate_state == HIBERNATE_STATE_EXITING) {
  845. tor_assert(shutdown_time);
  846. if (shutdown_time <= now) {
  847. log_notice(LD_GENERAL, "Clean shutdown finished. Exiting.");
  848. tor_cleanup();
  849. exit(0);
  850. }
  851. return; /* if exiting soon, don't worry about bandwidth limits */
  852. }
  853. if (hibernate_state == HIBERNATE_STATE_DORMANT) {
  854. /* We've been hibernating because of bandwidth accounting. */
  855. tor_assert(hibernate_end_time);
  856. if (hibernate_end_time > now && accounting_enabled) {
  857. /* If we're hibernating, don't wake up until it's time, regardless of
  858. * whether we're in a new interval. */
  859. return ;
  860. } else {
  861. hibernate_end_time_elapsed(now);
  862. }
  863. }
  864. /* Else, we aren't hibernating. See if it's time to start hibernating, or to
  865. * go dormant. */
  866. if (hibernate_state == HIBERNATE_STATE_LIVE ||
  867. hibernate_state == HIBERNATE_STATE_INITIAL) {
  868. if (hibernate_soft_limit_reached()) {
  869. log_notice(LD_ACCT,
  870. "Bandwidth soft limit reached; commencing hibernation. "
  871. "No new connections will be accepted");
  872. hibernate_begin(HIBERNATE_STATE_LOWBANDWIDTH, now);
  873. } else if (accounting_enabled && now < interval_wakeup_time) {
  874. format_local_iso_time(buf,interval_wakeup_time);
  875. log_notice(LD_ACCT,
  876. "Commencing hibernation. We will wake up at %s local time.",
  877. buf);
  878. hibernate_go_dormant(now);
  879. } else if (hibernate_state == HIBERNATE_STATE_INITIAL) {
  880. hibernate_end(HIBERNATE_STATE_LIVE);
  881. }
  882. }
  883. if (hibernate_state == HIBERNATE_STATE_LOWBANDWIDTH) {
  884. if (!accounting_enabled) {
  885. hibernate_end_time_elapsed(now);
  886. } else if (hibernate_hard_limit_reached()) {
  887. hibernate_go_dormant(now);
  888. } else if (hibernate_end_time <= now) {
  889. /* The hibernation period ended while we were still in lowbandwidth.*/
  890. hibernate_end_time_elapsed(now);
  891. }
  892. }
  893. }
  894. /** Helper function: called when we get a GETINFO request for an
  895. * accounting-related key on the control connection <b>conn</b>. If we can
  896. * answer the request for <b>question</b>, then set *<b>answer</b> to a newly
  897. * allocated string holding the result. Otherwise, set *<b>answer</b> to
  898. * NULL. */
  899. int
  900. getinfo_helper_accounting(control_connection_t *conn,
  901. const char *question, char **answer,
  902. const char **errmsg)
  903. {
  904. (void) conn;
  905. (void) errmsg;
  906. if (!strcmp(question, "accounting/enabled")) {
  907. *answer = tor_strdup(accounting_is_enabled(get_options()) ? "1" : "0");
  908. } else if (!strcmp(question, "accounting/hibernating")) {
  909. if (hibernate_state == HIBERNATE_STATE_DORMANT)
  910. *answer = tor_strdup("hard");
  911. else if (hibernate_state == HIBERNATE_STATE_LOWBANDWIDTH)
  912. *answer = tor_strdup("soft");
  913. else
  914. *answer = tor_strdup("awake");
  915. } else if (!strcmp(question, "accounting/bytes")) {
  916. tor_asprintf(answer, U64_FORMAT" "U64_FORMAT,
  917. U64_PRINTF_ARG(n_bytes_read_in_interval),
  918. U64_PRINTF_ARG(n_bytes_written_in_interval));
  919. } else if (!strcmp(question, "accounting/bytes-left")) {
  920. uint64_t limit = get_options()->AccountingMax;
  921. if (get_options()->AccountingRule == ACCT_SUM) {
  922. uint64_t total_left = 0;
  923. uint64_t total_bytes = get_accounting_bytes();
  924. if (total_bytes < limit)
  925. total_left = limit - total_bytes;
  926. tor_asprintf(answer, U64_FORMAT" "U64_FORMAT,
  927. U64_PRINTF_ARG(total_left), U64_PRINTF_ARG(total_left));
  928. } else {
  929. uint64_t read_left = 0, write_left = 0;
  930. if (n_bytes_read_in_interval < limit)
  931. read_left = limit - n_bytes_read_in_interval;
  932. if (n_bytes_written_in_interval < limit)
  933. write_left = limit - n_bytes_written_in_interval;
  934. tor_asprintf(answer, U64_FORMAT" "U64_FORMAT,
  935. U64_PRINTF_ARG(read_left), U64_PRINTF_ARG(write_left));
  936. }
  937. } else if (!strcmp(question, "accounting/interval-start")) {
  938. *answer = tor_malloc(ISO_TIME_LEN+1);
  939. format_iso_time(*answer, interval_start_time);
  940. } else if (!strcmp(question, "accounting/interval-wake")) {
  941. *answer = tor_malloc(ISO_TIME_LEN+1);
  942. format_iso_time(*answer, interval_wakeup_time);
  943. } else if (!strcmp(question, "accounting/interval-end")) {
  944. *answer = tor_malloc(ISO_TIME_LEN+1);
  945. format_iso_time(*answer, interval_end_time);
  946. } else {
  947. *answer = NULL;
  948. }
  949. return 0;
  950. }
  951. #ifdef TOR_UNIT_TESTS
  952. /**
  953. * Manually change the hibernation state. Private; used only by the unit
  954. * tests.
  955. */
  956. void
  957. hibernate_set_state_for_testing_(hibernate_state_t newstate)
  958. {
  959. hibernate_state = newstate;
  960. }
  961. #endif