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.6 2008/10/07 22:28:41 thomas 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 0d 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 struct didpfs {
  60         struct didpfs *next;
  61         uuid_t          uuid;
  62 };
  63
  64 static void do_cleanup(const char *path);
  65 static int strtosecs(char *ptr);
  66 static const char *dividing_slash(const char *path);
  67 static int check_period(const char *snapshots_path, const char *cmd, int arg1,
  68                         time_t *savep);
  69 static void save_period(const char *snapshots_path, const char *cmd,
  70                         time_t savet);
  71 static int check_softlinks(const char *snapshots_path);
  72 static void cleanup_softlinks(const char *path, const char *snapshots_path,
  73                         int arg2, char *arg3);
  74 static int check_expired(const char *fpath, int arg2);
  75
  76 static int create_snapshot(const char *path, const char *snapshots_path,
  77                               int arg1, int arg2);
  78 static int cleanup_rebalance(const char *path, const char *snapshots_path,
  79                               int arg1, int arg2);
  80 static int cleanup_prune(const char *path, const char *snapshots_path,
  81                               int arg1, int arg2, int snapshots_disabled);
  82 static int cleanup_reblock(const char *path, const char *snapshots_path,
  83                               int arg1, int arg2);
  84 static int cleanup_recopy(const char *path, const char *snapshots_path,
  85                               int arg1, int arg2);
  86
  87 static void runcmd(int *resp, const char *ctl, ...);
  88
  89 #define WS      " \t\r\n"
  90
  91 struct didpfs *FirstPFS;
  92
  93 void
  94 hammer_cmd_cleanup(char **av, int ac)
  95 {
  96         char *fstype, *fs, *path;
  97         struct statfs *stfsbuf;
  98         int mntsize, i;
  99
 100         tzset();
 101         if (ac == 0) {
 102                 mntsize = getmntinfo(&stfsbuf, MNT_NOWAIT);
 103                 if (mntsize > 0) {
 104                         for (i=0; i < mntsize; i++) {
 105                                 /*
 106                                  * We will cleanup in the case fstype is hammer.
 107                                  * If we have null-mounted PFS, we check the
 108                                  * mount source. If it looks like a PFS, we
 109                                  * proceed to cleanup also.
 110                                  */
 111                                 fstype = stfsbuf[i].f_fstypename;
 112                                 fs = stfsbuf[i].f_mntfromname;
 113                                 if ((strcmp(fstype, "hammer") == 0) ||
 114                                     ((strcmp(fstype, "null") == 0) &&
 115                                      (strstr(fs, "/@@0x") != NULL ||
 116                                       strstr(fs, "/@@-1") != NULL))) {
 117                                         path = stfsbuf[i].f_mntonname;
 118                                         do_cleanup(path);
 119                                 }
 120                         }
 121                 }
 122
 123         } else {
 124                 while (ac) {
 125                         do_cleanup(*av);
 126                         --ac;
 127                         ++av;
 128                 }
 129         }
 130 }
 131
 132 static
 133 void
 134 do_cleanup(const char *path)
 135 {
 136         struct hammer_ioc_pseudofs_rw pfs;
 137         union hammer_ioc_mrecord_any mrec_tmp;
 138         char *snapshots_path;
 139         char *config_path;
 140         struct stat st;
 141         char *cmd;
 142         char *ptr;
 143         int arg1;
 144         int arg2;
 145         char *arg3;
 146         time_t savet;
 147         char buf[256];
 148         FILE *fp;
 149         struct didpfs *didpfs;
 150         int snapshots_disabled = 0;
 151         int prune_warning = 0;
 152         int fd;
 153         int r;
 154         int found_rebal = 0;
 155
 156         bzero(&pfs, sizeof(pfs));
 157         bzero(&mrec_tmp, sizeof(mrec_tmp));
 158         pfs.ondisk = &mrec_tmp.pfs.pfsd;
 159         pfs.bytes = sizeof(mrec_tmp.pfs.pfsd);
 160         pfs.pfs_id = -1;
 161
 162         printf("cleanup %-20s -", path);
 163         fd = open(path, O_RDONLY);
 164         if (fd < 0) {
 165                 printf(" unable to access directory: %s\n", strerror(errno));
 166                 return;
 167         }
 168         if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) != 0) {
 169                 printf(" not a HAMMER filesystem: %s\n", strerror(errno));
 170                 return;
 171         }
 172         close(fd);
 173         if (pfs.version != HAMMER_IOC_PSEUDOFS_VERSION) {
 174                 printf(" unrecognized HAMMER version\n");
 175                 return;
 176         }
 177
 178         /*
 179          * Make sure we have not already handled this PFS.  Several nullfs
 180          * mounts might alias the same PFS.
 181          */
 182         for (didpfs = FirstPFS; didpfs; didpfs = didpfs->next) {
 183                 if (bcmp(&didpfs->uuid, &mrec_tmp.pfs.pfsd.unique_uuid, sizeof(uuid_t)) == 0) {
 184                         printf(" PFS #%d already handled\n", pfs.pfs_id);
 185                         return;
 186                 }
 187         }
 188         didpfs = malloc(sizeof(*didpfs));
 189         didpfs->next = FirstPFS;
 190         FirstPFS = didpfs;
 191         didpfs->uuid = mrec_tmp.pfs.pfsd.unique_uuid;
 192
 193         /*
 194          * Figure out where the snapshot directory is.
 195          */
 196         if (mrec_tmp.pfs.pfsd.snapshots[0] == '/') {
 197                 asprintf(&snapshots_path, "%s", mrec_tmp.pfs.pfsd.snapshots);
 198         } else if (mrec_tmp.pfs.pfsd.snapshots[0]) {
 199                 printf(" WARNING: pfs-slave's snapshots dir is not absolute\n");
 200                 return;
 201         } else if (mrec_tmp.pfs.pfsd.mirror_flags & HAMMER_PFSD_SLAVE) {
 202                 printf(" WARNING: must configure snapshot dir for PFS slave\n");
 203                 printf("\tWe suggest <fs>/var/slaves/<name> where "
 204                        "<fs> is the base HAMMER fs\n");
 205                 printf("\tcontaining the slave\n");
 206                 return;
 207         } else {
 208                 asprintf(&snapshots_path,
 209                          "%s%ssnapshots", path, dividing_slash(path));
 210         }
 211
 212         /*
 213          * Create a snapshot directory if necessary, and a config file if
 214          * necessary.
 215          */
 216         if (stat(snapshots_path, &st) < 0) {
 217                 if (mkdir(snapshots_path, 0755) != 0) {
 218                         free(snapshots_path);
 219                         printf(" unable to create snapshot dir \"%s\": %s\n",
 220                                 snapshots_path, strerror(errno));
 221                         return;
 222                 }
 223         }
 224         asprintf(&config_path, "%s/config", snapshots_path);
 225         if ((fp = fopen(config_path, "r")) == NULL) {
 226                 fp = fopen(config_path, "w");
 227                 if (fp == NULL) {
 228                         printf(" cannot create %s: %s\n",
 229                                 config_path, strerror(errno));
 230                         return;
 231                 }
 232                 if (strcmp(path, "/tmp") == 0 ||
 233                     strcmp(path, "/var/tmp") == 0 ||
 234                     strcmp(path, "/usr/obj") == 0) {
 235                         fprintf(fp, "snapshots 0d 0d\n");
 236                 } else {
 237                         fprintf(fp, "snapshots 1d 60d\n");
 238                 }
 239                 fprintf(fp,
 240                         "prune     1d 5m\n"
 241                         "rebalance 1d 5m\n"
 242                         "reblock   1d 5m\n"
 243                         "recopy    30d 10m\n");
 244                 fclose(fp);
 245                 fp = fopen(config_path, "r");
 246         }
 247         if (fp == NULL) {
 248                 printf(" cannot access %s: %s\n",
 249                        config_path, strerror(errno));
 250                 return;
 251         }
 252
 253         if (flock(fileno(fp), LOCK_EX|LOCK_NB) == -1) {
 254                 if (errno == EWOULDBLOCK)
 255                         printf(" PFS #%d locked by other process\n", pfs.pfs_id);
 256                 else
 257                         printf(" can not lock %s: %s\n", config_path, strerror(errno));
 258                 fclose(fp);
 259                 return;
 260         }
 261
 262         printf(" handle PFS #%d using %s\n", pfs.pfs_id, snapshots_path);
 263
 264         /*
 265          * Process the config file
 266          */
 267         while (fgets(buf, sizeof(buf), fp) != NULL) {
 268                 cmd = strtok(buf, WS);
 269                 arg1 = 0;
 270                 arg2 = 0;
 271                 arg3 = NULL;
 272                 if ((ptr = strtok(NULL, WS)) != NULL) {
 273                         arg1 = strtosecs(ptr);
 274                         if ((ptr = strtok(NULL, WS)) != NULL) {
 275                                 arg2 = strtosecs(ptr);
 276                                 arg3 = strtok(NULL, WS);
 277                         }
 278                 }
 279
 280                 printf("%20s - ", cmd);
 281                 fflush(stdout);
 282
 283                 r = 1;
 284                 if (strcmp(cmd, "snapshots") == 0) {
 285                         if (arg1 == 0) {
 286                                 if (arg2 && check_softlinks(snapshots_path)) {
 287                                         printf("only removing old snapshots\n");
 288                                         prune_warning = 1;
 289                                         cleanup_softlinks(path, snapshots_path,
 290                                                           arg2, arg3);
 291                                 } else {
 292                                         printf("disabled\n");
 293                                         snapshots_disabled = 1;
 294                                 }
 295                         } else
 296                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
 297                                 printf("run\n");
 298                                 cleanup_softlinks(path, snapshots_path,
 299                                                   arg2, arg3);
 300                                 r = create_snapshot(path, snapshots_path,
 301                                                   arg1, arg2);
 302                         } else {
 303                                 printf("skip\n");
 304                         }
 305                 } else if (arg1 == 0) {
 306                         /*
 307                          * The commands following this check can't handle
 308                          * a period of 0, so call the feature disabled and
 309                          * ignore the directive.
 310                          */
 311                         printf("disabled\n");
 312                 } else if (strcmp(cmd, "prune") == 0) {
 313                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
 314                                 if (prune_warning) {
 315                                         printf("run - WARNING snapshot "
 316                                                "softlinks present "
 317                                                "but snapshots disabled\n");
 318                                 } else {
 319                                         printf("run\n");
 320                                 }
 321                                 r = cleanup_prune(path, snapshots_path,
 322                                               arg1, arg2, snapshots_disabled);
 323                         } else {
 324                                 printf("skip\n");
 325                         }
 326                 } else if (strcmp(cmd, "rebalance") == 0) {
 327                         found_rebal = 1;
 328                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
 329                                 printf("run");
 330                                 fflush(stdout);
 331                                 if (VerboseOpt)
 332                                         printf("\n");
 333                                 r = cleanup_rebalance(path, snapshots_path,
 334                                                 arg1, arg2);
 335                         } else {
 336                                 printf("skip\n");
 337                         }
 338                 } else if (strcmp(cmd, "reblock") == 0) {
 339                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
 340                                 printf("run");
 341                                 fflush(stdout);
 342                                 if (VerboseOpt)
 343                                         printf("\n");
 344                                 r = cleanup_reblock(path, snapshots_path,
 345                                                 arg1, arg2);
 346                         } else {
 347                                 printf("skip\n");
 348                         }
 349                 } else if (strcmp(cmd, "recopy") == 0) {
 350                         if (check_period(snapshots_path, cmd, arg1, &savet)) {
 351                                 printf("run");
 352                                 fflush(stdout);
 353                                 if (VerboseOpt)
 354                                         printf("\n");
 355                                 r = cleanup_recopy(path, snapshots_path,
 356                                                arg1, arg2);
 357                         } else {
 358                                 printf("skip\n");
 359                         }
 360                 } else {
 361                         printf("unknown directive\n");
 362                         r = 1;
 363                 }
 364                 if (r == 0)
 365                         save_period(snapshots_path, cmd, savet);
 366         }
 367         fclose(fp);
 368
 369         /*
 370          * Add new rebalance feature if the config doesn't have it
 371          */
 372         if (found_rebal == 0) {
 373                 if ((fp = fopen(config_path, "r+")) != NULL) {
 374                         fseek(fp, 0L, 2);
 375                         fprintf(fp, "rebalance 1d 5m\n");
 376                         fclose(fp);
 377                 }
 378         }
 379         usleep(1000);
 380 }
 381
 382 static
 383 int
 384 strtosecs(char *ptr)
 385 {
 386         int val;
 387
 388         val = strtol(ptr, &ptr, 0);
 389         switch(*ptr) {
 390         case 'd':
 391                 val *= 24;
 392                 /* fall through */
 393         case 'h':
 394                 val *= 60;
 395                 /* fall through */
 396         case 'm':
 397                 val *= 60;
 398                 /* fall through */
 399         case 's':
 400                 break;
 401         default:
 402                 errx(1, "illegal suffix converting %s\n", ptr);
 403                 break;
 404         }
 405         return(val);
 406 }
 407
 408 static const char *
 409 dividing_slash(const char *path)
 410 {
 411         int len = strlen(path);
 412         if (len && path[len-1] == '/')
 413                 return("");
 414         else
 415                 return("/");
 416 }
 417
 418 /*
 419  * Check whether the desired period has elapsed since the last successful
 420  * run.  The run may take a while and cross a boundary so we remember the
 421  * current time_t so we can save it later on.
 422  *
 423  * Periods in minutes, hours, or days are assumed to have been crossed
 424  * if the local time crosses a minute, hour, or day boundary regardless
 425  * of how close the last operation actually was.
 426  */
 427 static int
 428 check_period(const char *snapshots_path, const char *cmd, int arg1,
 429         time_t *savep)
 430 {
 431         char *check_path;
 432         struct tm tp1;
 433         struct tm tp2;
 434         FILE *fp;
 435         time_t baset, lastt;
 436         char buf[256];
 437
 438         time(savep);
 439         localtime_r(savep, &tp1);
 440
 441         /*
 442          * Retrieve the start time of the last successful operation.
 443          */
 444         asprintf(&check_path, "%s/.%s.period", snapshots_path, cmd);
 445         fp = fopen(check_path, "r");
 446         free(check_path);
 447         if (fp == NULL)
 448                 return(1);
 449         if (fgets(buf, sizeof(buf), fp) == NULL) {
 450                 fclose(fp);
 451                 return(1);
 452         }
 453         fclose(fp);
 454
 455         lastt = strtol(buf, NULL, 0);
 456         localtime_r(&lastt, &tp2);
 457
 458         /*
 459          * Normalize the times.  e.g. if asked to do something on a 1-day
 460          * interval the operation will be performed as soon as the day
 461          * turns over relative to the previous operation, even if the previous
 462          * operation ran a few seconds ago just before midnight.
 463          */
 464         if (arg1 % 60 == 0) {
 465                 tp1.tm_sec = 0;
 466                 tp2.tm_sec = 0;
 467         }
 468         if (arg1 % (60 * 60) == 0) {
 469                 tp1.tm_min = 0;
 470                 tp2.tm_min = 0;
 471         }
 472         if (arg1 % (24 * 60 * 60) == 0) {
 473                 tp1.tm_hour = 0;
 474                 tp2.tm_hour = 0;
 475         }
 476
 477         baset = mktime(&tp1);
 478         lastt = mktime(&tp2);
 479
 480 #if 0
 481         printf("%lld vs %lld\n", (long long)(baset - lastt), (long long)arg1);
 482 #endif
 483
 484         if ((int)(baset - lastt) >= arg1)
 485                 return(1);
 486         return(0);
 487 }
 488
 489 /*
 490  * Store the start time of the last successful operation.
 491  */
 492 static void
 493 save_period(const char *snapshots_path, const char *cmd,
 494                         time_t savet)
 495 {
 496         char *ocheck_path;
 497         char *ncheck_path;
 498         FILE *fp;
 499
 500         asprintf(&ocheck_path, "%s/.%s.period", snapshots_path, cmd);
 501         asprintf(&ncheck_path, "%s/.%s.period.new", snapshots_path, cmd);
 502         fp = fopen(ncheck_path, "w");
 503         if (fp) {
 504                 fprintf(fp, "0x%08llx\n", (long long)savet);
 505                 if (fclose(fp) == 0)
 506                         rename(ncheck_path, ocheck_path);
 507                 remove(ncheck_path);
 508         } else {
 509                 fprintf(stderr, "hammer: Unable to create period-file %s: %s\n",
 510                         ncheck_path, strerror(errno));
 511         }
 512 }
 513
 514 /*
 515  * Simply count the number of softlinks in the snapshots dir
 516  */
 517 static int
 518 check_softlinks(const char *snapshots_path)
 519 {
 520         struct dirent *den;
 521         struct stat st;
 522         DIR *dir;
 523         char *fpath;
 524         int res = 0;
 525
 526         if ((dir = opendir(snapshots_path)) != NULL) {
 527                 while ((den = readdir(dir)) != NULL) {
 528                         if (den->d_name[0] == '.')
 529                                 continue;
 530                         asprintf(&fpath, "%s/%s", snapshots_path, den->d_name);
 531                         if (lstat(fpath, &st) == 0 && S_ISLNK(st.st_mode))
 532                                 ++res;
 533                         free(fpath);
 534                 }
 535                 closedir(dir);
 536         }
 537         return(res);
 538 }
 539
 540 /*
 541  * Clean up expired softlinks in the snapshots dir
 542  */
 543 static void
 544 cleanup_softlinks(const char *path __unused, const char *snapshots_path,
 545                   int arg2, char *arg3)
 546 {
 547         struct dirent *den;
 548         struct stat st;
 549         DIR *dir;
 550         char *fpath;
 551         int anylink = 0;
 552
 553         if (arg3 != NULL && strstr(arg3, "any") != NULL)
 554                 anylink = 1;
 555
 556         if ((dir = opendir(snapshots_path)) != NULL) {
 557                 while ((den = readdir(dir)) != NULL) {
 558                         if (den->d_name[0] == '.')
 559                                 continue;
 560                         asprintf(&fpath, "%s/%s", snapshots_path, den->d_name);
 561                         if (lstat(fpath, &st) == 0 && S_ISLNK(st.st_mode) &&
 562                             (anylink || strncmp(den->d_name, "snap-", 5) == 0)
 563                         ) {
 564                                 if (check_expired(den->d_name, arg2)) {
 565                                         if (VerboseOpt) {
 566                                                 printf("    expire %s\n",
 567                                                         fpath);
 568                                         }
 569                                         remove(fpath);
 570                                 }
 571                         }
 572                         free(fpath);
 573                 }
 574                 closedir(dir);
 575         }
 576 }
 577
 578 /*
 579  * Take a softlink path in the form snap-yyyymmdd-hhmm and the
 580  * expiration in seconds (arg2) and return non-zero if the softlink
 581  * has expired.
 582  */
 583 static int
 584 check_expired(const char *fpath, int arg2)
 585 {
 586         struct tm tm;
 587         time_t t;
 588         int year;
 589         int month;
 590         int day = 0;
 591         int hour = 0;
 592         int minute = 0;
 593         int r;
 594
 595         while (*fpath && *fpath != '-' && *fpath != '.')
 596                 ++fpath;
 597         if (*fpath)
 598                 ++fpath;
 599
 600         r = sscanf(fpath, "%4d%2d%2d-%2d%2d",
 601                    &year, &month, &day, &hour, &minute);
 602
 603         if (r >= 3) {
 604                 bzero(&tm, sizeof(tm));
 605                 tm.tm_isdst = -1;
 606                 tm.tm_min = minute;
 607                 tm.tm_hour = hour;
 608                 tm.tm_mday = day;
 609                 tm.tm_mon = month - 1;
 610                 tm.tm_year = year - 1900;
 611                 t = mktime(&tm);
 612                 if (t == (time_t)-1)
 613                         return(0);
 614                 t = time(NULL) - t;
 615                 if ((int)t > arg2)
 616                         return(1);
 617         }
 618         return(0);
 619 }
 620
 621 /*
 622  * Issue a snapshot.
 623  */
 624 static int
 625 create_snapshot(const char *path __unused, const char *snapshots_path,
 626                   int arg1 __unused, int arg2 __unused)
 627 {
 628         int r;
 629
 630         runcmd(&r, "hammer snapshot %s %s", path, snapshots_path);
 631         return(r);
 632 }
 633
 634 static int
 635 cleanup_prune(const char *path __unused, const char *snapshots_path,
 636                   int arg1 __unused, int arg2, int snapshots_disabled)
 637 {
 638         /*
 639          * If snapshots have been disabled run prune-everything instead
 640          * of prune.
 641          */
 642         if (snapshots_disabled && arg2) {
 643                 runcmd(NULL, "hammer -c %s/.prune.cycle -t %d prune-everything %s",
 644                         snapshots_path, arg2, path);
 645         } else if (snapshots_disabled) {
 646                 runcmd(NULL, "hammer prune-everything %s", path);
 647         } else if (arg2) {
 648                 runcmd(NULL, "hammer -c %s/.prune.cycle -t %d prune %s",
 649                         snapshots_path, arg2, snapshots_path);
 650         } else {
 651                 runcmd(NULL, "hammer prune %s", snapshots_path);
 652         }
 653         return(0);
 654 }
 655
 656 static int
 657 cleanup_rebalance(const char *path, const char *snapshots_path,
 658                   int arg1 __unused, int arg2)
 659 {
 660         if (VerboseOpt == 0) {
 661                 printf(".");
 662                 fflush(stdout);
 663         }
 664
 665         runcmd(NULL,
 666                "hammer -c %s/.rebalance.cycle -t %d rebalance %s",
 667                snapshots_path, arg2, path);
 668         if (VerboseOpt == 0) {
 669                 printf(".");
 670                 fflush(stdout);
 671         }
 672         if (VerboseOpt == 0)
 673                 printf("\n");
 674         return(0);
 675 }
 676
 677 static int
 678 cleanup_reblock(const char *path, const char *snapshots_path,
 679                   int arg1 __unused, int arg2)
 680 {
 681         if (VerboseOpt == 0) {
 682                 printf(".");
 683                 fflush(stdout);
 684         }
 685
 686         /*
 687          * When reblocking the B-Tree always reblock everything in normal
 688          * mode.
 689          */
 690         runcmd(NULL,
 691                "hammer -c %s/.reblock-1.cycle -t %d reblock-btree %s",
 692                snapshots_path, arg2, path);
 693         if (VerboseOpt == 0) {
 694                 printf(".");
 695                 fflush(stdout);
 696         }
 697
 698         /*
 699          * When reblocking the inodes always reblock everything in normal
 700          * mode.
 701          */
 702         runcmd(NULL,
 703                "hammer -c %s/.reblock-2.cycle -t %d reblock-inodes %s",
 704                snapshots_path, arg2, path);
 705         if (VerboseOpt == 0) {
 706                 printf(".");
 707                 fflush(stdout);
 708         }
 709
 710         /*
 711          * When reblocking the directories always reblock everything in normal
 712          * mode.
 713          */
 714         runcmd(NULL,
 715                "hammer -c %s/.reblock-4.cycle -t %d reblock-dirs %s",
 716                snapshots_path, arg2, path);
 717         if (VerboseOpt == 0) {
 718                 printf(".");
 719                 fflush(stdout);
 720         }
 721
 722         /*
 723          * Do not reblock all the data in normal mode.
 724          */
 725         runcmd(NULL,
 726                "hammer -c %s/.reblock-3.cycle -t %d reblock-data %s 95",
 727                snapshots_path, arg2, path);
 728         if (VerboseOpt == 0)
 729                 printf("\n");
 730         return(0);
 731 }
 732
 733 static int
 734 cleanup_recopy(const char *path, const char *snapshots_path,
 735                   int arg1 __unused, int arg2)
 736 {
 737         if (VerboseOpt == 0) {
 738                 printf(".");
 739                 fflush(stdout);
 740         }
 741         runcmd(NULL,
 742                "hammer -c %s/.recopy-1.cycle -t %d reblock-btree %s",
 743                snapshots_path, arg2, path);
 744         if (VerboseOpt == 0) {
 745                 printf(".");
 746                 fflush(stdout);
 747         }
 748         runcmd(NULL,
 749                "hammer -c %s/.recopy-2.cycle -t %d reblock-inodes %s",
 750                snapshots_path, arg2, path);
 751         if (VerboseOpt == 0) {
 752                 printf(".");
 753                 fflush(stdout);
 754         }
 755         runcmd(NULL,
 756                "hammer -c %s/.recopy-4.cycle -t %d reblock-dirs %s",
 757                snapshots_path, arg2, path);
 758         if (VerboseOpt == 0) {
 759                 printf(".");
 760                 fflush(stdout);
 761         }
 762         runcmd(NULL,
 763                "hammer -c %s/.recopy-3.cycle -t %d reblock-data %s",
 764                snapshots_path, arg2, path);
 765         if (VerboseOpt == 0)
 766                 printf("\n");
 767         return(0);
 768 }
 769
 770 static
 771 void
 772 runcmd(int *resp, const char *ctl, ...)
 773 {
 774         va_list va;
 775         char *cmd;
 776         char *arg;
 777         char **av;
 778         int n;
 779         int nmax;
 780         int res;
 781         pid_t pid;
 782
 783         /*
 784          * Generate the command
 785          */
 786         va_start(va, ctl);
 787         vasprintf(&cmd, ctl, va);
 788         va_end(va);
 789         if (VerboseOpt)
 790                 printf("    %s\n", cmd);
 791
 792         /*
 793          * Break us down into arguments.  We do not just use system() here
 794          * because it blocks SIGINT and friends.
 795          */
 796         n = 0;
 797         nmax = 16;
 798         av = malloc(sizeof(char *) * nmax);
 799
 800         for (arg = strtok(cmd, WS); arg; arg = strtok(NULL, WS)) {
 801                 if (n == nmax - 1) {
 802                         nmax += 16;
 803                         av = realloc(av, sizeof(char *) * nmax);
 804                 }
 805                 av[n++] = arg;
 806         }
 807         av[n++] = NULL;
 808
 809         /*
 810          * Run the command.
 811          */
 812         RunningIoctl = 1;
 813         if ((pid = fork()) == 0) {
 814                 if (VerboseOpt < 2) {
 815                         int fd = open("/dev/null", O_RDWR);
 816                         dup2(fd, 1);
 817                         close(fd);
 818                 }
 819                 execvp(av[0], av);
 820                 _exit(127);
 821         } else if (pid < 0) {
 822                 res = 127;
 823         } else {
 824                 int status;
 825
 826                 while (waitpid(pid, &status, 0) != pid)
 827                         ;
 828                 res = WEXITSTATUS(status);
 829         }
 830         RunningIoctl = 0;
 831         if (DidInterrupt)
 832                 _exit(1);
 833
 834         free(cmd);
 835         free(av);
 836         if (resp)
 837                 *resp = res;
 838 }