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