storagedir.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586
  1. /* Copyright (c) 2017, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. #include "container.h"
  4. #include "compat.h"
  5. #include "confline.h"
  6. #include "memarea.h"
  7. #include "sandbox.h"
  8. #include "storagedir.h"
  9. #include "torlog.h"
  10. #include "util.h"
  11. #ifdef HAVE_SYS_TYPES_H
  12. #include <sys/types.h>
  13. #endif
  14. #ifdef HAVE_SYS_STAT_H
  15. #include <sys/stat.h>
  16. #endif
  17. #ifdef HAVE_UNISTD_H
  18. #include <unistd.h>
  19. #endif
  20. #define FNAME_MIN_NUM 1000
  21. /** A storage_dir_t represents a directory full of similar cached
  22. * files. Filenames are decimal integers. Files can be cleaned as needed
  23. * to limit total disk usage. */
  24. struct storage_dir_t {
  25. /** Directory holding the files for this storagedir. */
  26. char *directory;
  27. /** Either NULL, or a directory listing of the directory (as a smartlist
  28. * of strings */
  29. smartlist_t *contents;
  30. /** The largest number of non-temporary files we'll place in the
  31. * directory. */
  32. int max_files;
  33. /** If true, then 'usage' has been computed. */
  34. int usage_known;
  35. /** The total number of bytes used in this directory */
  36. uint64_t usage;
  37. };
  38. /** Create or open a new storage directory at <b>dirname</b>, with
  39. * capacity for up to <b>max_files</b> files.
  40. */
  41. storage_dir_t *
  42. storage_dir_new(const char *dirname, int max_files)
  43. {
  44. if (check_private_dir(dirname, CPD_CREATE, NULL) < 0)
  45. return NULL;
  46. storage_dir_t *d = tor_malloc_zero(sizeof(storage_dir_t));
  47. d->directory = tor_strdup(dirname);
  48. d->max_files = max_files;
  49. return d;
  50. }
  51. /**
  52. * Drop all in-RAM storage for <b>d</b>. Does not delete any files.
  53. */
  54. void
  55. storage_dir_free_(storage_dir_t *d)
  56. {
  57. if (d == NULL)
  58. return;
  59. tor_free(d->directory);
  60. if (d->contents) {
  61. SMARTLIST_FOREACH(d->contents, char *, cp, tor_free(cp));
  62. smartlist_free(d->contents);
  63. }
  64. tor_free(d);
  65. }
  66. /**
  67. * Tell the sandbox (if any) configured by <b>cfg</b> to allow the
  68. * operations that <b>d</b> will need.
  69. *
  70. * The presence of this function is why we need an upper limit on the
  71. * number of files in a storage_dir_t: we need to approve file operations
  72. * one by one.
  73. */
  74. int
  75. storage_dir_register_with_sandbox(storage_dir_t *d, sandbox_cfg_t **cfg)
  76. {
  77. int problems = 0;
  78. int idx;
  79. for (idx = FNAME_MIN_NUM; idx < FNAME_MIN_NUM + d->max_files; ++idx) {
  80. char *path = NULL, *tmppath = NULL;
  81. tor_asprintf(&path, "%s/%d", d->directory, idx);
  82. tor_asprintf(&tmppath, "%s/%d.tmp", d->directory, idx);
  83. problems += sandbox_cfg_allow_open_filename(cfg, tor_strdup(path));
  84. problems += sandbox_cfg_allow_open_filename(cfg, tor_strdup(tmppath));
  85. problems += sandbox_cfg_allow_stat_filename(cfg, tor_strdup(path));
  86. problems += sandbox_cfg_allow_stat_filename(cfg, tor_strdup(tmppath));
  87. problems += sandbox_cfg_allow_rename(cfg,
  88. tor_strdup(tmppath), tor_strdup(path));
  89. tor_free(path);
  90. tor_free(tmppath);
  91. }
  92. return problems ? -1 : 0;
  93. }
  94. /**
  95. * Remove all files in <b>d</b> whose names end with ".tmp".
  96. *
  97. * Requires that the contents field of <b>d</b> is set.
  98. */
  99. static void
  100. storage_dir_clean_tmpfiles(storage_dir_t *d)
  101. {
  102. if (!d->contents)
  103. return;
  104. SMARTLIST_FOREACH_BEGIN(d->contents, char *, fname) {
  105. if (strcmpend(fname, ".tmp"))
  106. continue;
  107. char *path = NULL;
  108. tor_asprintf(&path, "%s/%s", d->directory, fname);
  109. if (unlink(sandbox_intern_string(path))) {
  110. log_warn(LD_FS, "Unable to unlink %s while cleaning "
  111. "temporary files: %s", escaped(path), strerror(errno));
  112. tor_free(path);
  113. continue;
  114. }
  115. tor_free(path);
  116. SMARTLIST_DEL_CURRENT(d->contents, fname);
  117. tor_free(fname);
  118. } SMARTLIST_FOREACH_END(fname);
  119. d->usage_known = 0;
  120. }
  121. /**
  122. * Re-scan the directory <b>d</b> to learn its contents.
  123. */
  124. static int
  125. storage_dir_rescan(storage_dir_t *d)
  126. {
  127. if (d->contents) {
  128. SMARTLIST_FOREACH(d->contents, char *, cp, tor_free(cp));
  129. smartlist_free(d->contents);
  130. }
  131. d->usage = 0;
  132. d->usage_known = 0;
  133. if (NULL == (d->contents = tor_listdir(d->directory))) {
  134. return -1;
  135. }
  136. storage_dir_clean_tmpfiles(d);
  137. return 0;
  138. }
  139. /**
  140. * Return a smartlist containing the filenames within <b>d</b>.
  141. */
  142. const smartlist_t *
  143. storage_dir_list(storage_dir_t *d)
  144. {
  145. if (! d->contents)
  146. storage_dir_rescan(d);
  147. return d->contents;
  148. }
  149. /**
  150. * Return the total number of bytes used for storage in <b>d</b>.
  151. */
  152. uint64_t
  153. storage_dir_get_usage(storage_dir_t *d)
  154. {
  155. if (d->usage_known)
  156. return d->usage;
  157. uint64_t total = 0;
  158. SMARTLIST_FOREACH_BEGIN(storage_dir_list(d), const char *, cp) {
  159. char *path = NULL;
  160. struct stat st;
  161. tor_asprintf(&path, "%s/%s", d->directory, cp);
  162. if (stat(sandbox_intern_string(path), &st) == 0) {
  163. total += st.st_size;
  164. }
  165. tor_free(path);
  166. } SMARTLIST_FOREACH_END(cp);
  167. d->usage = total;
  168. d->usage_known = 1;
  169. return d->usage;
  170. }
  171. /** Mmap a specified file within <b>d</b>.
  172. *
  173. * On failure, return NULL and set errno as for tor_mmap_file(). */
  174. tor_mmap_t *
  175. storage_dir_map(storage_dir_t *d, const char *fname)
  176. {
  177. char *path = NULL;
  178. tor_asprintf(&path, "%s/%s", d->directory, fname);
  179. tor_mmap_t *result = tor_mmap_file(path);
  180. int errval = errno;
  181. tor_free(path);
  182. if (result == NULL)
  183. errno = errval;
  184. return result;
  185. }
  186. /** Read a file within <b>d</b> into a newly allocated buffer. Set
  187. * *<b>sz_out</b> to its size. */
  188. uint8_t *
  189. storage_dir_read(storage_dir_t *d, const char *fname, int bin, size_t *sz_out)
  190. {
  191. const int flags = bin ? RFTS_BIN : 0;
  192. char *path = NULL;
  193. tor_asprintf(&path, "%s/%s", d->directory, fname);
  194. struct stat st;
  195. char *contents = read_file_to_str(path, flags, &st);
  196. if (contents && sz_out) {
  197. // it fits in RAM, so we know its size is less than SIZE_MAX
  198. #if UINT64_MAX > SIZE_MAX
  199. tor_assert((uint64_t)st.st_size <= SIZE_MAX);
  200. #endif
  201. *sz_out = (size_t) st.st_size;
  202. }
  203. tor_free(path);
  204. return (uint8_t *) contents;
  205. }
  206. /** Helper: Find an unused filename within the directory */
  207. static char *
  208. find_unused_fname(storage_dir_t *d)
  209. {
  210. if (!d->contents) {
  211. if (storage_dir_rescan(d) < 0)
  212. return NULL;
  213. }
  214. char buf[16];
  215. int i;
  216. /* Yuck; this is quadratic. Fortunately, that shouldn't matter much,
  217. * since disk writes are more expensive by a lot. */
  218. for (i = FNAME_MIN_NUM; i < FNAME_MIN_NUM + d->max_files; ++i) {
  219. tor_snprintf(buf, sizeof(buf), "%d", i);
  220. if (!smartlist_contains_string(d->contents, buf)) {
  221. return tor_strdup(buf);
  222. }
  223. }
  224. return NULL;
  225. }
  226. /** Helper: As storage_dir_save_bytes_to_file, but store a smartlist of
  227. * sized_chunk_t rather than a single byte array. */
  228. static int
  229. storage_dir_save_chunks_to_file(storage_dir_t *d,
  230. const smartlist_t *chunks,
  231. int binary,
  232. char **fname_out)
  233. {
  234. uint64_t total_length = 0;
  235. char *fname = find_unused_fname(d);
  236. if (!fname)
  237. return -1;
  238. SMARTLIST_FOREACH(chunks, const sized_chunk_t *, ch,
  239. total_length += ch->len);
  240. char *path = NULL;
  241. tor_asprintf(&path, "%s/%s", d->directory, fname);
  242. int r = write_chunks_to_file(path, chunks, binary, 0);
  243. if (r == 0) {
  244. if (d->usage_known)
  245. d->usage += total_length;
  246. if (fname_out) {
  247. *fname_out = tor_strdup(fname);
  248. }
  249. if (d->contents)
  250. smartlist_add(d->contents, tor_strdup(fname));
  251. }
  252. tor_free(fname);
  253. tor_free(path);
  254. return r;
  255. }
  256. /** Try to write the <b>length</b> bytes at <b>data</b> into a new file
  257. * in <b>d</b>. On success, return 0 and set *<b>fname_out</b> to a
  258. * newly allocated string containing the filename. On failure, return
  259. * -1. */
  260. int
  261. storage_dir_save_bytes_to_file(storage_dir_t *d,
  262. const uint8_t *data,
  263. size_t length,
  264. int binary,
  265. char **fname_out)
  266. {
  267. smartlist_t *chunks = smartlist_new();
  268. sized_chunk_t chunk = { (const char *)data, length };
  269. smartlist_add(chunks, &chunk);
  270. int r = storage_dir_save_chunks_to_file(d, chunks, binary, fname_out);
  271. smartlist_free(chunks);
  272. return r;
  273. }
  274. /**
  275. * As storage_dir_save_bytes_to_file, but saves a NUL-terminated string
  276. * <b>str</b>.
  277. */
  278. int
  279. storage_dir_save_string_to_file(storage_dir_t *d,
  280. const char *str,
  281. int binary,
  282. char **fname_out)
  283. {
  284. return storage_dir_save_bytes_to_file(d,
  285. (const uint8_t*)str, strlen(str), binary, fname_out);
  286. }
  287. /**
  288. * As storage_dir_save_bytes_to_file, but associates the data with the
  289. * key-value pairs in <b>labels</b>. Files stored in this format can be
  290. * recovered with storage_dir_map_labeled() or storage_dir_read_labeled().
  291. */
  292. int
  293. storage_dir_save_labeled_to_file(storage_dir_t *d,
  294. const config_line_t *labels,
  295. const uint8_t *data,
  296. size_t length,
  297. char **fname_out)
  298. {
  299. /*
  300. * The storage format is to prefix the data with the key-value pairs in
  301. * <b>labels</b>, and a single NUL separator. But code outside this module
  302. * MUST NOT rely on that format.
  303. */
  304. smartlist_t *chunks = smartlist_new();
  305. memarea_t *area = memarea_new();
  306. const config_line_t *line;
  307. for (line = labels; line; line = line->next) {
  308. sized_chunk_t *sz = memarea_alloc(area, sizeof(sized_chunk_t));
  309. sz->len = strlen(line->key) + 1 + strlen(line->value) + 1;
  310. const size_t allocated = sz->len + 1;
  311. char *bytes = memarea_alloc(area, allocated);
  312. tor_snprintf(bytes, allocated, "%s %s\n", line->key, line->value);
  313. sz->bytes = bytes;
  314. smartlist_add(chunks, sz);
  315. }
  316. sized_chunk_t *nul = memarea_alloc(area, sizeof(sized_chunk_t));
  317. nul->len = 1;
  318. nul->bytes = "\0";
  319. smartlist_add(chunks, nul);
  320. sized_chunk_t *datachunk = memarea_alloc(area, sizeof(sized_chunk_t));
  321. datachunk->bytes = (const char *)data;
  322. datachunk->len = length;
  323. smartlist_add(chunks, datachunk);
  324. int r = storage_dir_save_chunks_to_file(d, chunks, 1, fname_out);
  325. smartlist_free(chunks);
  326. memarea_drop_all(area);
  327. return r;
  328. }
  329. /**
  330. * Map a file that was created with storage_dir_save_labeled_to_file(). On
  331. * failure, return NULL. On success, write a set of newly allocated labels
  332. * into *<b>labels_out</b>, a pointer to the data into *<b>data_out</b>, and
  333. * the data's size into *<b>sz_out</b>. On success, also return a tor_mmap_t
  334. * object whose contents should not be used -- it needs to be kept around,
  335. * though, for as long as <b>data_out</b> is going to be valid.
  336. *
  337. * On failure, set errno as for tor_mmap_file() if the file was missing or
  338. * empty, and set errno to EINVAL if the file was not in the labeled
  339. * format expected.
  340. */
  341. tor_mmap_t *
  342. storage_dir_map_labeled(storage_dir_t *dir,
  343. const char *fname,
  344. config_line_t **labels_out,
  345. const uint8_t **data_out,
  346. size_t *sz_out)
  347. {
  348. tor_mmap_t *m = storage_dir_map(dir, fname);
  349. int errval;
  350. if (! m) {
  351. errval = errno;
  352. goto err;
  353. }
  354. const char *nulp = memchr(m->data, '\0', m->size);
  355. if (! nulp) {
  356. errval = EINVAL;
  357. goto err;
  358. }
  359. if (labels_out && config_get_lines(m->data, labels_out, 0) < 0) {
  360. errval = EINVAL;
  361. goto err;
  362. }
  363. size_t offset = nulp - m->data + 1;
  364. tor_assert(offset <= m->size);
  365. *data_out = (const uint8_t *)(m->data + offset);
  366. *sz_out = m->size - offset;
  367. return m;
  368. err:
  369. tor_munmap_file(m);
  370. errno = errval;
  371. return NULL;
  372. }
  373. /** As storage_dir_map_labeled, but return a new byte array containing the
  374. * data. */
  375. uint8_t *
  376. storage_dir_read_labeled(storage_dir_t *dir,
  377. const char *fname,
  378. config_line_t **labels_out,
  379. size_t *sz_out)
  380. {
  381. const uint8_t *data = NULL;
  382. tor_mmap_t *m = storage_dir_map_labeled(dir, fname, labels_out,
  383. &data, sz_out);
  384. if (m == NULL)
  385. return NULL;
  386. uint8_t *result = tor_memdup(data, *sz_out);
  387. tor_munmap_file(m);
  388. return result;
  389. }
  390. /* Reduce the cached usage amount in <b>d</b> by <b>removed_file_size</b>.
  391. * This function is a no-op if <b>d->usage_known</b> is 0. */
  392. static void
  393. storage_dir_reduce_usage(storage_dir_t *d, uint64_t removed_file_size)
  394. {
  395. if (d->usage_known) {
  396. if (! BUG(d->usage < removed_file_size)) {
  397. /* This bug can also be triggered if an external process resized a file
  398. * between the call to storage_dir_get_usage() that last checked
  399. * actual usage (rather than relaying on cached usage), and the call to
  400. * this function. */
  401. d->usage -= removed_file_size;
  402. } else {
  403. /* If we underflowed the cached directory size, re-check the sizes of all
  404. * the files in the directory. This makes storage_dir_shrink() quadratic,
  405. * but only if a process is continually changing file sizes in the
  406. * storage directory (in which case, we have bigger issues).
  407. *
  408. * We can't just reset usage_known, because storage_dir_shrink() relies
  409. * on knowing the usage. */
  410. storage_dir_rescan(d);
  411. (void)storage_dir_get_usage(d);
  412. }
  413. }
  414. }
  415. /**
  416. * Remove the file called <b>fname</b> from <b>d</b>.
  417. */
  418. void
  419. storage_dir_remove_file(storage_dir_t *d,
  420. const char *fname)
  421. {
  422. char *path = NULL;
  423. tor_asprintf(&path, "%s/%s", d->directory, fname);
  424. const char *ipath = sandbox_intern_string(path);
  425. uint64_t size = 0;
  426. if (d->usage_known) {
  427. struct stat st;
  428. if (stat(ipath, &st) == 0) {
  429. size = st.st_size;
  430. }
  431. }
  432. if (unlink(ipath) == 0) {
  433. storage_dir_reduce_usage(d, size);
  434. } else {
  435. log_warn(LD_FS, "Unable to unlink %s while removing file: %s",
  436. escaped(path), strerror(errno));
  437. tor_free(path);
  438. return;
  439. }
  440. if (d->contents) {
  441. smartlist_string_remove(d->contents, fname);
  442. }
  443. tor_free(path);
  444. }
  445. /** Helper type: used to sort the members of storage directory by mtime. */
  446. typedef struct shrinking_dir_entry_t {
  447. time_t mtime;
  448. uint64_t size;
  449. char *path;
  450. } shrinking_dir_entry_t;
  451. /** Helper: use with qsort to sort shrinking_dir_entry_t structs. */
  452. static int
  453. shrinking_dir_entry_compare(const void *a_, const void *b_)
  454. {
  455. const shrinking_dir_entry_t *a = a_;
  456. const shrinking_dir_entry_t *b = b_;
  457. if (a->mtime < b->mtime)
  458. return -1;
  459. else if (a->mtime > b->mtime)
  460. return 1;
  461. else
  462. return 0;
  463. }
  464. /**
  465. * Try to free space by removing the oldest files in <b>d</b>. Delete
  466. * until no more than <b>target_size</b> bytes are left, and at least
  467. * <b>min_to_remove</b> files have been removed... or until there is
  468. * nothing left to remove.
  469. *
  470. * Return 0 on success; -1 on failure.
  471. */
  472. int
  473. storage_dir_shrink(storage_dir_t *d,
  474. uint64_t target_size,
  475. int min_to_remove)
  476. {
  477. if (d->usage_known && d->usage <= target_size && !min_to_remove) {
  478. /* Already small enough. */
  479. return 0;
  480. }
  481. if (storage_dir_rescan(d) < 0)
  482. return -1;
  483. const uint64_t orig_usage = storage_dir_get_usage(d);
  484. if (orig_usage <= target_size && !min_to_remove) {
  485. /* Okay, small enough after rescan! */
  486. return 0;
  487. }
  488. const int n = smartlist_len(d->contents);
  489. shrinking_dir_entry_t *ents = tor_calloc(n, sizeof(shrinking_dir_entry_t));
  490. SMARTLIST_FOREACH_BEGIN(d->contents, const char *, fname) {
  491. shrinking_dir_entry_t *ent = &ents[fname_sl_idx];
  492. struct stat st;
  493. tor_asprintf(&ent->path, "%s/%s", d->directory, fname);
  494. if (stat(sandbox_intern_string(ent->path), &st) == 0) {
  495. ent->mtime = st.st_mtime;
  496. ent->size = st.st_size;
  497. }
  498. } SMARTLIST_FOREACH_END(fname);
  499. qsort(ents, n, sizeof(shrinking_dir_entry_t), shrinking_dir_entry_compare);
  500. int idx = 0;
  501. while ((d->usage > target_size || min_to_remove > 0) && idx < n) {
  502. if (unlink(sandbox_intern_string(ents[idx].path)) == 0) {
  503. storage_dir_reduce_usage(d, ents[idx].size);
  504. --min_to_remove;
  505. }
  506. ++idx;
  507. }
  508. for (idx = 0; idx < n; ++idx) {
  509. tor_free(ents[idx].path);
  510. }
  511. tor_free(ents);
  512. storage_dir_rescan(d);
  513. return 0;
  514. }
  515. /** Remove all files in <b>d</b>. */
  516. int
  517. storage_dir_remove_all(storage_dir_t *d)
  518. {
  519. return storage_dir_shrink(d, 0, d->max_files);
  520. }
  521. /**
  522. * Return the largest number of non-temporary files we're willing to
  523. * store in <b>d</b>.
  524. */
  525. int
  526. storage_dir_get_max_files(storage_dir_t *d)
  527. {
  528. return d->max_files;
  529. }