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 753