sbin/hammer/cmd_softprune.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_softprune.c,v 1.7 2008/08/21 23:28:43 thomas Exp $
  35  */
  36
  37 #include "hammer.h"
  38
  39 static void softprune_usage(int code);
  40 static int hammer_softprune_scanmeta(int fd, struct softprune *scan,
  41                         int delete_all);
  42 static void hammer_meta_flushdelete(int fd, struct hammer_ioc_snapshot *dsnap);
  43 static struct softprune *hammer_softprune_addentry(struct softprune **basep,
  44                         struct hammer_ioc_prune *template,
  45                         const char *dirpath, const char *denname,
  46                         struct stat *st,
  47                         const char *linkbuf, const char *tidptr);
  48 static void hammer_softprune_addelm(struct softprune *scan, hammer_tid_t tid,
  49                         time_t ct, time_t mt);
  50 static void hammer_softprune_finalize(struct softprune *scan);
  51
  52 /*
  53  * prune <softlink-dir>
  54  * prune-everything <filesystem>
  55  */
  56 void
  57 hammer_cmd_softprune(char **av, int ac, int everything_opt)
  58 {
  59         struct hammer_ioc_prune template;
  60         struct hammer_ioc_pseudofs_rw pfs;
  61         struct softprune *base, *scan;
  62         int fd;
  63         int rcode;
  64
  65         base = NULL;
  66         rcode = 0;
  67         if (TimeoutOpt > 0)
  68                 alarm(TimeoutOpt);
  69
  70         bzero(&pfs, sizeof(pfs));
  71         pfs.bytes = sizeof(*pfs.ondisk);
  72         pfs.ondisk = malloc(pfs.bytes);
  73         bzero(pfs.ondisk, pfs.bytes);
  74         pfs.pfs_id = -1;
  75
  76         /*
  77          * NOTE: To restrict to a single file XXX we have to set
  78          * the localization the same (not yet implemented).  Typically
  79          * two passes would be needed, one using HAMMER_LOCALIZE_MISC
  80          * and one using HAMMER_LOCALIZE_INODE.
  81          */
  82
  83         bzero(&template, sizeof(template));
  84         template.key_beg.localization = HAMMER_MIN_LOCALIZATION;
  85         template.key_beg.obj_id = HAMMER_MIN_OBJID;
  86         template.key_end.localization = HAMMER_MAX_LOCALIZATION;
  87         template.key_end.obj_id = HAMMER_MAX_OBJID;
  88         hammer_get_cycle(&template.key_end, NULL);
  89         template.stat_oldest_tid = HAMMER_MAX_TID;
  90
  91         /*
  92          * For now just allow one directory
  93          */
  94         if (ac == 0 || ac > 1)
  95                 softprune_usage(1);
  96
  97         /*
  98          * Scan the softlink directory.
  99          */
 100         if (everything_opt) {
 101                 const char *dummylink = "";
 102                 scan = hammer_softprune_addentry(&base, &template,
 103                                                  *av, NULL, NULL,
 104                                                  dummylink, dummylink);
 105                 if (scan == NULL)
 106                         softprune_usage(1);
 107                 scan->prune.nelms = 0;
 108                 scan->prune.head.flags |= HAMMER_IOC_PRUNE_ALL;
 109         } else {
 110                 hammer_softprune_scandir(&base, &template, *av);
 111                 if (base == NULL) {
 112                         const char *dummylink = "";
 113                         scan = hammer_softprune_addentry(&base, &template,
 114                                                          *av, NULL, NULL,
 115                                                          dummylink, dummylink);
 116                         if (scan == NULL)
 117                                 softprune_usage(1);
 118                         scan->prune.nelms = 0;
 119                 }
 120                 ++av;
 121                 --ac;
 122         }
 123
 124         /*
 125          * XXX future (need to store separate cycles for each filesystem)
 126          */
 127         if (base->next) {
 128                 fprintf(stderr, "Currently only one HAMMER filesystem may "
 129                                 "be specified in the softlink scan\n");
 130                 exit(1);
 131         }
 132
 133         /*
 134          * Issue the prunes
 135          */
 136         for (scan = base; scan; scan = scan->next) {
 137                 /*
 138                  * Open the filesystem for ioctl calls and extract the
 139                  * PFS.
 140                  */
 141                 fd = open(scan->filesystem, O_RDONLY);
 142                 if (fd < 0) {
 143                         warn("Unable to open %s", scan->filesystem);
 144                         rcode = 1;
 145                         continue;
 146                 }
 147
 148                 if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) < 0) {
 149                         warn("Filesystem %s is not HAMMER", scan->filesystem);
 150                         rcode = 1;
 151                         close(fd);
 152                         continue;
 153                 }
 154                 scan->prune_min = pfs.ondisk->prune_min;
 155
 156                 /*
 157                  * Incorporate meta-data snapshots into the pruning regimen.
 158                  * If pruning everything we delete the meta-data snapshots.
 159                  */
 160                 if (hammer_softprune_scanmeta(fd, scan, everything_opt) < 0) {
 161                         warn("Filesystem %s could not scan meta-data snaps",
 162                              scan->filesystem);
 163                         rcode = 1;
 164                         close(fd);
 165                         continue;
 166                 }
 167
 168                 /*
 169                  * Finalize operations
 170                  */
 171                 hammer_softprune_finalize(scan);
 172                 if (everything_opt) {
 173                         printf("Prune %s: EVERYTHING\n",
 174                                scan->filesystem);
 175                 } else {
 176                         printf("Prune %s: %d snapshots\n",
 177                                scan->filesystem, scan->prune.nelms);
 178                 }
 179                 if (scan->prune.nelms == 0 &&
 180                     (scan->prune.head.flags & HAMMER_IOC_PRUNE_ALL) == 0) {
 181                         fprintf(stderr, "No snapshots found\n");
 182                         continue;
 183                 }
 184
 185                 printf("Prune %s: objspace %016jx:%04x %016jx:%04x "
 186                        "pfs_id %d\n",
 187                        scan->filesystem,
 188                        (uintmax_t)scan->prune.key_beg.obj_id,
 189                        scan->prune.key_beg.localization,
 190                        (uintmax_t)scan->prune.key_end.obj_id,
 191                        scan->prune.key_end.localization,
 192                        pfs.pfs_id);
 193                 printf("Prune %s: prune_min is %dd/%02d:%02d:%02d\n",
 194                        scan->filesystem,
 195                         pfs.ondisk->prune_min / (24 * 60 * 60),
 196                         pfs.ondisk->prune_min / 60 / 60 % 24,
 197                         pfs.ondisk->prune_min / 60 % 60,
 198                         pfs.ondisk->prune_min % 60);
 199
 200                 RunningIoctl = 1;
 201                 if (ioctl(fd, HAMMERIOC_PRUNE, &scan->prune) < 0) {
 202                         printf("Prune %s failed: %s\n",
 203                                scan->filesystem, strerror(errno));
 204                         rcode = 2;
 205                 } else if (scan->prune.head.flags & HAMMER_IOC_HEAD_INTR) {
 206                         printf("Prune %s interrupted by timer at "
 207                                "%016jx %04x\n",
 208                                scan->filesystem,
 209                                (uintmax_t)scan->prune.key_cur.obj_id,
 210                                scan->prune.key_cur.localization);
 211                         if (CyclePath)
 212                                 hammer_set_cycle(&scan->prune.key_cur, 0);
 213                         rcode = 0;
 214                 } else {
 215                         if (CyclePath)
 216                                 hammer_reset_cycle();
 217                         printf("Prune %s succeeded\n", scan->filesystem);
 218                 }
 219                 printf("Pruned %jd/%jd records (%jd directory entries) "
 220                        "and %jd bytes\n",
 221                         (uintmax_t)scan->prune.stat_rawrecords,
 222                         (uintmax_t)scan->prune.stat_scanrecords,
 223                         (uintmax_t)scan->prune.stat_dirrecords,
 224                         (uintmax_t)scan->prune.stat_bytes
 225                 );
 226                 RunningIoctl = 0;
 227                 close(fd);
 228         }
 229         if (rcode)
 230                 exit(rcode);
 231 }
 232
 233 /*
 234  * Scan a directory for softlinks representing snapshots and build
 235  * associated softprune structures.
 236  *
 237  * NOTE: Once a filesystem is completely converted to the meta-data
 238  *       snapshot mechanic we don't have to scan softlinks any more
 239  *       and can just use the meta-data.  But for now we do both.
 240  */
 241 void
 242 hammer_softprune_scandir(struct softprune **basep,
 243                          struct hammer_ioc_prune *template,
 244                          const char *dirname)
 245 {
 246         struct stat st;
 247         struct dirent *den;
 248         DIR *dir;
 249         char *path;
 250         int len;
 251         char *linkbuf;
 252         char *ptr;
 253
 254         path = NULL;
 255         linkbuf = malloc(MAXPATHLEN);
 256
 257         if ((dir = opendir(dirname)) == NULL)
 258                 err(1, "Cannot open directory %s", dirname);
 259         while ((den = readdir(dir)) != NULL) {
 260                 if (strcmp(den->d_name, ".") == 0)
 261                         continue;
 262                 if (strcmp(den->d_name, "..") == 0)
 263                         continue;
 264                 if (path)
 265                         free(path);
 266                 asprintf(&path, "%s/%s", dirname, den->d_name);
 267                 if (lstat(path, &st) < 0)
 268                         continue;
 269                 if (!S_ISLNK(st.st_mode))
 270                         continue;
 271                 if ((len = readlink(path, linkbuf, MAXPATHLEN - 1)) < 0)
 272                         continue;
 273                 linkbuf[len] = 0;
 274                 if ((ptr = strrchr(linkbuf, '@')) &&
 275                     ptr > linkbuf && ptr[-1] == '@') {
 276                         hammer_softprune_addentry(basep, template,
 277                                                   dirname, den->d_name, &st,
 278                                                   linkbuf, ptr - 1);
 279                 }
 280         }
 281         free(linkbuf);
 282         if (path)
 283                 free(path);
 284 }
 285
 286 /*
 287  * Scan the metadata snapshots for the filesystem and either delete them
 288  * or add them to the pruning list.
 289  */
 290 static
 291 int
 292 hammer_softprune_scanmeta(int fd, struct softprune *scan, int delete_all)
 293 {
 294         struct hammer_ioc_version       version;
 295         struct hammer_ioc_snapshot      snapshot;
 296         struct hammer_ioc_snapshot      dsnapshot;
 297         struct hammer_snapshot_data     *snap;
 298         time_t ct;
 299
 300         /*
 301          * Stop if we can't get the version.  Meta-data snapshots only
 302          * exist for HAMMER version 3 or greater.
 303          */
 304         bzero(&version, sizeof(version));
 305         if (ioctl(fd, HAMMERIOC_GET_VERSION, &version) < 0)
 306                 return(-1);
 307         if (version.cur_version < 3)
 308                 return(0);
 309
 310         bzero(&snapshot, sizeof(snapshot));
 311         bzero(&dsnapshot, sizeof(dsnapshot));
 312
 313         /*
 314          * Scan meta-data snapshots, either add them to the prune list or
 315          * delete them.  When deleting, just skip any entries which cannot
 316          * be deleted.
 317          */
 318         for (;;) {
 319                 if (ioctl(fd, HAMMERIOC_GET_SNAPSHOT, &snapshot) < 0) {
 320                         printf("hammer prune: Unable to access "
 321                                "meta-data snaps: %s\n", strerror(errno));
 322                         return(-1);
 323                 }
 324                 while (snapshot.index < snapshot.count) {
 325                         snap = &snapshot.snaps[snapshot.index];
 326                         if (delete_all) {
 327                                 dsnapshot.snaps[dsnapshot.count++] = *snap;
 328                                 if (dsnapshot.count == HAMMER_SNAPS_PER_IOCTL)
 329                                         hammer_meta_flushdelete(fd, &dsnapshot);
 330                         } else {
 331                                 ct = snap->ts / 1000000ULL;
 332                                 hammer_softprune_addelm(scan, snap->tid,
 333                                                         ct, ct);
 334                         }
 335                         ++snapshot.index;
 336                 }
 337                 if (snapshot.head.flags & HAMMER_IOC_SNAPSHOT_EOF)
 338                         break;
 339                 snapshot.index = 0;
 340         }
 341         if (delete_all)
 342                 hammer_meta_flushdelete(fd, &dsnapshot);
 343         return(0);
 344 }
 345
 346 /*
 347  * Flush any entries built up in the deletion snapshot ioctl structure.
 348  * Used during a prune-everything.
 349  */
 350 static void
 351 hammer_meta_flushdelete(int fd, struct hammer_ioc_snapshot *dsnap)
 352 {
 353         while (dsnap->index < dsnap->count) {
 354                 if (ioctl(fd, HAMMERIOC_DEL_SNAPSHOT, dsnap) < 0)
 355                         break;
 356                 if (dsnap->head.error == 0)
 357                         break;
 358                 ++dsnap->index;
 359         }
 360         dsnap->index = 0;
 361         dsnap->count = 0;
 362 }
 363
 364 /*
 365  * Add the softlink to the appropriate softprune structure, creating a new
 366  * one if necessary.
 367  */
 368 static
 369 struct softprune *
 370 hammer_softprune_addentry(struct softprune **basep,
 371                          struct hammer_ioc_prune *template,
 372                          const char *dirpath, const char *denname __unused,
 373                          struct stat *st,
 374                          const char *linkbuf, const char *tidptr)
 375 {
 376         struct softprune *scan;
 377         struct statfs fs;
 378         char *fspath;
 379
 380         /*
 381          * Calculate filesystem path.
 382          */
 383         if (linkbuf[0] == '/') {
 384                 asprintf(&fspath, "%*.*s",
 385                          (int)(tidptr - linkbuf), (int)(tidptr - linkbuf),
 386                          linkbuf);
 387         } else {
 388                 asprintf(&fspath, "%s/%*.*s", dirpath,
 389                          (int)(tidptr - linkbuf), (int)(tidptr - linkbuf),
 390                          linkbuf);
 391         }
 392         if (statfs(fspath, &fs) < 0) {
 393                 free(fspath);
 394                 return(NULL);
 395         }
 396
 397         /*
 398          * Locate the filesystem in an existing softprune structure
 399          */
 400         for (scan = *basep; scan; scan = scan->next) {
 401                 if (bcmp(&fs.f_fsid, &scan->fs.f_fsid, sizeof(fs.f_fsid)) != 0)
 402                         continue;
 403                 if (strcmp(fs.f_mntonname, scan->fs.f_mntonname) != 0)
 404                         continue;
 405                 break;
 406         }
 407
 408         /*
 409          * Create a new softprune structure if necessasry
 410          */
 411         if (scan == NULL) {
 412                 scan = malloc(sizeof(*scan));
 413                 bzero(scan, sizeof(*scan));
 414
 415                 scan->fs = fs;
 416                 scan->filesystem = fspath;
 417                 scan->prune = *template;
 418                 scan->maxelms = 32;
 419                 scan->prune.elms = malloc(sizeof(struct hammer_ioc_prune_elm) *
 420                                           scan->maxelms);
 421                 scan->next = *basep;
 422                 *basep = scan;
 423         } else {
 424                 free(fspath);
 425         }
 426         hammer_softprune_addelm(scan,
 427                                 (hammer_tid_t)strtoull(tidptr + 2, NULL, 0),
 428                                 (st ? st->st_ctime : 0),
 429                                 (st ? st->st_mtime : 0));
 430         return(scan);
 431 }
 432
 433 /*
 434  * Add the entry (unsorted).  Just set the beg_tid, we will sort
 435  * and set the remaining entries later.
 436  *
 437  * Always leave one entry free for our terminator.
 438  */
 439 static void
 440 hammer_softprune_addelm(struct softprune *scan, hammer_tid_t tid,
 441                         time_t ct, time_t mt)
 442 {
 443         struct hammer_ioc_prune_elm *elm;
 444
 445         if (scan->prune.nelms >= scan->maxelms - 1) {
 446                 scan->maxelms = (scan->maxelms * 3 / 2);
 447                 scan->prune.elms = realloc(scan->prune.elms,
 448                                            sizeof(*elm) * scan->maxelms);
 449         }
 450
 451         /*
 452          * NOTE: Temporarily store the snapshot timestamp in mod_tid.
 453          *       This will be cleaned up in the finalization phase.
 454          */
 455         elm = &scan->prune.elms[scan->prune.nelms];
 456         elm->beg_tid = tid;
 457         elm->end_tid = 0;
 458         elm->mod_tid = 0;
 459         if (ct < mt)
 460                 elm->mod_tid = ct;
 461         else
 462                 elm->mod_tid = mt;
 463         ++scan->prune.nelms;
 464 }
 465
 466 /*
 467  * Finalize a softprune structure after scanning in its softlinks.
 468  * Sort the elements, remove duplicates, and then fill in end_tid and
 469  * mod_tid.
 470  *
 471  * The array must end up in descending order.
 472  */
 473 static int
 474 hammer_softprune_qsort_cmp(const void *arg1, const void *arg2)
 475 {
 476         const struct hammer_ioc_prune_elm *elm1 = arg1;
 477         const struct hammer_ioc_prune_elm *elm2 = arg2;
 478
 479         if (elm1->beg_tid < elm2->beg_tid)
 480                 return(1);
 481         if (elm1->beg_tid > elm2->beg_tid)
 482                 return(-1);
 483         return(0);
 484 }
 485
 486 static void
 487 hammer_softprune_finalize(struct softprune *scan)
 488 {
 489         struct hammer_ioc_prune_elm *elm;
 490         time_t t;
 491         long delta;
 492         int i;
 493
 494         /*
 495          * Don't do anything if there are no elements.
 496          */
 497         if (scan->prune.nelms == 0)
 498                 return;
 499
 500         /*
 501          * Sort the elements in descending order, remove duplicates, and
 502          * fill in any missing bits.
 503          */
 504         qsort(scan->prune.elms, scan->prune.nelms, sizeof(*elm),
 505               hammer_softprune_qsort_cmp);
 506
 507         for (i = 0; i < scan->prune.nelms; ++i) {
 508                 elm = &scan->prune.elms[i];
 509                 if (i == 0) {
 510                         /*
 511                          * First (highest TID) (also last if only one element)
 512                          */
 513                         elm->end_tid = HAMMER_MAX_TID;
 514                 } else if (elm[0].beg_tid == elm[-1].beg_tid) {
 515                         /*
 516                          * Remove duplicate
 517                          */
 518                         --scan->prune.nelms;
 519                         if (i != scan->prune.nelms) {
 520                                 bcopy(elm + 1, elm,
 521                                       (scan->prune.nelms - i) * sizeof(*elm));
 522                         }
 523                         --i;
 524                         continue;
 525                 } else {
 526                         /*
 527                          * Middle or last.
 528                          */
 529                         elm->end_tid = elm[-1].beg_tid;
 530                 }
 531         }
 532
 533         /*
 534          * If a minimum retention time (in seconds) is configured for the
 535          * PFS, remove any snapshots from the pruning list that are within
 536          * the period.
 537          */
 538         if (scan->prune_min) {
 539                 t = time(NULL);
 540                 for (i = scan->prune.nelms - 1; i >= 0; --i) {
 541                         elm = &scan->prune.elms[i];
 542                         if (elm->mod_tid == 0)
 543                                 continue;
 544                         delta = (long)(t - (time_t)elm->mod_tid);
 545                         if (delta < scan->prune_min)
 546                                 break;
 547                 }
 548                 ++i;
 549                 if (i) {
 550                         printf("Prune %s: prune_min: Will not clean between "
 551                                "the teeth of the first %d snapshots\n",
 552                                scan->filesystem, i);
 553                         bcopy(&scan->prune.elms[i], &scan->prune.elms[0],
 554                               (scan->prune.nelms - i) * sizeof(scan->prune.elms[0]));
 555                         scan->prune.elms[0].end_tid = HAMMER_MAX_TID;
 556                         scan->prune.nelms -= i;
 557                 }
 558         }
 559
 560         /*
 561          * Remove the first entry.  This entry represents the prune from
 562          * the most recent snapshot to current.  We wish to retain the
 563          * fine-grained history for this region.
 564          */
 565         if (scan->prune.nelms) {
 566                 bcopy(&scan->prune.elms[1], &scan->prune.elms[0],
 567                       (scan->prune.nelms - 1) * sizeof(scan->prune.elms[0]));
 568                 --scan->prune.nelms;
 569         }
 570
 571         /*
 572          * Add a final element to prune everything from transaction id
 573          * 0 to the lowest transaction id (aka last so far).
 574          */
 575         if (scan->prune.nelms) {
 576                 assert(scan->prune.nelms < scan->maxelms);
 577                 elm = &scan->prune.elms[scan->prune.nelms];
 578                 elm->beg_tid = 1;
 579                 elm->end_tid = elm[-1].beg_tid;
 580                 ++scan->prune.nelms;
 581         }
 582
 583         /*
 584          * Adjust mod_tid to what the ioctl() expects.
 585          */
 586         for (i = 0; i < scan->prune.nelms; ++i) {
 587                 elm = &scan->prune.elms[i];
 588                 elm->mod_tid = elm->end_tid - elm->beg_tid;
 589                 printf("TID %016jx - %016jx\n",
 590                        (uintmax_t)elm->beg_tid, (uintmax_t)elm->end_tid);
 591         }
 592 }
 593
 594 static
 595 void
 596 softprune_usage(int code)
 597 {
 598         fprintf(stderr, "Badly formed prune command, use:\n");
 599         fprintf(stderr, "hammer prune <softlink-dir>\n");
 600         fprintf(stderr, "hammer prune-everything <filesystem>\n");
 601         exit(code);
 602 }
 603
 604