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