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