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/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 }