storagedir.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569
  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. tor_mmap_t *
  173. storage_dir_map(storage_dir_t *d, const char *fname)
  174. {
  175. char *path = NULL;
  176. tor_asprintf(&path, "%s/%s", d->directory, fname);
  177. tor_mmap_t *result = tor_mmap_file(path);
  178. tor_free(path);
  179. return result;
  180. }
  181. /** Read a file within <b>d</b> into a newly allocated buffer. Set
  182. * *<b>sz_out</b> to its size. */
  183. uint8_t *
  184. storage_dir_read(storage_dir_t *d, const char *fname, int bin, size_t *sz_out)
  185. {
  186. const int flags = bin ? RFTS_BIN : 0;
  187. char *path = NULL;
  188. tor_asprintf(&path, "%s/%s", d->directory, fname);
  189. struct stat st;
  190. char *contents = read_file_to_str(path, flags, &st);
  191. if (contents && sz_out) {
  192. // it fits in RAM, so we know its size is less than SIZE_MAX
  193. #if UINT64_MAX > SIZE_MAX
  194. tor_assert((uint64_t)st.st_size <= SIZE_MAX);
  195. #endif
  196. *sz_out = (size_t) st.st_size;
  197. }
  198. tor_free(path);
  199. return (uint8_t *) contents;
  200. }
  201. /** Helper: Find an unused filename within the directory */
  202. static char *
  203. find_unused_fname(storage_dir_t *d)
  204. {
  205. if (!d->contents) {
  206. if (storage_dir_rescan(d) < 0)
  207. return NULL;
  208. }
  209. char buf[16];
  210. int i;
  211. /* Yuck; this is quadratic. Fortunately, that shouldn't matter much,
  212. * since disk writes are more expensive by a lot. */
  213. for (i = FNAME_MIN_NUM; i < FNAME_MIN_NUM + d->max_files; ++i) {
  214. tor_snprintf(buf, sizeof(buf), "%d", i);
  215. if (!smartlist_contains_string(d->contents, buf)) {
  216. return tor_strdup(buf);
  217. }
  218. }
  219. return NULL;
  220. }
  221. /** Helper: As storage_dir_save_bytes_to_file, but store a smartlist of
  222. * sized_chunk_t rather than a single byte array. */
  223. static int
  224. storage_dir_save_chunks_to_file(storage_dir_t *d,
  225. const smartlist_t *chunks,
  226. int binary,
  227. char **fname_out)
  228. {
  229. uint64_t total_length = 0;
  230. char *fname = find_unused_fname(d);
  231. if (!fname)
  232. return -1;
  233. SMARTLIST_FOREACH(chunks, const sized_chunk_t *, ch,
  234. total_length += ch->len);
  235. char *path = NULL;
  236. tor_asprintf(&path, "%s/%s", d->directory, fname);
  237. int r = write_chunks_to_file(path, chunks, binary, 0);
  238. if (r == 0) {
  239. if (d->usage_known)
  240. d->usage += total_length;
  241. if (fname_out) {
  242. *fname_out = tor_strdup(fname);
  243. }
  244. if (d->contents)
  245. smartlist_add(d->contents, tor_strdup(fname));
  246. }
  247. tor_free(fname);
  248. tor_free(path);
  249. return r;
  250. }
  251. /** Try to write the <b>length</b> bytes at <b>data</b> into a new file
  252. * in <b>d</b>. On success, return 0 and set *<b>fname_out</b> to a
  253. * newly allocated string containing the filename. On failure, return
  254. * -1. */
  255. int
  256. storage_dir_save_bytes_to_file(storage_dir_t *d,
  257. const uint8_t *data,
  258. size_t length,
  259. int binary,
  260. char **fname_out)
  261. {
  262. smartlist_t *chunks = smartlist_new();
  263. sized_chunk_t chunk = { (const char *)data, length };
  264. smartlist_add(chunks, &chunk);
  265. int r = storage_dir_save_chunks_to_file(d, chunks, binary, fname_out);
  266. smartlist_free(chunks);
  267. return r;
  268. }
  269. /**
  270. * As storage_dir_save_bytes_to_file, but saves a NUL-terminated string
  271. * <b>str</b>.
  272. */
  273. int
  274. storage_dir_save_string_to_file(storage_dir_t *d,
  275. const char *str,
  276. int binary,
  277. char **fname_out)
  278. {
  279. return storage_dir_save_bytes_to_file(d,
  280. (const uint8_t*)str, strlen(str), binary, fname_out);
  281. }
  282. /**
  283. * As storage_dir_save_bytes_to_file, but associates the data with the
  284. * key-value pairs in <b>labels</b>. Files stored in this format can be
  285. * recovered with storage_dir_map_labeled() or storage_dir_read_labeled().
  286. */
  287. int
  288. storage_dir_save_labeled_to_file(storage_dir_t *d,
  289. const config_line_t *labels,
  290. const uint8_t *data,
  291. size_t length,
  292. char **fname_out)
  293. {
  294. /*
  295. * The storage format is to prefix the data with the key-value pairs in
  296. * <b>labels</b>, and a single NUL separator. But code outside this module
  297. * MUST NOT rely on that format.
  298. */
  299. smartlist_t *chunks = smartlist_new();
  300. memarea_t *area = memarea_new();
  301. const config_line_t *line;
  302. for (line = labels; line; line = line->next) {
  303. sized_chunk_t *sz = memarea_alloc(area, sizeof(sized_chunk_t));
  304. sz->len = strlen(line->key) + 1 + strlen(line->value) + 1;
  305. const size_t allocated = sz->len + 1;
  306. char *bytes = memarea_alloc(area, allocated);
  307. tor_snprintf(bytes, allocated, "%s %s\n", line->key, line->value);
  308. sz->bytes = bytes;
  309. smartlist_add(chunks, sz);
  310. }
  311. sized_chunk_t *nul = memarea_alloc(area, sizeof(sized_chunk_t));
  312. nul->len = 1;
  313. nul->bytes = "\0";
  314. smartlist_add(chunks, nul);
  315. sized_chunk_t *datachunk = memarea_alloc(area, sizeof(sized_chunk_t));
  316. datachunk->bytes = (const char *)data;
  317. datachunk->len = length;
  318. smartlist_add(chunks, datachunk);
  319. int r = storage_dir_save_chunks_to_file(d, chunks, 1, fname_out);
  320. smartlist_free(chunks);
  321. memarea_drop_all(area);
  322. return r;
  323. }
  324. /**
  325. * Map a file that was created with storage_dir_save_labeled_to_file(). On
  326. * failure, return NULL. On success, write a set of newly allocated labels
  327. * into *<b>labels_out</b>, a pointer to the data into *<b>data_out</b>, and
  328. * the data's size into *<b>sz_out</b>. On success, also return a tor_mmap_t
  329. * object whose contents should not be used -- it needs to be kept around,
  330. * though, for as long as <b>data_out</b> is going to be valid.
  331. */
  332. tor_mmap_t *
  333. storage_dir_map_labeled(storage_dir_t *dir,
  334. const char *fname,
  335. config_line_t **labels_out,
  336. const uint8_t **data_out,
  337. size_t *sz_out)
  338. {
  339. tor_mmap_t *m = storage_dir_map(dir, fname);
  340. if (! m)
  341. goto err;
  342. const char *nulp = memchr(m->data, '\0', m->size);
  343. if (! nulp)
  344. goto err;
  345. if (labels_out && config_get_lines(m->data, labels_out, 0) < 0)
  346. goto err;
  347. size_t offset = nulp - m->data + 1;
  348. tor_assert(offset <= m->size);
  349. *data_out = (const uint8_t *)(m->data + offset);
  350. *sz_out = m->size - offset;
  351. return m;
  352. err:
  353. tor_munmap_file(m);
  354. return NULL;
  355. }
  356. /** As storage_dir_map_labeled, but return a new byte array containing the
  357. * data. */
  358. uint8_t *
  359. storage_dir_read_labeled(storage_dir_t *dir,
  360. const char *fname,
  361. config_line_t **labels_out,
  362. size_t *sz_out)
  363. {
  364. const uint8_t *data = NULL;
  365. tor_mmap_t *m = storage_dir_map_labeled(dir, fname, labels_out,
  366. &data, sz_out);
  367. if (m == NULL)
  368. return NULL;
  369. uint8_t *result = tor_memdup(data, *sz_out);
  370. tor_munmap_file(m);
  371. return result;
  372. }
  373. /* Reduce the cached usage amount in <b>d</b> by <b>removed_file_size</b>.
  374. * This function is a no-op if <b>d->usage_known</b> is 0. */
  375. static void
  376. storage_dir_reduce_usage(storage_dir_t *d, uint64_t removed_file_size)
  377. {
  378. if (d->usage_known) {
  379. if (! BUG(d->usage < removed_file_size)) {
  380. /* This bug can also be triggered if an external process resized a file
  381. * between the call to storage_dir_get_usage() that last checked
  382. * actual usage (rather than relaying on cached usage), and the call to
  383. * this function. */
  384. d->usage -= removed_file_size;
  385. } else {
  386. /* If we underflowed the cached directory size, re-check the sizes of all
  387. * the files in the directory. This makes storage_dir_shrink() quadratic,
  388. * but only if a process is continually changing file sizes in the
  389. * storage directory (in which case, we have bigger issues).
  390. *
  391. * We can't just reset usage_known, because storage_dir_shrink() relies
  392. * on knowing the usage. */
  393. storage_dir_rescan(d);
  394. (void)storage_dir_get_usage(d);
  395. }
  396. }
  397. }
  398. /**
  399. * Remove the file called <b>fname</b> from <b>d</b>.
  400. */
  401. void
  402. storage_dir_remove_file(storage_dir_t *d,
  403. const char *fname)
  404. {
  405. char *path = NULL;
  406. tor_asprintf(&path, "%s/%s", d->directory, fname);
  407. const char *ipath = sandbox_intern_string(path);
  408. uint64_t size = 0;
  409. if (d->usage_known) {
  410. struct stat st;
  411. if (stat(ipath, &st) == 0) {
  412. size = st.st_size;
  413. }
  414. }
  415. if (unlink(ipath) == 0) {
  416. storage_dir_reduce_usage(d, size);
  417. } else {
  418. log_warn(LD_FS, "Unable to unlink %s while removing file: %s",
  419. escaped(path), strerror(errno));
  420. tor_free(path);
  421. return;
  422. }
  423. if (d->contents) {
  424. smartlist_string_remove(d->contents, fname);
  425. }
  426. tor_free(path);
  427. }
  428. /** Helper type: used to sort the members of storage directory by mtime. */
  429. typedef struct shrinking_dir_entry_t {
  430. time_t mtime;
  431. uint64_t size;
  432. char *path;
  433. } shrinking_dir_entry_t;
  434. /** Helper: use with qsort to sort shrinking_dir_entry_t structs. */
  435. static int
  436. shrinking_dir_entry_compare(const void *a_, const void *b_)
  437. {
  438. const shrinking_dir_entry_t *a = a_;
  439. const shrinking_dir_entry_t *b = b_;
  440. if (a->mtime < b->mtime)
  441. return -1;
  442. else if (a->mtime > b->mtime)
  443. return 1;
  444. else
  445. return 0;
  446. }
  447. /**
  448. * Try to free space by removing the oldest files in <b>d</b>. Delete
  449. * until no more than <b>target_size</b> bytes are left, and at least
  450. * <b>min_to_remove</b> files have been removed... or until there is
  451. * nothing left to remove.
  452. *
  453. * Return 0 on success; -1 on failure.
  454. */
  455. int
  456. storage_dir_shrink(storage_dir_t *d,
  457. uint64_t target_size,
  458. int min_to_remove)
  459. {
  460. if (d->usage_known && d->usage <= target_size && !min_to_remove) {
  461. /* Already small enough. */
  462. return 0;
  463. }
  464. if (storage_dir_rescan(d) < 0)
  465. return -1;
  466. const uint64_t orig_usage = storage_dir_get_usage(d);
  467. if (orig_usage <= target_size && !min_to_remove) {
  468. /* Okay, small enough after rescan! */
  469. return 0;
  470. }
  471. const int n = smartlist_len(d->contents);
  472. shrinking_dir_entry_t *ents = tor_calloc(n, sizeof(shrinking_dir_entry_t));
  473. SMARTLIST_FOREACH_BEGIN(d->contents, const char *, fname) {
  474. shrinking_dir_entry_t *ent = &ents[fname_sl_idx];
  475. struct stat st;
  476. tor_asprintf(&ent->path, "%s/%s", d->directory, fname);
  477. if (stat(sandbox_intern_string(ent->path), &st) == 0) {
  478. ent->mtime = st.st_mtime;
  479. ent->size = st.st_size;
  480. }
  481. } SMARTLIST_FOREACH_END(fname);
  482. qsort(ents, n, sizeof(shrinking_dir_entry_t), shrinking_dir_entry_compare);
  483. int idx = 0;
  484. while ((d->usage > target_size || min_to_remove > 0) && idx < n) {
  485. if (unlink(sandbox_intern_string(ents[idx].path)) == 0) {
  486. storage_dir_reduce_usage(d, ents[idx].size);
  487. --min_to_remove;
  488. }
  489. ++idx;
  490. }
  491. for (idx = 0; idx < n; ++idx) {
  492. tor_free(ents[idx].path);
  493. }
  494. tor_free(ents);
  495. storage_dir_rescan(d);
  496. return 0;
  497. }
  498. /** Remove all files in <b>d</b>. */
  499. int
  500. storage_dir_remove_all(storage_dir_t *d)
  501. {
  502. return storage_dir_shrink(d, 0, d->max_files);
  503. }
  504. /**
  505. * Return the largest number of non-temporary files we're willing to
  506. * store in <b>d</b>.
  507. */
  508. int
  509. storage_dir_get_max_files(storage_dir_t *d)
  510. {
  511. return d->max_files;
  512. }