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