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