21ea025de195188b945dff84c4530f853f29a7e1
[dragonfly.git] / sbin / hammer / cmd_cleanup.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/cmd_cleanup.c,v 1.1 2008/09/20 04:23:21 dillon Exp $
35  */
36 /*
37  * Clean up a specific HAMMER filesystem or all HAMMER filesystems.
38  *
39  * Each filesystem is expected to have a <mount>/snapshots directory.
40  * No cleanup will be performed on any filesystem that does not.  If
41  * no filesystems are specified the 'df' program is run and any HAMMER
42  * or null-mounted hammer PFS's are extracted.
43  *
44  * The snapshots directory may contain a config file called 'config'.  If
45  * no config file is present one will be created with the following
46  * defaults:
47  *
48  *      snapshots 1d 60d        (0d 60d for /tmp, /var/tmp, /usr/obj)
49  *      prune     1d 5m
50  *      reblock   1d 5m
51  *      recopy    30d 5m
52  *
53  * All hammer commands create and maintain cycle files in the snapshots
54  * directory.
55  */
56
57 #include "hammer.h"
58
59 static void do_cleanup(const char *path);
60 static int strtosecs(char *ptr);
61 static const char *dividing_slash(const char *path);
62 static int check_period(const char *snapshots_path, const char *cmd, int arg1,
63                         time_t *savep);
64 static void save_period(const char *snapshots_path, const char *cmd,
65                         time_t savet);
66
67 static int cleanup_snapshots(const char *path, const char *snapshots_path,
68                               int arg1, int arg2);
69 static int cleanup_prune(const char *path, const char *snapshots_path,
70                               int arg1, int arg2);
71 static int cleanup_reblock(const char *path, const char *snapshots_path,
72                               int arg1, int arg2);
73 static int cleanup_recopy(const char *path, const char *snapshots_path,
74                               int arg1, int arg2);
75
76 static void runcmd(int *resp, const char *ctl, ...);
77
78 #define WS      " \t\r\n"
79 #define MAXPFS  65536
80 #define DIDBITS (sizeof(int) * 8)
81
82 static int DidPFS[MAXPFS/DIDBITS];
83
84 void
85 hammer_cmd_cleanup(char **av, int ac)
86 {
87         FILE *fp;
88         char *ptr;
89         char *path;
90         char buf[256];
91
92         tzset();
93         if (ac == 0) {
94                 fp = popen("df -t hammer,null", "r");
95                 if (fp == NULL)
96                         errx(1, "hammer cleanup: 'df' failed");
97                 while (fgets(buf, sizeof(buf), fp) != NULL) {
98                         ptr = strtok(buf, WS);
99                         if (ptr && strcmp(ptr, "Filesystem") == 0)
100                                 continue;
101                         if (ptr)
102                                 ptr = strtok(NULL, WS);
103                         if (ptr)
104                                 ptr = strtok(NULL, WS);
105                         if (ptr)
106                                 ptr = strtok(NULL, WS);
107                         if (ptr)
108                                 ptr = strtok(NULL, WS);
109                         if (ptr) {
110                                 path = strtok(NULL, WS);
111                                 if (path)
112                                         do_cleanup(path);
113                         }
114                 }
115                 fclose(fp);
116         } else {
117                 while (ac) {
118                         do_cleanup(*av);
119                         --ac;
120                         ++av;
121                 }
122         }
123 }
124
125 static
126 void
127 do_cleanup(const char *path)
128 {
129         struct hammer_ioc_pseudofs_rw pfs;
130         union hammer_ioc_mrecord_any mrec_tmp;
131         char *snapshots_path;
132         char *config_path;
133         struct stat st;
134         char *cmd;
135         char *ptr;
136         int arg1;
137         int arg2;
138         time_t savet;
139         char buf[256];
140         FILE *fp;
141         int fd;
142         int r;
143
144         bzero(&pfs, sizeof(pfs));
145         bzero(&mrec_tmp, sizeof(mrec_tmp));
146         pfs.ondisk = &mrec_tmp.pfs.pfsd;
147         pfs.bytes = sizeof(mrec_tmp.pfs.pfsd);
148         pfs.pfs_id = -1;
149
150         printf("cleanup %-20s -", path);
151         fd = open(path, O_RDONLY);
152         if (fd < 0) {
153                 printf(" unable to access directory: %s\n", strerror(errno));
154                 return;
155         }
156         if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) != 0) {
157                 printf(" not a HAMMER filesystem: %s\n", strerror(errno));
158                 return;
159         }
160         close(fd);
161         if (pfs.version != HAMMER_IOC_PSEUDOFS_VERSION) {
162                 printf(" unrecognized HAMMER version\n");
163                 return;
164         }
165
166         /*
167          * Make sure we have not already handled this PFS.  Several nullfs
168          * mounts might alias the same PFS.
169          */
170         if (pfs.pfs_id < 0 || pfs.pfs_id >= MAXPFS) {
171                 printf(" pfs_id %d illegal\n", pfs.pfs_id);
172                 return;
173         }
174
175         if (DidPFS[pfs.pfs_id / DIDBITS] & (1 << (pfs.pfs_id % DIDBITS))) {
176                 printf(" pfs_id %d already handled\n", pfs.pfs_id);
177                 return;
178         }
179         DidPFS[pfs.pfs_id / DIDBITS] |= (1 << (pfs.pfs_id % DIDBITS));
180
181         /*
182          * Create a snapshot directory if necessary, and a config file if
183          * necessary.
184          */
185         asprintf(&snapshots_path, "%s%ssnapshots", path, dividing_slash(path));
186         if (stat(snapshots_path, &st) < 0) {
187                 if (mkdir(snapshots_path, 0755) != 0) {
188                         free(snapshots_path);
189                         printf(" unable to create snapshot dir: %s\n",
190                                 strerror(errno));
191                         return;
192                 }
193         }
194         asprintf(&config_path, "%s/config", snapshots_path);
195         if ((fp = fopen(config_path, "r")) == NULL) {
196                 fp = fopen(config_path, "w");
197                 if (fp == NULL) {
198                         printf(" cannot create %s: %s\n",
199                                 config_path, strerror(errno));
200                         return;
201                 }
202                 if (strcmp(path, "/tmp") == 0 ||
203                     strcmp(path, "/var/tmp") == 0 ||
204                     strcmp(path, "/usr/obj") == 0) {
205                         fprintf(fp, "snapshots 0d 60d\n");
206                 } else {
207                         fprintf(fp, "snapshots 1d 60d\n");
208                 }
209                 fprintf(fp, 
210                         "prune     1d 5m\n"
211                         "reblock   1d 5m\n"
212                         "recopy    30d 10m\n");
213                 fclose(fp);
214                 fp = fopen(config_path, "r");
215         }
216         if (fp == NULL) {
217                 printf(" cannot access %s: %s\n",
218                        config_path, strerror(errno));
219                 return;
220         }
221
222         printf(" processing PFS #%d\n", pfs.pfs_id);
223
224         /*
225          * Process the config file
226          */
227         while (fgets(buf, sizeof(buf), fp) != NULL) {
228                 cmd = strtok(buf, WS);
229                 arg1 = 0;
230                 arg2 = 0;
231                 if ((ptr = strtok(NULL, WS)) != NULL) {
232                         arg1 = strtosecs(ptr);
233                         if ((ptr = strtok(NULL, WS)) != NULL)
234                                 arg2 = strtosecs(ptr);
235                 }
236
237                 printf("%20s - ", cmd);
238                 fflush(stdout);
239
240                 if (arg1 == 0) {
241                         printf("disabled\n");
242                         continue;
243                 }
244
245                 r = 1;
246                 if (strcmp(cmd, "snapshots") == 0) {
247                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
248                                 printf("run\n");
249                                 r = cleanup_snapshots(path, snapshots_path,
250                                                   arg1, arg2);
251                         } else {
252                                 printf("skip\n");
253                         }
254                 } else if (strcmp(cmd, "prune") == 0) {
255                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
256                                 r = cleanup_prune(path, snapshots_path,
257                                               arg1, arg2);
258                         } else {
259                                 printf("skip\n");
260                         }
261                 } else if (strcmp(cmd, "reblock") == 0) {
262                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
263                                 printf("run");
264                                 fflush(stdout);
265                                 if (VerboseOpt)
266                                         printf("\n");
267                                 r = cleanup_reblock(path, snapshots_path,
268                                                 arg1, arg2);
269                         } else {
270                                 printf("skip\n");
271                         }
272                 } else if (strcmp(cmd, "recopy") == 0) {
273                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
274                                 printf("run");
275                                 fflush(stdout);
276                                 if (VerboseOpt)
277                                         printf("\n");
278                                 r = cleanup_recopy(path, snapshots_path,
279                                                arg1, arg2);
280                         } else {
281                                 printf("skip\n");
282                         }
283                 } else {
284                         printf("unknown directive\n");
285                         r = 1;
286                 }
287                 if (r == 0)
288                         save_period(snapshots_path, cmd, savet);
289         }
290         fclose(fp);
291         usleep(1000);
292 }
293
294 static
295 int
296 strtosecs(char *ptr)
297 {
298         int val;
299
300         val = strtol(ptr, &ptr, 0);
301         switch(*ptr) {
302         case 'd':
303                 val *= 24;
304                 /* fall through */
305         case 'h':
306                 val *= 60;
307                 /* fall through */
308         case 'm':
309                 val *= 60;
310                 /* fall through */
311         case 's':
312                 break;
313         default:
314                 errx(1, "illegal suffix converting %s\n", ptr);
315                 break;
316         }
317         return(val);
318 }
319
320 static const char *
321 dividing_slash(const char *path)
322 {
323         int len = strlen(path);
324         if (len && path[len-1] == '/')
325                 return("");
326         else
327                 return("/");
328 }
329
330 /*
331  * Check whether the desired period has elapsed since the last successful
332  * run.  The run may take a while and cross a boundary so we remember the
333  * current time_t so we can save it later on.
334  *
335  * Periods in minutes, hours, or days are assumed to have been crossed
336  * if the local time crosses a minute, hour, or day boundary regardless
337  * of how close the last operation actually was.
338  */
339 static int
340 check_period(const char *snapshots_path, const char *cmd, int arg1,
341         time_t *savep)
342 {
343         char *check_path;
344         struct tm tp1;
345         struct tm tp2;
346         FILE *fp;
347         time_t baset, lastt;
348         char buf[256];
349
350         time(savep);
351         localtime_r(savep, &tp1);
352
353         /*
354          * Retrieve the start time of the last successful operation.
355          */
356         asprintf(&check_path, "%s/.%s.period", snapshots_path, cmd);
357         fp = fopen(check_path, "r");
358         free(check_path);
359         if (fp == NULL)
360                 return(1);
361         if (fgets(buf, sizeof(buf), fp) == NULL) {
362                 fclose(fp);
363                 return(1);
364         }
365         fclose(fp);
366
367         lastt = strtol(buf, NULL, 0);
368         localtime_r(&lastt, &tp2);
369
370         /*
371          * Normalize the times.  e.g. if asked to do something on a 1-day
372          * interval the operation will be performed as soon as the day
373          * turns over relative to the previous operation, even if the previous
374          * operation ran a few seconds ago just before midnight.
375          */
376         if (arg1 % 60 == 0) {
377                 tp1.tm_sec = 0;
378                 tp2.tm_sec = 0;
379         }
380         if (arg1 % (60 * 60) == 0) {
381                 tp1.tm_min = 0;
382                 tp2.tm_min = 0;
383         }
384         if (arg1 % (24 * 60 * 60) == 0) {
385                 tp1.tm_hour = 0;
386                 tp2.tm_hour = 0;
387         }
388
389         baset = mktime(&tp1);
390         lastt = mktime(&tp2);
391
392 #if 0
393         printf("%lld vs %lld\n", (long long)(baset - lastt), (long long)arg1);
394 #endif
395
396         if ((int)(baset - lastt) >= arg1)
397                 return(1);
398         return(0);
399 }
400
401 /*
402  * Store the start time of the last successful operation.
403  */
404 static void
405 save_period(const char *snapshots_path, const char *cmd,
406                         time_t savet)
407 {
408         char *ocheck_path;
409         char *ncheck_path;
410         FILE *fp;
411
412         asprintf(&ocheck_path, "%s/.%s.period", snapshots_path, cmd);
413         asprintf(&ncheck_path, "%s/.%s.period.new", snapshots_path, cmd);
414         fp = fopen(ncheck_path, "w");
415         fprintf(fp, "0x%08llx\n", (long long)savet);
416         if (fclose(fp) == 0)
417                 rename(ncheck_path, ocheck_path);
418         remove(ncheck_path);
419 }
420
421 /*
422  * Issue a snapshot.
423  */
424 static int
425 cleanup_snapshots(const char *path __unused, const char *snapshots_path,
426                   int arg1 __unused, int arg2 __unused)
427 {
428         int r;
429
430         runcmd(&r, "hammer snapshot %s", snapshots_path);
431         return(r);
432 }
433
434 static int
435 cleanup_prune(const char *path __unused, const char *snapshots_path,
436                   int arg1 __unused, int arg2)
437 {
438         if (arg2) {
439                 runcmd(NULL, "hammer -c %s/.prune.cycle -t %d prune %s",
440                         snapshots_path, arg2, snapshots_path);
441         } else {
442                 runcmd(NULL, "hammer prune %s", snapshots_path);
443         }
444         return(0);
445 }
446
447 static int
448 cleanup_reblock(const char *path, const char *snapshots_path,
449                   int arg1 __unused, int arg2)
450 {
451         if (VerboseOpt == 0) {
452                 printf(".");
453                 fflush(stdout);
454         }
455         runcmd(NULL,
456                "hammer -c %s/.reblock-1.cycle -t %d reblock-btree %s 95",
457                snapshots_path, arg2, path);
458         if (VerboseOpt == 0) {
459                 printf(".");
460                 fflush(stdout);
461         }
462         runcmd(NULL,
463                "hammer -c %s/.reblock-2.cycle -t %d reblock-inodes %s 95",
464                snapshots_path, arg2, path);
465         if (VerboseOpt == 0) {
466                 printf(".");
467                 fflush(stdout);
468         }
469         runcmd(NULL,
470                "hammer -c %s/.reblock-3.cycle -t %d reblock-data %s 95",
471                snapshots_path, arg2, path);
472         if (VerboseOpt == 0)
473                 printf("\n");
474         return(0);
475 }
476
477 static int
478 cleanup_recopy(const char *path, const char *snapshots_path,
479                   int arg1 __unused, int arg2)
480 {
481         if (VerboseOpt == 0) {
482                 printf(".");
483                 fflush(stdout);
484         }
485         runcmd(NULL,
486                "hammer -c %s/.recopy-1.cycle -t %d reblock-btree %s",
487                snapshots_path, arg2, path);
488         if (VerboseOpt == 0) {
489                 printf(".");
490                 fflush(stdout);
491         }
492         runcmd(NULL,
493                "hammer -c %s/.recopy-2.cycle -t %d reblock-inodes %s",
494                snapshots_path, arg2, path);
495         if (VerboseOpt == 0) {
496                 printf(".");
497                 fflush(stdout);
498         }
499         runcmd(NULL,
500                "hammer -c %s/.recopy-3.cycle -t %d reblock-data %s",
501                snapshots_path, arg2, path);
502         if (VerboseOpt == 0)
503                 printf("\n");
504         return(0);
505 }
506
507 static
508 void
509 runcmd(int *resp, const char *ctl, ...)
510 {
511         va_list va;
512         char *cmd;
513         char *arg;
514         char **av;
515         int n;
516         int nmax;
517         int res;
518         pid_t pid;
519
520         /*
521          * Generate the command
522          */
523         va_start(va, ctl);
524         vasprintf(&cmd, ctl, va);
525         va_end(va);
526         if (VerboseOpt)
527                 printf("    %s\n", cmd);
528
529         /*
530          * Break us down into arguments.  We do not just use system() here
531          * because it blocks SIGINT and friends.
532          */
533         n = 0;
534         nmax = 16;
535         av = malloc(sizeof(char *) * nmax);
536
537         for (arg = strtok(cmd, WS); arg; arg = strtok(NULL, WS)) {
538                 if (n == nmax) {
539                         nmax += 16;
540                         av = realloc(av, sizeof(char *) * nmax);
541                 }
542                 av[n++] = arg;
543         }
544
545         /*
546          * Run the command.
547          */
548         if ((pid = fork()) == 0) {
549                 if (VerboseOpt < 2) {
550                         int fd = open("/dev/null", O_RDWR);
551                         dup2(fd, 1);
552                         close(fd);
553                 }
554                 execvp(av[0], av);
555                 _exit(127);
556         } else if (pid < 0) {
557                 res = 127;
558         } else {
559                 int status;
560                 while (waitpid(pid, &status, 0) != pid)
561                         ;
562                 res = WEXITSTATUS(status);
563         }
564
565         free(cmd);
566         free(av);
567         if (resp)
568                 *resp = res;
569 }
570
571