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 clrpfs(&pfs
, NULL
, -1);
85 * NOTE: To restrict to a single file XXX we have to set
86 * the localization the same (not yet implemented). Typically
87 * two passes would be needed, one using HAMMER_LOCALIZE_MISC
88 * and one using HAMMER_LOCALIZE_INODE.
91 bzero(&template, sizeof(template));
92 template.key_beg
.localization
= HAMMER_MIN_LOCALIZATION
;
93 template.key_beg
.obj_id
= HAMMER_MIN_OBJID
;
94 template.key_end
.localization
= HAMMER_MAX_LOCALIZATION
;
95 template.key_end
.obj_id
= HAMMER_MAX_OBJID
;
96 hammer_get_cycle(&template.key_end
, NULL
);
97 template.stat_oldest_tid
= HAMMER_MAX_TID
;
100 * For now just allow one directory
102 if (ac
== 0 || ac
> 1) {
108 * Scan the softlink directory.
110 if (everything_opt
) {
111 const char *dummylink
= "";
112 scan
= hammer_softprune_addentry(&base
, &template,
114 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
);
132 scan
->prune
.nelms
= 0;
139 * XXX future (need to store separate cycles for each filesystem)
142 errx(1, "Currently only one HAMMER filesystem may "
143 "be specified in the softlink scan");
150 for (scan
= base
; scan
; scan
= scan
->next
) {
152 * Open the filesystem for ioctl calls and extract the
155 fd
= open(scan
->filesystem
, O_RDONLY
);
157 warn("Unable to open %s", scan
->filesystem
);
162 if (ioctl(fd
, HAMMERIOC_GET_PSEUDOFS
, &pfs
) < 0) {
163 warn("Filesystem %s is not HAMMER", scan
->filesystem
);
168 scan
->prune_min
= pfs
.ondisk
->prune_min
;
171 * Incorporate meta-data snapshots into the pruning regimen.
172 * If pruning everything we delete the meta-data snapshots.
174 if (hammer_softprune_scanmeta(fd
, scan
, everything_opt
) < 0) {
175 warn("Filesystem %s could not scan meta-data snaps",
183 * Finalize operations
185 hammer_softprune_finalize(scan
);
186 if (everything_opt
) {
187 printf("Prune %s: EVERYTHING\n",
190 printf("Prune %s: %d snapshots\n",
191 scan
->filesystem
, scan
->prune
.nelms
);
193 if (scan
->prune
.nelms
== 0 &&
194 (scan
->prune
.head
.flags
& HAMMER_IOC_PRUNE_ALL
) == 0) {
195 fprintf(stderr
, "No snapshots found\n");
199 printf("Prune %s: objspace %016jx:%04x %016jx:%04x "
202 (uintmax_t)scan
->prune
.key_beg
.obj_id
,
203 scan
->prune
.key_beg
.localization
,
204 (uintmax_t)scan
->prune
.key_end
.obj_id
,
205 scan
->prune
.key_end
.localization
,
207 printf("Prune %s: prune_min is %dd/%02d:%02d:%02d\n",
209 pfs
.ondisk
->prune_min
/ (24 * 60 * 60),
210 pfs
.ondisk
->prune_min
/ 60 / 60 % 24,
211 pfs
.ondisk
->prune_min
/ 60 % 60,
212 pfs
.ondisk
->prune_min
% 60);
215 if (ioctl(fd
, HAMMERIOC_PRUNE
, &scan
->prune
) < 0) {
216 printf("Prune %s failed: %s\n",
217 scan
->filesystem
, strerror(errno
));
219 } else if (scan
->prune
.head
.flags
& HAMMER_IOC_HEAD_INTR
) {
220 printf("Prune %s interrupted by timer at "
223 (uintmax_t)scan
->prune
.key_cur
.obj_id
,
224 scan
->prune
.key_cur
.localization
);
226 hammer_set_cycle(&scan
->prune
.key_cur
, 0);
230 hammer_reset_cycle();
231 printf("Prune %s succeeded\n", scan
->filesystem
);
233 printf("Pruned %jd/%jd records (%jd directory entries) "
235 (uintmax_t)scan
->prune
.stat_rawrecords
,
236 (uintmax_t)scan
->prune
.stat_scanrecords
,
237 (uintmax_t)scan
->prune
.stat_dirrecords
,
238 (uintmax_t)scan
->prune
.stat_bytes
248 * Scan a directory for softlinks representing snapshots and build
249 * associated softprune structures.
251 * NOTE: Once a filesystem is completely converted to the meta-data
252 * snapshot mechanic we don't have to scan softlinks any more
253 * and can just use the meta-data. But for now we do both.
257 hammer_softprune_scandir(struct softprune
**basep
,
258 struct hammer_ioc_prune
*template,
270 linkbuf
= malloc(MAXPATHLEN
);
272 if ((dir
= opendir(dirname
)) == NULL
) {
273 err(1, "Cannot open directory %s", dirname
);
276 while ((den
= readdir(dir
)) != NULL
) {
277 if (strcmp(den
->d_name
, ".") == 0)
279 if (strcmp(den
->d_name
, "..") == 0)
283 asprintf(&path
, "%s/%s", dirname
, den
->d_name
);
284 if (lstat(path
, &st
) < 0)
286 if (!S_ISLNK(st
.st_mode
))
288 if ((len
= readlink(path
, linkbuf
, MAXPATHLEN
- 1)) < 0)
291 if ((ptr
= strrchr(linkbuf
, '@')) &&
292 ptr
> linkbuf
&& ptr
[-1] == '@') {
293 hammer_softprune_addentry(basep
, template,
294 dirname
, den
->d_name
, &st
,
304 * Scan a directory for softlinks representing snapshots.
305 * Return 1 if the directory contains snapshots, otherwise 0.
308 hammer_softprune_testdir(const char *dirname
)
310 struct softprune
*base
= NULL
;
311 struct hammer_ioc_prune dummy_template
;
313 bzero(&dummy_template
, sizeof(dummy_template
));
314 hammer_softprune_scandir(&base
, &dummy_template
, dirname
);
322 * Scan the metadata snapshots for the filesystem and either delete them
323 * or add them to the pruning list.
327 hammer_softprune_scanmeta(int fd
, struct softprune
*scan
, int delete_all
)
329 struct hammer_ioc_version version
;
330 struct hammer_ioc_snapshot snapshot
;
331 struct hammer_ioc_snapshot dsnapshot
;
332 hammer_snapshot_data_t snap
;
336 * Stop if we can't get the version. Meta-data snapshots only
337 * exist for HAMMER version 3 or greater.
339 bzero(&version
, sizeof(version
));
340 if (ioctl(fd
, HAMMERIOC_GET_VERSION
, &version
) < 0)
342 HammerVersion
= version
.cur_version
;
343 if (version
.cur_version
< 3)
346 bzero(&snapshot
, sizeof(snapshot
));
347 bzero(&dsnapshot
, sizeof(dsnapshot
));
350 * Scan meta-data snapshots, either add them to the prune list or
351 * delete them. When deleting, just skip any entries which cannot
355 if (ioctl(fd
, HAMMERIOC_GET_SNAPSHOT
, &snapshot
) < 0) {
356 printf("hammer prune: Unable to access "
357 "meta-data snaps: %s\n", strerror(errno
));
360 while (snapshot
.index
< snapshot
.count
) {
361 snap
= &snapshot
.snaps
[snapshot
.index
];
363 dsnapshot
.snaps
[dsnapshot
.count
++] = *snap
;
364 if (dsnapshot
.count
== HAMMER_SNAPS_PER_IOCTL
)
365 hammer_meta_flushdelete(fd
, &dsnapshot
);
367 ct
= snap
->ts
/ 1000000ULL;
368 hammer_softprune_addelm(scan
, snap
->tid
,
373 if (snapshot
.head
.flags
& HAMMER_IOC_SNAPSHOT_EOF
)
378 hammer_meta_flushdelete(fd
, &dsnapshot
);
383 * Flush any entries built up in the deletion snapshot ioctl structure.
384 * Used during a prune-everything.
388 hammer_meta_flushdelete(int fd
, struct hammer_ioc_snapshot
*dsnap
)
390 while (dsnap
->index
< dsnap
->count
) {
391 if (ioctl(fd
, HAMMERIOC_DEL_SNAPSHOT
, dsnap
) < 0)
393 if (dsnap
->head
.error
== 0)
402 * Add the softlink to the appropriate softprune structure, creating a new
407 hammer_softprune_addentry(struct softprune
**basep
,
408 struct hammer_ioc_prune
*template,
409 const char *dirpath
, const char *denname __unused
,
411 const char *linkbuf
, const char *tidptr
)
413 struct softprune
*scan
;
418 * Calculate filesystem path.
420 if (linkbuf
[0] == '/') {
421 asprintf(&fspath
, "%*.*s",
422 (int)(tidptr
- linkbuf
), (int)(tidptr
- linkbuf
),
425 asprintf(&fspath
, "%s/%*.*s", dirpath
,
426 (int)(tidptr
- linkbuf
), (int)(tidptr
- linkbuf
),
429 if (statfs(fspath
, &fs
) < 0) {
435 * Locate the filesystem in an existing softprune structure
437 for (scan
= *basep
; scan
; scan
= scan
->next
) {
438 if (bcmp(&fs
.f_fsid
, &scan
->fs
.f_fsid
, sizeof(fs
.f_fsid
)) != 0)
440 if (strcmp(fs
.f_mntonname
, scan
->fs
.f_mntonname
) != 0)
446 * Create a new softprune structure if necessasry
449 scan
= malloc(sizeof(*scan
));
450 bzero(scan
, sizeof(*scan
));
453 scan
->filesystem
= fspath
;
454 scan
->prune
= *template;
456 scan
->prune
.elms
= malloc(sizeof(struct hammer_ioc_prune_elm
) *
463 hammer_softprune_addelm(scan
,
464 (hammer_tid_t
)strtoull(tidptr
+ 2, NULL
, 0),
465 (st
? st
->st_ctime
: 0),
466 (st
? st
->st_mtime
: 0));
471 * Add the entry (unsorted). Just set the beg_tid, we will sort
472 * and set the remaining entries later.
474 * Always leave one entry free for our terminator.
478 hammer_softprune_addelm(struct softprune
*scan
, hammer_tid_t tid
,
479 time_t ct
, time_t mt
)
481 struct hammer_ioc_prune_elm
*elm
;
483 if (scan
->prune
.nelms
>= scan
->maxelms
- 1) {
484 scan
->maxelms
= (scan
->maxelms
* 3 / 2);
485 scan
->prune
.elms
= realloc(scan
->prune
.elms
,
486 sizeof(*elm
) * scan
->maxelms
);
490 * NOTE: Temporarily store the snapshot timestamp in mod_tid.
491 * This will be cleaned up in the finalization phase.
493 elm
= &scan
->prune
.elms
[scan
->prune
.nelms
];
505 * Finalize a softprune structure after scanning in its softlinks.
506 * Sort the elements, remove duplicates, and then fill in end_tid and
509 * The array must end up in descending order.
513 hammer_softprune_qsort_cmp(const void *arg1
, const void *arg2
)
515 const struct hammer_ioc_prune_elm
*elm1
= arg1
;
516 const struct hammer_ioc_prune_elm
*elm2
= arg2
;
518 if (elm1
->beg_tid
< elm2
->beg_tid
)
520 if (elm1
->beg_tid
> elm2
->beg_tid
)
527 hammer_softprune_finalize(struct softprune
*scan
)
529 struct hammer_ioc_prune_elm
*elm
;
535 * Don't do anything if there are no elements.
537 if (scan
->prune
.nelms
== 0)
541 * Sort the elements in descending order, remove duplicates, and
542 * fill in any missing bits.
544 qsort(scan
->prune
.elms
, scan
->prune
.nelms
, sizeof(*elm
),
545 hammer_softprune_qsort_cmp
);
547 for (i
= 0; i
< scan
->prune
.nelms
; ++i
) {
548 elm
= &scan
->prune
.elms
[i
];
551 * First (highest TID) (also last if only one element)
553 elm
->end_tid
= HAMMER_MAX_TID
;
554 } else if (elm
[0].beg_tid
== elm
[-1].beg_tid
) {
559 if (i
!= scan
->prune
.nelms
) {
561 (scan
->prune
.nelms
- i
) * sizeof(*elm
));
569 elm
->end_tid
= elm
[-1].beg_tid
;
574 * If a minimum retention time (in seconds) is configured for the
575 * PFS, remove any snapshots from the pruning list that are within
578 if (scan
->prune_min
) {
580 for (i
= scan
->prune
.nelms
- 1; i
>= 0; --i
) {
581 elm
= &scan
->prune
.elms
[i
];
582 if (elm
->mod_tid
== 0)
584 delta
= (long)(t
- (time_t)elm
->mod_tid
);
585 if (delta
< scan
->prune_min
)
590 printf("Prune %s: prune_min: Will not clean between "
591 "the teeth of the first %d snapshots\n",
592 scan
->filesystem
, i
);
593 bcopy(&scan
->prune
.elms
[i
], &scan
->prune
.elms
[0],
594 (scan
->prune
.nelms
- i
) * sizeof(scan
->prune
.elms
[0]));
595 scan
->prune
.elms
[0].end_tid
= HAMMER_MAX_TID
;
596 scan
->prune
.nelms
-= i
;
601 * Remove the first entry. This entry represents the prune from
602 * the most recent snapshot to current. We wish to retain the
603 * fine-grained history for this region.
605 if (scan
->prune
.nelms
) {
606 bcopy(&scan
->prune
.elms
[1], &scan
->prune
.elms
[0],
607 (scan
->prune
.nelms
- 1) * sizeof(scan
->prune
.elms
[0]));
612 * Add a final element to prune everything from transaction id
613 * 0 to the lowest transaction id (aka last so far).
615 if (scan
->prune
.nelms
) {
616 assert(scan
->prune
.nelms
< scan
->maxelms
);
617 elm
= &scan
->prune
.elms
[scan
->prune
.nelms
];
619 elm
->end_tid
= elm
[-1].beg_tid
;
624 * Adjust mod_tid to what the ioctl() expects.
626 for (i
= 0; i
< scan
->prune
.nelms
; ++i
) {
627 elm
= &scan
->prune
.elms
[i
];
628 elm
->mod_tid
= elm
->end_tid
- elm
->beg_tid
;
629 printf("TID %016jx - %016jx\n",
630 (uintmax_t)elm
->beg_tid
, (uintmax_t)elm
->end_tid
);
636 softprune_usage(int code
)
638 fprintf(stderr
, "Badly formed prune command, use:\n");
639 fprintf(stderr
, "hammer prune <softlink-dir>\n");
640 fprintf(stderr
, "hammer prune-everything <filesystem>\n");