usr.bin/undo/undo.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/usr.bin/undo/undo.c,v 1.6 2008/07/17 21:34:47 thomas Exp $
  35  */
  36 /*
  37  * UNDO - retrieve an older version of a file.
  38  */
  39
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/wait.h>
  43 #include <sys/tree.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <stdarg.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49 #include <fcntl.h>
  50 #include <errno.h>
  51 #include <vfs/hammer/hammer_disk.h>
  52 #include <vfs/hammer/hammer_ioctl.h>
  53
  54 /*
  55  * Sorted list of transaction ids
  56  */
  57 struct undo_hist_entry;
  58 RB_HEAD(undo_hist_entry_rb_tree, undo_hist_entry);
  59 RB_PROTOTYPE2(undo_hist_entry_rb_tree, undo_hist_entry, rbnode,
  60         undo_hist_entry_compare, hammer_tid_t);
  61
  62 struct undo_hist_entry {
  63         RB_ENTRY(undo_hist_entry) rbnode;
  64         struct hammer_ioc_hist_entry tse;
  65         ino_t inum;
  66 };
  67
  68 enum undo_type { TYPE_FILE, TYPE_DIFF, TYPE_RDIFF, TYPE_HISTORY };
  69 enum undo_cmd { CMD_DUMP, CMD_ITERATEALL };
  70
  71 #define UNDO_FLAG_MULT          0x0001
  72 #define UNDO_FLAG_INOCHG        0x0002
  73 #define UNDO_FLAG_SETTID1       0x0004
  74 #define UNDO_FLAG_SETTID2       0x0008
  75
  76 static int undo_hist_entry_compare(struct undo_hist_entry *he1,
  77                     struct undo_hist_entry *he2);
  78 static void doiterate(const char *filename, const char *outFileName,
  79                    const char *outFilePostfix, int flags,
  80                    struct hammer_ioc_hist_entry ts1,
  81                    struct hammer_ioc_hist_entry ts2,
  82                    enum undo_cmd cmd, enum undo_type type);
  83 static void dogenerate(const char *filename, const char *outFileName,
  84                    const char *outFilePostfix,
  85                    int flags, int idx, enum undo_type type,
  86                    struct hammer_ioc_hist_entry ts1,
  87                    struct hammer_ioc_hist_entry ts2);
  88 static void collect_history(int fd, int *error,
  89                    struct undo_hist_entry_rb_tree *tse_tree);
  90 static void collect_dir_history(const char *filename, int *error,
  91                    struct undo_hist_entry_rb_tree *dir_tree);
  92 static void clean_tree(struct undo_hist_entry_rb_tree *tree);
  93 static hammer_tid_t parse_delta_time(const char *timeStr, int *flags,
  94                    int ind_flag);
  95 static void runcmd(int fd, const char *cmd, ...);
  96 static char *timestamp(hammer_ioc_hist_entry_t hen);
  97 static void usage(void);
  98
  99 static int VerboseOpt;
 100
 101 RB_GENERATE2(undo_hist_entry_rb_tree, undo_hist_entry, rbnode,
 102         undo_hist_entry_compare, hammer_tid_t, tse.tid);
 103
 104
 105 int
 106 main(int ac, char **av)
 107 {
 108         const char *outFileName = NULL;
 109         const char *outFilePostfix = NULL;
 110         enum undo_cmd cmd;
 111         enum undo_type type;
 112         struct hammer_ioc_hist_entry ts1;
 113         struct hammer_ioc_hist_entry ts2;
 114         int c;
 115         int count_t;
 116         int flags;
 117
 118         bzero(&ts1, sizeof(ts1));
 119         bzero(&ts2, sizeof(ts2));
 120
 121         cmd = CMD_DUMP;
 122         type = TYPE_FILE;
 123         count_t = 0;
 124         flags = 0;
 125
 126         while ((c = getopt(ac, av, "adDiuvo:t:")) != -1) {
 127                 switch(c) {
 128                 case 'd':
 129                         type = TYPE_DIFF;
 130                         break;
 131                 case 'D':
 132                         type = TYPE_RDIFF;
 133                         break;
 134                 case 'i':
 135                         if (type != TYPE_FILE)
 136                                 usage();
 137                         type = TYPE_HISTORY;
 138                         cmd = CMD_ITERATEALL;
 139                         break;
 140                 case 'a':
 141                         cmd = CMD_ITERATEALL;
 142                         break;
 143                 case 'u':
 144                         outFilePostfix = ".undo";
 145                         break;
 146                 case 'v':
 147                         ++VerboseOpt;
 148                         break;
 149                 case 'o':
 150                         outFileName = optarg;
 151                         break;
 152                 case 't':
 153                         /*
 154                          * Parse one or two -t options.  If two are specified
 155                          * -d is implied (but may be overridden)
 156                          */
 157                         ++count_t;
 158                         if (count_t == 1) {
 159                                 ts1.tid = parse_delta_time(optarg, &flags,
 160                                                            UNDO_FLAG_SETTID1);
 161                         } else if (count_t == 2) {
 162                                 ts2.tid = parse_delta_time(optarg, &flags,
 163                                                            UNDO_FLAG_SETTID2);
 164                                 if (type == TYPE_FILE)
 165                                         type = TYPE_DIFF;
 166                         } else {
 167                                 usage();
 168                         }
 169                         break;
 170                 default:
 171                         usage();
 172                         /* NOT REACHED */
 173                         break;
 174                 }
 175         }
 176
 177         /*
 178          * Option validation
 179          */
 180         if (outFileName && outFilePostfix) {
 181                 fprintf(stderr, "The -o option may not be combined with -u\n");
 182                 usage();
 183         }
 184
 185         ac -= optind;
 186         av += optind;
 187         if (ac > 1)
 188                 flags |= UNDO_FLAG_MULT;
 189
 190         if (ac == 0)
 191                 usage();
 192
 193         /*
 194          * Validate the output template, if specified.
 195          */
 196         if (outFileName && (flags & UNDO_FLAG_MULT)) {
 197                 const char *ptr = outFileName;
 198                 int didStr = 0;
 199
 200                 while ((ptr = strchr(ptr, '%')) != NULL) {
 201                         if (ptr[1] == 's') {
 202                                 if (didStr) {
 203                                         fprintf(stderr, "Malformed output "
 204                                                         "template\n");
 205                                         usage();
 206                                 }
 207                                 didStr = 1;
 208                                 ++ptr;
 209                         } else if (ptr[1] != '%') {
 210                                 fprintf(stderr, "Malformed output template\n");
 211                                 usage();
 212                         } else {
 213                                 ptr += 2;
 214                         }
 215                 }
 216         }
 217
 218         while (ac) {
 219                 doiterate(*av, outFileName, outFilePostfix,
 220                           flags, ts1, ts2, cmd, type);
 221                 ++av;
 222                 --ac;
 223         }
 224         return(0);
 225 }
 226
 227 /*
 228  * Iterate through a file's history.  If cmd == CMD_DUMP we take the
 229  * next-to-last transaction id, unless another given.  Otherwise if
 230  * cmd == CMD_ITERATEALL we scan all transaction ids.
 231  *
 232  * Also iterate through the directory's history to locate other inodes that
 233  * used the particular file name.
 234  */
 235 static
 236 void
 237 doiterate(const char *filename, const char *outFileName,
 238           const char *outFilePostfix, int flags,
 239           struct hammer_ioc_hist_entry ts1,
 240           struct hammer_ioc_hist_entry ts2,
 241           enum undo_cmd cmd, enum undo_type type)
 242 {
 243         struct undo_hist_entry_rb_tree dir_tree;
 244         struct undo_hist_entry_rb_tree tse_tree;
 245         struct undo_hist_entry *tse1;
 246         struct undo_hist_entry *tse2;
 247         struct hammer_ioc_hist_entry tid_max;
 248         char *path = NULL;
 249         int i;
 250         int fd;
 251         int error;
 252
 253         RB_INIT(&dir_tree);
 254         RB_INIT(&tse_tree);
 255
 256         tid_max.tid = HAMMER_MAX_TID;
 257         tid_max.time32 = 0;
 258
 259         /*
 260          * Use the directory history to locate all possible versions of
 261          * the file.
 262          */
 263         collect_dir_history(filename, &error, &dir_tree);
 264         RB_FOREACH(tse1, undo_hist_entry_rb_tree, &dir_tree) {
 265                 asprintf(&path, "%s@@0x%016jx", filename, (uintmax_t)tse1->tse.tid);
 266                 if ((fd = open(path, O_RDONLY)) > 0) {
 267                         collect_history(fd, &error, &tse_tree);
 268                         close(fd);
 269                 }
 270         }
 271         if (cmd == CMD_DUMP) {
 272                 if ((ts1.tid == 0 ||
 273                      flags & (UNDO_FLAG_SETTID1|UNDO_FLAG_SETTID2)) &&
 274                     RB_EMPTY(&tse_tree)) {
 275                         if ((fd = open(filename, O_RDONLY)) > 0) {
 276                                 collect_history(fd, &error, &tse_tree);
 277                                 close(fd);
 278                         }
 279                 }
 280                 /*
 281                  * Find entry if tid set to placeholder index
 282                  */
 283                 if (flags & UNDO_FLAG_SETTID1){
 284                         tse1 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree);
 285                         while (tse1 && ts1.tid--) {
 286                                 tse1 = RB_PREV(undo_hist_entry_rb_tree,
 287                                                &tse_tree, tse1);
 288                         }
 289                         if (tse1)
 290                                 ts1 = tse1->tse;
 291                         else
 292                                 ts1.tid = 0;
 293                 }
 294                 if (flags & UNDO_FLAG_SETTID2){
 295                         tse2 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree);
 296                         while (tse2 && ts2.tid--) {
 297                                 tse2 = RB_PREV(undo_hist_entry_rb_tree,
 298                                                &tse_tree, tse2);
 299                         }
 300                         if (tse2)
 301                                 ts2 = tse2->tse;
 302                         else
 303                                 ts2.tid = 0;
 304                 }
 305
 306                 /*
 307                  * Single entry, most recent prior to current
 308                  */
 309                 if (ts1.tid == 0) {
 310                         tse2 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree);
 311                         if (tse2) {
 312                                 ts2 = tse2->tse;
 313                                 tse1 = RB_PREV(undo_hist_entry_rb_tree,
 314                                                &tse_tree, tse2);
 315                                 if (tse1)
 316                                         ts1 = tse1->tse;
 317                         }
 318                 }
 319                 if (ts1.tid == 0) {
 320                         printf("%s: No UNDO history found\n", filename);
 321                 } else {
 322                         dogenerate(filename,
 323                                    outFileName, outFilePostfix,
 324                                    0, 0, type,
 325                                    ts1, ts2);
 326                 }
 327         } else if (RB_ROOT(&tse_tree)) {
 328                 /*
 329                  * Iterate entire history
 330                  */
 331                 printf("%s: ITERATE ENTIRE HISTORY\n", filename);
 332
 333                 tse1 = NULL;
 334                 i = 0;
 335                 RB_FOREACH(tse2, undo_hist_entry_rb_tree, &tse_tree) {
 336                         if (tse1) {
 337                                 dogenerate(filename,
 338                                            outFileName, outFilePostfix,
 339                                            flags, i, type,
 340                                            tse1->tse, tse2->tse);
 341                         }
 342                         if (tse1 && tse2->inum != tse1->inum)
 343                                 flags |= UNDO_FLAG_INOCHG;
 344                         else
 345                                 flags &= ~UNDO_FLAG_INOCHG;
 346                         tse1 = tse2;
 347                         ++i;
 348                 }
 349                 /*
 350                  * There is no delta to print for the last pair,
 351                  * because they are identical.
 352                  */
 353                 if (type != TYPE_DIFF && type != TYPE_RDIFF) {
 354                         dogenerate(filename,
 355                                    outFileName, outFilePostfix,
 356                                    flags, i, type,
 357                                    tse1->tse, tid_max);
 358                 }
 359         } else {
 360                 printf("%s: ITERATE ENTIRE HISTORY: %s\n",
 361                        filename, strerror(error));
 362         }
 363         if (path)
 364                 free(path);
 365         clean_tree(&dir_tree);
 366         clean_tree(&tse_tree);
 367 }
 368
 369 /*
 370  * Generate output for a file as-of ts1 (ts1 may be 0!), if diffing then
 371  * through ts2.
 372  */
 373 static
 374 void
 375 dogenerate(const char *filename, const char *outFileName,
 376            const char *outFilePostfix,
 377            int flags, int idx, enum undo_type type,
 378            struct hammer_ioc_hist_entry ts1,
 379            struct hammer_ioc_hist_entry ts2)
 380 {
 381         struct stat st;
 382         const char *elm;
 383         char *ipath1 = NULL;
 384         char *ipath2 = NULL;
 385         FILE *fi;
 386         FILE *fp;
 387         char *buf;
 388         char *path;
 389         time_t t;
 390         struct tm *tp;
 391         char datestr[64];
 392         int n;
 393
 394         buf = malloc(8192);
 395
 396         /*
 397          * Open the input file.  If ts1 is 0 try to locate the most recent
 398          * version of the file prior to the current version.
 399          */
 400         if (ts1.tid == 0)
 401                 asprintf(&ipath1, "%s", filename);
 402         else
 403                 asprintf(&ipath1, "%s@@0x%016jx", filename, (uintmax_t)ts1.tid);
 404
 405         if (ts2.tid == 0)
 406                 asprintf(&ipath2, "%s", filename);
 407         else
 408                 asprintf(&ipath2, "%s@@0x%016jx", filename, (uintmax_t)ts2.tid);
 409
 410         if (lstat(ipath1, &st) < 0 && lstat(ipath2, &st) < 0) {
 411                 if (idx == 0 || VerboseOpt) {
 412                         fprintf(stderr, "Unable to access either %s or %s\n",
 413                                 ipath1, ipath2);
 414                 }
 415                 free(ipath1);
 416                 free(ipath2);
 417                 goto done;
 418         }
 419
 420         /*
 421          * elm is the last component of the input file name
 422          */
 423         if ((elm = strrchr(filename, '/')) != NULL)
 424                 ++elm;
 425         else
 426                 elm = filename;
 427
 428         /*
 429          * Where do we stuff our output?
 430          */
 431         if (outFileName) {
 432                 if (flags & UNDO_FLAG_MULT) {
 433                         asprintf(&path, outFileName, elm);
 434                         fp = fopen(path, "w");
 435                         if (fp == NULL) {
 436                                 perror(path);
 437                                 exit(1);
 438                         }
 439                         free(path);
 440                 } else {
 441                         fp = fopen(outFileName, "w");
 442                         if (fp == NULL) {
 443                                 perror(outFileName);
 444                                 exit(1);
 445                         }
 446                 }
 447         } else if (outFilePostfix) {
 448                 if (idx >= 0) {
 449                         asprintf(&path, "%s%s.%04d", filename,
 450                                  outFilePostfix, idx);
 451                 } else {
 452                         asprintf(&path, "%s%s", filename, outFilePostfix);
 453                 }
 454                 fp = fopen(path, "w");
 455                 if (fp == NULL) {
 456                         perror(path);
 457                         exit(1);
 458                 }
 459                 free(path);
 460         } else {
 461                 if ((flags & UNDO_FLAG_MULT) && type == TYPE_FILE) {
 462                         if (idx >= 0) {
 463                                 printf("\n>>> %s %04d 0x%016jx %s\n\n",
 464                                        filename, idx, (uintmax_t)ts1.tid,
 465                                        timestamp(&ts1));
 466                         } else {
 467                                 printf("\n>>> %s ---- 0x%016jx %s\n\n",
 468                                        filename, (uintmax_t)ts1.tid,
 469                                        timestamp(&ts1));
 470                         }
 471                 } else if (idx >= 0 && type == TYPE_FILE) {
 472                         printf("\n>>> %s %04d 0x%016jx %s\n\n",
 473                                filename, idx, (uintmax_t)ts1.tid,
 474                                timestamp(&ts1));
 475                 }
 476                 fp = stdout;
 477         }
 478
 479         switch(type) {
 480         case TYPE_FILE:
 481                 if ((fi = fopen(ipath1, "r")) != NULL) {
 482                         while ((n = fread(buf, 1, 8192, fi)) > 0)
 483                                 fwrite(buf, 1, n, fp);
 484                         fclose(fi);
 485                 }
 486                 break;
 487         case TYPE_DIFF:
 488                 printf("diff -N -r -u %s %s (to %s)\n",
 489                        ipath1, ipath2, timestamp(&ts2));
 490                 fflush(stdout);
 491                 runcmd(fileno(fp), "/usr/bin/diff", "diff", "-N", "-r", "-u", ipath1, ipath2, NULL);
 492                 break;
 493         case TYPE_RDIFF:
 494                 printf("diff -N -r -u %s %s\n", ipath2, ipath1);
 495                 fflush(stdout);
 496                 runcmd(fileno(fp), "/usr/bin/diff", "diff", "-N", "-r", "-u", ipath2, ipath1, NULL);
 497                 break;
 498         case TYPE_HISTORY:
 499                 t = (time_t)ts1.time32;
 500                 tp = localtime(&t);
 501                 strftime(datestr, sizeof(datestr), "%d-%b-%Y %H:%M:%S", tp);
 502                 printf("\t0x%016jx %s", (uintmax_t)ts1.tid, datestr);
 503                 if (flags & UNDO_FLAG_INOCHG)
 504                         printf(" inode-change");
 505                 if (lstat(ipath1, &st) < 0)
 506                         printf(" file-deleted");
 507                 printf("\n");
 508                 break;
 509         }
 510
 511         if (fp != stdout)
 512                 fclose(fp);
 513 done:
 514         free(buf);
 515 }
 516
 517 static
 518 void
 519 clean_tree(struct undo_hist_entry_rb_tree *tree)
 520 {
 521         struct undo_hist_entry *tse;
 522
 523         while ((tse = RB_ROOT(tree)) != NULL) {
 524                 RB_REMOVE(undo_hist_entry_rb_tree, tree, tse);
 525                 free(tse);
 526         }
 527 }
 528
 529 static
 530 void
 531 collect_history(int fd, int *errorp, struct undo_hist_entry_rb_tree *tse_tree)
 532 {
 533         struct hammer_ioc_history hist;
 534         struct undo_hist_entry *tse;
 535         struct stat st;
 536         int istmp;
 537         int i;
 538
 539         /*
 540          * Setup
 541          */
 542         bzero(&hist, sizeof(hist));
 543         hist.beg_tid = HAMMER_MIN_TID;
 544         hist.end_tid = HAMMER_MAX_TID;
 545         hist.head.flags |= HAMMER_IOC_HISTORY_ATKEY;
 546         hist.key = 0;
 547         hist.nxt_key = HAMMER_MAX_KEY;
 548
 549         *errorp = 0;
 550
 551         if (tse_tree == NULL) {
 552                 tse_tree = malloc(sizeof(*tse_tree));
 553                 RB_INIT(tse_tree);
 554                 istmp = 1;
 555         } else {
 556                 istmp = 0;
 557         }
 558
 559         /*
 560          * Save the inode so inode changes can be reported.
 561          */
 562         st.st_ino = 0;
 563         fstat(fd, &st);
 564
 565         /*
 566          * Collect a unique set of transaction ids
 567          */
 568         if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
 569                 *errorp = errno;
 570                 goto done;
 571         }
 572         for (;;) {
 573                 for (i = 0; i < hist.count; ++i) {
 574                         tse = malloc(sizeof(*tse));
 575                         tse->tse = hist.hist_ary[i];
 576                         tse->inum = st.st_ino;
 577                         if (RB_INSERT(undo_hist_entry_rb_tree, tse_tree, tse)) {
 578                                 free(tse);
 579                         }
 580                 }
 581                 if (hist.head.flags & HAMMER_IOC_HISTORY_EOF)
 582                         break;
 583                 if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_KEY) {
 584                         hist.key = hist.nxt_key;
 585                         hist.nxt_key = HAMMER_MAX_KEY;
 586                 }
 587                 if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_TID)
 588                         hist.beg_tid = hist.nxt_tid;
 589                 if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
 590                         *errorp = errno;
 591                         break;
 592                 }
 593         }
 594
 595         /*
 596          * Cleanup
 597          */
 598 done:
 599         if (istmp) {
 600                 clean_tree(tse_tree);
 601                 free(tse_tree);
 602         }
 603 }
 604
 605 static
 606 void
 607 collect_dir_history(const char *filename, int *errorp,
 608                     struct undo_hist_entry_rb_tree *dir_tree)
 609 {
 610         char *dirname;
 611         int fd;
 612         int error;
 613
 614         *errorp = 0;
 615         if (strrchr(filename, '/')) {
 616                 dirname = strdup(filename);
 617                 *strrchr(dirname, '/') = 0;
 618         } else {
 619                 dirname = strdup(".");
 620         }
 621         if ((fd = open(dirname, O_RDONLY)) > 0) {
 622                 collect_history(fd, &error, dir_tree);
 623                 close(fd);
 624         }
 625 }
 626
 627 static
 628 hammer_tid_t
 629 parse_delta_time(const char *timeStr, int *flags, int ind_flag)
 630 {
 631         hammer_tid_t tid;
 632
 633         tid = strtoull(timeStr, NULL, 0);
 634         if (timeStr[0] == '+')
 635                 ++timeStr;
 636         if (timeStr[0] >= '0' && timeStr[0] <= '9' && timeStr[1] != 'x')
 637                 *flags |= ind_flag;
 638         return(tid);
 639 }
 640
 641 static void
 642 runcmd(int fd, const char *cmd, ...)
 643 {
 644         va_list va;
 645         pid_t pid;
 646         char **av;
 647         int ac;
 648         int i;
 649
 650         va_start(va, cmd);
 651         for (ac = 0; va_arg(va, void *) != NULL; ++ac)
 652                 ;
 653         va_end(va);
 654
 655         av = malloc((ac + 1) * sizeof(char *));
 656         va_start(va, cmd);
 657         for (i = 0; i < ac; ++i)
 658                 av[i] = va_arg(va, char *);
 659         va_end(va);
 660         av[i] = NULL;
 661
 662         if ((pid = fork()) < 0) {
 663                 perror("fork");
 664                 exit(1);
 665         } else if (pid == 0) {
 666                 if (fd != 1) {
 667                         dup2(fd, 1);
 668                         close(fd);
 669                 }
 670                 execv(cmd, av);
 671                 _exit(1);
 672         } else {
 673                 while (waitpid(pid, NULL, 0) != pid)
 674                         ;
 675         }
 676         free(av);
 677 }
 678
 679 /*
 680  * Convert tid to timestamp.
 681  */
 682 static char *
 683 timestamp(hammer_ioc_hist_entry_t hen)
 684 {
 685         static char timebuf[64];
 686         time_t t = (time_t)hen->time32;
 687         struct tm *tp;
 688
 689         tp = localtime(&t);
 690         strftime(timebuf, sizeof(timebuf), "%d-%b-%Y %H:%M:%S", tp);
 691         return(timebuf);
 692 }
 693
 694 static
 695 int
 696 undo_hist_entry_compare(struct undo_hist_entry *he1,
 697                         struct undo_hist_entry *he2)
 698 {
 699         if (he1->tse.tid < he2->tse.tid)
 700                 return(-1);
 701         if (he1->tse.tid > he2->tse.tid)
 702                 return(1);
 703         return(0);
 704 }
 705
 706 static void
 707 usage(void)
 708 {
 709         fprintf(stderr, "undo [-adDiuv] [-o outfile] "
 710                         "[-t transaction-id] [-t transaction-id] path...\n"
 711                         "    -a       Iterate all historical segments\n"
 712                         "    -d       Forward diff\n"
 713                         "    -D       Reverse diff\n"
 714                         "    -i       Dump history transaction ids\n"
 715                         "    -u       Generate .undo files\n"
 716                         "    -v       Verbose\n"
 717                         "    -o file  Output to the specified file\n"
 718                         "    -t TID   Retrieve as of transaction-id, TID\n"
 719                         "             (a second `-t TID' to diff two)\n"
 720                         "    transaction ids must be prefixed with 0x, and\n"
 721                         "    otherwise may specify an index starting at 0\n"
 722                         "    and iterating backwards through the history.\n"
 723         );
 724         exit(1);
 725 }
 726