2 * Copyright (c) 2008 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * $DragonFly: src/sbin/hammer/cmd_softprune.c,v 1.7 2008/08/21 23:28:43 thomas Exp $
40 struct softprune *next;
43 struct hammer_ioc_prune prune;
48 static void hammer_softprune_scandir(struct softprune **basep,
49 struct hammer_ioc_prune *template,
51 static int hammer_softprune_scanmeta(int fd, struct softprune *scan,
53 static void hammer_meta_flushdelete(int fd, struct hammer_ioc_snapshot *dsnap);
54 static struct softprune *hammer_softprune_addentry(struct softprune **basep,
55 struct hammer_ioc_prune *template,
56 const char *dirpath, const char *denname,
58 const char *linkbuf, const char *tidptr);
59 static void hammer_softprune_addelm(struct softprune *scan, hammer_tid_t tid,
60 time_t ct, time_t mt);
61 static void hammer_softprune_finalize(struct softprune *scan);
62 static void softprune_usage(int code);
65 * prune <softlink-dir>
66 * prune-everything <filesystem>
69 hammer_cmd_softprune(char **av, int ac, int everything_opt)
71 struct hammer_ioc_prune template;
72 struct hammer_ioc_pseudofs_rw pfs;
73 struct softprune *base, *scan;
82 bzero(&pfs, sizeof(pfs));
83 pfs.bytes = sizeof(*pfs.ondisk);
84 pfs.ondisk = malloc(pfs.bytes);
85 bzero(pfs.ondisk, pfs.bytes);
89 * NOTE: To restrict to a single file XXX we have to set
90 * the localization the same (not yet implemented). Typically
91 * two passes would be needed, one using HAMMER_LOCALIZE_MISC
92 * and one using HAMMER_LOCALIZE_INODE.
95 bzero(&template, sizeof(template));
96 template.key_beg.localization = HAMMER_MIN_LOCALIZATION;
97 template.key_beg.obj_id = HAMMER_MIN_OBJID;
98 template.key_end.localization = HAMMER_MAX_LOCALIZATION;
99 template.key_end.obj_id = HAMMER_MAX_OBJID;
100 hammer_get_cycle(&template.key_end, NULL);
101 template.stat_oldest_tid = HAMMER_MAX_TID;
104 * For now just allow one directory
106 if (ac == 0 || ac > 1)
110 * Scan the softlink directory.
112 if (everything_opt) {
113 const char *dummylink = "";
114 scan = hammer_softprune_addentry(&base, &template,
116 dummylink, dummylink);
119 scan->prune.nelms = 0;
120 scan->prune.head.flags |= HAMMER_IOC_PRUNE_ALL;
122 hammer_softprune_scandir(&base, &template, *av);
124 const char *dummylink = "";
125 scan = hammer_softprune_addentry(&base, &template,
127 dummylink, dummylink);
130 scan->prune.nelms = 0;
137 * XXX future (need to store separate cycles for each filesystem)
140 fprintf(stderr, "Currently only one HAMMER filesystem may "
141 "be specified in the softlink scan\n");
148 for (scan = base; scan; scan = scan->next) {
150 * Open the filesystem for ioctl calls and extract the
153 fd = open(scan->filesystem, O_RDONLY);
155 warn("Unable to open %s", scan->filesystem);
160 if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) < 0) {
161 warn("Filesystem %s is not HAMMER", scan->filesystem);
166 scan->prune_min = pfs.ondisk->prune_min;
169 * Incorporate meta-data snapshots into the pruning regimen.
170 * If pruning everything we delete the meta-data snapshots.
172 if (hammer_softprune_scanmeta(fd, scan, everything_opt) < 0) {
173 warn("Filesystem %s could not scan meta-data snaps",
181 * Finalize operations
183 hammer_softprune_finalize(scan);
184 if (everything_opt) {
185 printf("Prune %s: EVERYTHING\n",
188 printf("Prune %s: %d snapshots\n",
189 scan->filesystem, scan->prune.nelms);
191 if (scan->prune.nelms == 0 &&
192 (scan->prune.head.flags & HAMMER_IOC_PRUNE_ALL) == 0) {
193 fprintf(stderr, "No snapshots found\n");
197 printf("Prune %s: objspace %016jx:%04x %016jx:%04x "
200 (uintmax_t)scan->prune.key_beg.obj_id,
201 scan->prune.key_beg.localization,
202 (uintmax_t)scan->prune.key_end.obj_id,
203 scan->prune.key_end.localization,
205 printf("Prune %s: prune_min is %dd/%02d:%02d:%02d\n",
207 pfs.ondisk->prune_min / (24 * 60 * 60),
208 pfs.ondisk->prune_min / 60 / 60 % 24,
209 pfs.ondisk->prune_min / 60 % 60,
210 pfs.ondisk->prune_min % 60);
213 if (ioctl(fd, HAMMERIOC_PRUNE, &scan->prune) < 0) {
214 printf("Prune %s failed: %s\n",
215 scan->filesystem, strerror(errno));
217 } else if (scan->prune.head.flags & HAMMER_IOC_HEAD_INTR) {
218 printf("Prune %s interrupted by timer at "
221 (uintmax_t)scan->prune.key_cur.obj_id,
222 scan->prune.key_cur.localization);
224 hammer_set_cycle(&scan->prune.key_cur, 0);
228 hammer_reset_cycle();
229 printf("Prune %s succeeded\n", scan->filesystem);
231 printf("Pruned %jd/%jd records (%jd directory entries) "
233 (uintmax_t)scan->prune.stat_rawrecords,
234 (uintmax_t)scan->prune.stat_scanrecords,
235 (uintmax_t)scan->prune.stat_dirrecords,
236 (uintmax_t)scan->prune.stat_bytes
246 * Scan a directory for softlinks representing snapshots and build
247 * associated softprune structures.
249 * NOTE: Once a filesystem is completely converted to the meta-data
250 * snapshot mechanic we don't have to scan softlinks any more
251 * and can just use the meta-data. But for now we do both.
254 hammer_softprune_scandir(struct softprune **basep,
255 struct hammer_ioc_prune *template,
267 linkbuf = malloc(MAXPATHLEN);
269 if ((dir = opendir(dirname)) == NULL)
270 err(1, "Cannot open directory %s", dirname);
271 while ((den = readdir(dir)) != NULL) {
272 if (strcmp(den->d_name, ".") == 0)
274 if (strcmp(den->d_name, "..") == 0)
278 asprintf(&path, "%s/%s", dirname, den->d_name);
279 if (lstat(path, &st) < 0)
281 if (!S_ISLNK(st.st_mode))
283 if ((len = readlink(path, linkbuf, MAXPATHLEN - 1)) < 0)
286 if ((ptr = strrchr(linkbuf, '@')) &&
287 ptr > linkbuf && ptr[-1] == '@') {
288 hammer_softprune_addentry(basep, template,
289 dirname, den->d_name, &st,
299 * Scan a directory for softlinks representing snapshots.
300 * Return 1 if the directory contains snapshots, otherwise 0.
303 hammer_softprune_testdir(const char *dirname)
305 struct softprune *base = NULL;
306 struct hammer_ioc_prune dummy_template;
308 bzero(&dummy_template, sizeof(dummy_template));
309 hammer_softprune_scandir(&base, &dummy_template, dirname);
317 * Scan the metadata snapshots for the filesystem and either delete them
318 * or add them to the pruning list.
322 hammer_softprune_scanmeta(int fd, struct softprune *scan, int delete_all)
324 struct hammer_ioc_version version;
325 struct hammer_ioc_snapshot snapshot;
326 struct hammer_ioc_snapshot dsnapshot;
327 hammer_snapshot_data_t snap;
331 * Stop if we can't get the version. Meta-data snapshots only
332 * exist for HAMMER version 3 or greater.
334 bzero(&version, sizeof(version));
335 if (ioctl(fd, HAMMERIOC_GET_VERSION, &version) < 0)
337 if (version.cur_version < 3)
340 bzero(&snapshot, sizeof(snapshot));
341 bzero(&dsnapshot, sizeof(dsnapshot));
344 * Scan meta-data snapshots, either add them to the prune list or
345 * delete them. When deleting, just skip any entries which cannot
349 if (ioctl(fd, HAMMERIOC_GET_SNAPSHOT, &snapshot) < 0) {
350 printf("hammer prune: Unable to access "
351 "meta-data snaps: %s\n", strerror(errno));
354 while (snapshot.index < snapshot.count) {
355 snap = &snapshot.snaps[snapshot.index];
357 dsnapshot.snaps[dsnapshot.count++] = *snap;
358 if (dsnapshot.count == HAMMER_SNAPS_PER_IOCTL)
359 hammer_meta_flushdelete(fd, &dsnapshot);
361 ct = snap->ts / 1000000ULL;
362 hammer_softprune_addelm(scan, snap->tid,
367 if (snapshot.head.flags & HAMMER_IOC_SNAPSHOT_EOF)
372 hammer_meta_flushdelete(fd, &dsnapshot);
377 * Flush any entries built up in the deletion snapshot ioctl structure.
378 * Used during a prune-everything.
381 hammer_meta_flushdelete(int fd, struct hammer_ioc_snapshot *dsnap)
383 while (dsnap->index < dsnap->count) {
384 if (ioctl(fd, HAMMERIOC_DEL_SNAPSHOT, dsnap) < 0)
386 if (dsnap->head.error == 0)
395 * Add the softlink to the appropriate softprune structure, creating a new
400 hammer_softprune_addentry(struct softprune **basep,
401 struct hammer_ioc_prune *template,
402 const char *dirpath, const char *denname __unused,
404 const char *linkbuf, const char *tidptr)
406 struct softprune *scan;
411 * Calculate filesystem path.
413 if (linkbuf[0] == '/') {
414 asprintf(&fspath, "%*.*s",
415 (int)(tidptr - linkbuf), (int)(tidptr - linkbuf),
418 asprintf(&fspath, "%s/%*.*s", dirpath,
419 (int)(tidptr - linkbuf), (int)(tidptr - linkbuf),
422 if (statfs(fspath, &fs) < 0) {
428 * Locate the filesystem in an existing softprune structure
430 for (scan = *basep; scan; scan = scan->next) {
431 if (bcmp(&fs.f_fsid, &scan->fs.f_fsid, sizeof(fs.f_fsid)) != 0)
433 if (strcmp(fs.f_mntonname, scan->fs.f_mntonname) != 0)
439 * Create a new softprune structure if necessasry
442 scan = malloc(sizeof(*scan));
443 bzero(scan, sizeof(*scan));
446 scan->filesystem = fspath;
447 scan->prune = *template;
449 scan->prune.elms = malloc(sizeof(struct hammer_ioc_prune_elm) *
456 hammer_softprune_addelm(scan,
457 (hammer_tid_t)strtoull(tidptr + 2, NULL, 0),
458 (st ? st->st_ctime : 0),
459 (st ? st->st_mtime : 0));
464 * Add the entry (unsorted). Just set the beg_tid, we will sort
465 * and set the remaining entries later.
467 * Always leave one entry free for our terminator.
470 hammer_softprune_addelm(struct softprune *scan, hammer_tid_t tid,
471 time_t ct, time_t mt)
473 struct hammer_ioc_prune_elm *elm;
475 if (scan->prune.nelms >= scan->maxelms - 1) {
476 scan->maxelms = (scan->maxelms * 3 / 2);
477 scan->prune.elms = realloc(scan->prune.elms,
478 sizeof(*elm) * scan->maxelms);
482 * NOTE: Temporarily store the snapshot timestamp in mod_tid.
483 * This will be cleaned up in the finalization phase.
485 elm = &scan->prune.elms[scan->prune.nelms];
497 * Finalize a softprune structure after scanning in its softlinks.
498 * Sort the elements, remove duplicates, and then fill in end_tid and
501 * The array must end up in descending order.
504 hammer_softprune_qsort_cmp(const void *arg1, const void *arg2)
506 const struct hammer_ioc_prune_elm *elm1 = arg1;
507 const struct hammer_ioc_prune_elm *elm2 = arg2;
509 if (elm1->beg_tid < elm2->beg_tid)
511 if (elm1->beg_tid > elm2->beg_tid)
517 hammer_softprune_finalize(struct softprune *scan)
519 struct hammer_ioc_prune_elm *elm;
525 * Don't do anything if there are no elements.
527 if (scan->prune.nelms == 0)
531 * Sort the elements in descending order, remove duplicates, and
532 * fill in any missing bits.
534 qsort(scan->prune.elms, scan->prune.nelms, sizeof(*elm),
535 hammer_softprune_qsort_cmp);
537 for (i = 0; i < scan->prune.nelms; ++i) {
538 elm = &scan->prune.elms[i];
541 * First (highest TID) (also last if only one element)
543 elm->end_tid = HAMMER_MAX_TID;
544 } else if (elm[0].beg_tid == elm[-1].beg_tid) {
549 if (i != scan->prune.nelms) {
551 (scan->prune.nelms - i) * sizeof(*elm));
559 elm->end_tid = elm[-1].beg_tid;
564 * If a minimum retention time (in seconds) is configured for the
565 * PFS, remove any snapshots from the pruning list that are within
568 if (scan->prune_min) {
570 for (i = scan->prune.nelms - 1; i >= 0; --i) {
571 elm = &scan->prune.elms[i];
572 if (elm->mod_tid == 0)
574 delta = (long)(t - (time_t)elm->mod_tid);
575 if (delta < scan->prune_min)
580 printf("Prune %s: prune_min: Will not clean between "
581 "the teeth of the first %d snapshots\n",
582 scan->filesystem, i);
583 bcopy(&scan->prune.elms[i], &scan->prune.elms[0],
584 (scan->prune.nelms - i) * sizeof(scan->prune.elms[0]));
585 scan->prune.elms[0].end_tid = HAMMER_MAX_TID;
586 scan->prune.nelms -= i;
591 * Remove the first entry. This entry represents the prune from
592 * the most recent snapshot to current. We wish to retain the
593 * fine-grained history for this region.
595 if (scan->prune.nelms) {
596 bcopy(&scan->prune.elms[1], &scan->prune.elms[0],
597 (scan->prune.nelms - 1) * sizeof(scan->prune.elms[0]));
602 * Add a final element to prune everything from transaction id
603 * 0 to the lowest transaction id (aka last so far).
605 if (scan->prune.nelms) {
606 assert(scan->prune.nelms < scan->maxelms);
607 elm = &scan->prune.elms[scan->prune.nelms];
609 elm->end_tid = elm[-1].beg_tid;
614 * Adjust mod_tid to what the ioctl() expects.
616 for (i = 0; i < scan->prune.nelms; ++i) {
617 elm = &scan->prune.elms[i];
618 elm->mod_tid = elm->end_tid - elm->beg_tid;
619 printf("TID %016jx - %016jx\n",
620 (uintmax_t)elm->beg_tid, (uintmax_t)elm->end_tid);
626 softprune_usage(int code)
628 fprintf(stderr, "Badly formed prune command, use:\n");
629 fprintf(stderr, "hammer prune <softlink-dir>\n");
630 fprintf(stderr, "hammer prune-everything <filesystem>\n");