HAMMER Utilities: Feature add
[dragonfly.git] / sbin / hammer / cmd_prune.c
1 /*
2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
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
16  *    distribution.
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.
20  * 
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
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sbin/hammer/Attic/cmd_prune.c,v 1.6 2008/05/05 20:34:52 dillon Exp $
35  */
36
37 #include "hammer.h"
38
39 static void hammer_prune_load_file(hammer_tid_t now_tid, 
40                         struct hammer_ioc_prune *prune,
41                         const char *filesystem, const char *filename);
42 static int hammer_prune_parse_line(hammer_tid_t now_tid,
43                         struct hammer_ioc_prune *prune,
44                         const char *filesystem, char **av, int ac);
45 static void hammer_prune_create_links(const char *filesystem,
46                         struct hammer_ioc_prune *prune);
47 static void hammer_prune_make_softlink(const char *filesystem,
48                         hammer_tid_t tid);
49 static int parse_modulo_time(const char *str, u_int64_t *delta);
50 static char *tid_to_stamp_str(hammer_tid_t tid);
51 static void prune_usage(int code);
52
53 /*
54  * prune <filesystem> from <modulo_time> to <modulo_time> every <modulo_time>
55  * prune <filesystem> [using <filename>]
56  */
57 void
58 hammer_cmd_prune(char **av, int ac)
59 {
60         struct hammer_ioc_prune prune;
61         const char *filesystem;
62         int fd;
63         hammer_tid_t now_tid = (hammer_tid_t)time(NULL) * 1000000000LL;
64
65         bzero(&prune, sizeof(prune));
66         prune.nelms = 0;
67         prune.beg_obj_id = HAMMER_MIN_OBJID;
68         prune.end_obj_id = HAMMER_MAX_OBJID;
69         prune.cur_obj_id = prune.end_obj_id;    /* remove me */
70         prune.cur_key = HAMMER_MAX_KEY;         /* remove me */
71         prune.stat_oldest_tid = HAMMER_MAX_TID;
72
73         if (ac == 0)
74                 prune_usage(1);
75         filesystem = av[0];
76         if (ac == 1) {
77                 hammer_prune_load_file(now_tid, &prune, filesystem, 
78                                       "/etc/hammer.conf");
79         } else if (strcmp(av[1], "using") == 0) {
80                 if (ac == 2)
81                         prune_usage(1);
82                 hammer_prune_load_file(now_tid, &prune, filesystem, av[2]);
83         } else if (strcmp(av[1], "everything") == 0) {
84                 prune.head.flags |= HAMMER_IOC_PRUNE_ALL;
85                 if (ac > 2)
86                         prune_usage(1);
87         } else {
88                 if (hammer_prune_parse_line(now_tid, &prune, filesystem,
89                                             av, ac) < 0) {
90                         prune_usage(1);
91                 }
92         }
93         fd = open(filesystem, O_RDONLY);
94         if (fd < 0)
95                 err(1, "Unable to open %s", filesystem);
96         if (ioctl(fd, HAMMERIOC_PRUNE, &prune) < 0) {
97                 printf("Prune %s failed: %s\n",
98                        filesystem, strerror(errno));
99         } else if (prune.head.flags & HAMMER_IOC_HEAD_INTR) {
100                 printf("Prune %s interrupted by timer at %016llx\n",
101                        filesystem, prune.cur_obj_id);
102         } else {
103                 printf("Prune %s succeeded\n", filesystem);
104         }
105         close(fd);
106         if (LinkPath)
107                 hammer_prune_create_links(filesystem, &prune);
108         printf("Pruned %lld records (%lld directory entries) and %lld bytes\n",
109                 prune.stat_rawrecords,
110                 prune.stat_dirrecords,
111                 prune.stat_bytes
112         );
113 }
114
115 static void
116 hammer_prune_load_file(hammer_tid_t now_tid, struct hammer_ioc_prune *prune,
117                        const char *filesystem, const char *filename)
118 {
119         char buf[256];
120         FILE *fp;
121         char *av[16];
122         int ac;
123         int lineno;
124
125         if ((fp = fopen(filename, "r")) == NULL)
126                 err(1, "Unable to read %s", filename);
127         lineno = 0;
128         while (fgets(buf, sizeof(buf), fp) != NULL) {
129                 ++lineno;
130                 if (strncmp(buf, "prune", 5) != 0)
131                         continue;
132                 ac = 0;
133                 av[ac] = strtok(buf, " \t\r\n");
134                 while (av[ac] != NULL) {
135                         ++ac;
136                         if (ac == 16) {
137                                 fclose(fp);
138                                 errx(1, "Malformed prune directive in %s "
139                                      "line %d\n", filename, lineno);
140                         }
141                         av[ac] = strtok(NULL, " \t\r\n");
142                 }
143                 if (ac == 0)
144                         continue;
145                 if (strcmp(av[0], "prune") != 0)
146                         continue;
147                 if (hammer_prune_parse_line(now_tid, prune, filesystem,
148                                             av + 1, ac - 1) < 0) {
149                         errx(1, "Malformed prune directive in %s line %d\n",
150                              filename, lineno);
151                 }
152         }
153         fclose(fp);
154 }
155
156 static __inline
157 const char *
158 plural(int notplural)
159 {
160         return(notplural ? "" : "s");
161 }
162
163 /*
164  * Parse the following parameters:
165  *
166  * <filesystem> from <modulo_time> to <modulo_time> every <modulo_time>
167  */
168 static int
169 hammer_prune_parse_line(hammer_tid_t now_tid, struct hammer_ioc_prune *prune,
170                         const char *filesystem, char **av, int ac)
171 {
172         struct hammer_ioc_prune_elm *elm;
173         u_int64_t from_time;
174         u_int64_t to_time;
175         u_int64_t every_time;
176         char *from_stamp_str;
177         char *to_stamp_str;
178
179         if (ac != 7)
180                 return(-1);
181         if (strcmp(av[0], filesystem) != 0)
182                 return(0);
183         if (strcmp(av[1], "from") != 0)
184                 return(-1);
185         if (strcmp(av[3], "to") != 0)
186                 return(-1);
187         if (strcmp(av[5], "every") != 0)
188                 return(-1);
189         if (parse_modulo_time(av[2], &from_time) < 0)
190                 return(-1);
191         if (parse_modulo_time(av[4], &to_time) < 0)
192                 return(-1);
193         if (parse_modulo_time(av[6], &every_time) < 0)
194                 return(-1);
195         if (from_time > to_time)
196                 return(-1);
197         if (from_time == 0 || to_time == 0) {
198                 fprintf(stderr, "Bad from or to time specification.\n");
199                 return(-1);
200         }
201         if (to_time % from_time != 0) {
202                 fprintf(stderr, "Bad TO time specification.\n"
203                         "It must be an integral multiple of FROM time\n");
204                 return(-1);
205         }
206         if (every_time == 0 ||
207             from_time % every_time != 0 ||
208             to_time % every_time != 0) {
209                 fprintf(stderr, "Bad 'every <modulo_time>' specification.\n"
210                         "It must be an integral subdivision of FROM and TO\n");
211                 return(-1);
212         }
213         if (prune->nelms == HAMMER_MAX_PRUNE_ELMS) {
214                 fprintf(stderr, "Too many prune specifications in file! "
215                         "Max is %d\n", HAMMER_MAX_PRUNE_ELMS);
216                 return(-1);
217         }
218
219         /*
220          * Example:  from 1m to 60m every 5m
221          */
222         elm = &prune->elms[prune->nelms++];
223         elm->beg_tid = now_tid - now_tid % to_time;
224         if (now_tid - elm->beg_tid < to_time)
225                 elm->beg_tid -= to_time;
226
227         elm->end_tid = now_tid - now_tid % from_time;
228         if (now_tid - elm->end_tid < from_time)
229                 elm->end_tid -= from_time;
230
231         elm->mod_tid = every_time;
232         assert(elm->beg_tid < elm->end_tid);
233
234         /*
235          * Convert back to local time for pretty printing
236          */
237         from_stamp_str = tid_to_stamp_str(elm->beg_tid);
238         to_stamp_str = tid_to_stamp_str(elm->end_tid);
239         printf("Prune %s to %s every ", from_stamp_str, to_stamp_str);
240
241         every_time /= 1000000000;
242         if (every_time < 60)
243                 printf("%lld second%s\n", every_time, plural(every_time == 1));
244         every_time /= 60;
245         if (every_time && every_time < 60)
246                 printf("%lld minute%s\n", every_time, plural(every_time == 1));
247         every_time /= 60;
248         if (every_time && every_time < 24)
249                 printf("%lld hour%s\n", every_time, plural(every_time == 1));
250         every_time /= 24;
251         if (every_time)
252                 printf("%lld day%s\n", every_time, plural(every_time == 1));
253
254         free(from_stamp_str);
255         free(to_stamp_str);
256         return(0);
257 }
258
259 /*
260  * Create softlinks in the form $linkpath/snap_ddmmmyyyy[_hhmmss]
261  */
262 static void
263 hammer_prune_create_links(const char *filesystem,
264                           struct hammer_ioc_prune *prune)
265 {
266         struct hammer_ioc_prune_elm *elm;
267         hammer_tid_t tid;
268         struct dirent *den;
269         char *path;
270         DIR *dir;
271
272         if ((dir = opendir(LinkPath)) == NULL) {
273                 fprintf(stderr, "Unable to access linkpath %s\n", LinkPath);
274                 return;
275         }
276         while ((den = readdir(dir)) != NULL) {
277                 if (strncmp(den->d_name, "snap-", 5) == 0) {
278                         asprintf(&path, "%s/%s", LinkPath, den->d_name);
279                         remove(path);
280                         free(path);
281                 }
282         }
283         closedir(dir);
284
285         for (elm = &prune->elms[0]; elm < &prune->elms[prune->nelms]; ++elm) {
286                 for (tid = elm->beg_tid;
287                      tid < elm->end_tid;
288                      tid += elm->mod_tid) {
289                         if (tid < prune->stat_oldest_tid)
290                                 continue;
291                         hammer_prune_make_softlink(filesystem, tid);
292                 }
293         }
294 }
295
296 static void
297 hammer_prune_make_softlink(const char *filesystem, hammer_tid_t tid)
298 {
299         struct tm *tp;
300         char *path;
301         char *target;
302         char buf[64];
303         time_t t;
304
305         t = (time_t)(tid / 1000000000);
306         tp = localtime(&t);
307
308         /*
309          * Construct the contents of the softlink.
310          */
311         asprintf(&target, "%s/@@0x%016llx", filesystem, tid);
312
313         /*
314          * Construct the name of the snap-shot softlink
315          */
316         if (tid % (1000000000ULL * 60 * 60 * 24) == 0) {
317                 strftime(buf, sizeof(buf), "snap-%d%b%Y", tp);
318         } else if (tid % (1000000000ULL * 60 * 60) == 0) {
319                 strftime(buf, sizeof(buf), "snap-%d%b%Y_%H%M", tp);
320         } else if (tid % (1000000000ULL * 60) == 0) {
321                 strftime(buf, sizeof(buf), "snap-%d%b%Y_%H%M", tp);
322         } else {
323                 strftime(buf, sizeof(buf), "snap-%d%b%Y_%H%M%S", tp);
324         }
325
326         asprintf(&path, "%s/%s", LinkPath, buf);
327         symlink(target, path);
328         free(path);
329         free(target);
330 }
331
332 static
333 int
334 parse_modulo_time(const char *str, u_int64_t *delta)
335 {
336         char *term;
337
338         *delta = strtoull(str, &term, 10);
339
340         switch(*term) {
341         case 'y':
342                 *delta *= 12;
343                 /* fall through */
344         case 'M':
345                 *delta *= 30;
346                 /* fall through */
347         case 'd':
348                 *delta *= 24;
349                 /* fall through */
350         case 'h':
351                 *delta *= 60;
352                 /* fall through */
353         case 'm':
354                 *delta *= 60;
355                 /* fall through */
356         case 's':
357                 break;
358         default:
359                 return(-1);
360         }
361         *delta *= 1000000000LL; /* TID's are in nanoseconds */
362         return(0);
363 }
364
365 static char *
366 tid_to_stamp_str(hammer_tid_t tid)
367 {
368         struct tm *tp;
369         char *buf = malloc(256);
370         time_t t;
371
372         t = (time_t)(tid / 1000000000);
373         tp = localtime(&t);
374         strftime(buf, 256, "%e-%b-%Y %H:%M:%S %Z", tp);
375         return(buf);
376 }
377
378 static void
379 prune_usage(int code)
380 {
381         fprintf(stderr, "Bad prune directive, specify one of:\n"
382                         "prune filesystem [using filename]\n"
383                         "prune filesystem from <modulo_time> to <modulo_time> every <modulo_time>\n"
384                         "prune filesystem everything\n");
385         exit(code);
386 }