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 if (stat(path, &sb) == 0 && sb.st_mode & S_IFIFO) { 269 fprintf(stderr, "Warning: fake transaction id 0x%016jx\n", (uintmax_t)tse1->tse.tid); 270 continue; 271 } 272 if ((fd = open(path, O_RDONLY)) > 0) { 273 collect_history(fd, &error, &tse_tree); 274 close(fd); 275 } 276 free(path); 277 } 278 if ((fd = open(filename, O_RDONLY)) > 0) { 279 collect_history(fd, &error, &tse_tree); 280 close(fd); 281 } 282 if (cmd == CMD_DUMP) { 283 if ((ts1.tid == 0 || 284 flags & (UNDO_FLAG_SETTID1|UNDO_FLAG_SETTID2)) && 285 RB_EMPTY(&tse_tree)) { 286 if ((fd = open(filename, O_RDONLY)) > 0) { 287 collect_history(fd, &error, &tse_tree); 288 close(fd); 289 } 290 } 291 /* 292 * Find entry if tid set to placeholder index 293 */ 294 if (flags & UNDO_FLAG_SETTID1){ 295 tse1 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree); 296 while (tse1 && ts1.tid--) { 297 tse1 = RB_PREV(undo_hist_entry_rb_tree, 298 &tse_tree, tse1); 299 } 300 if (tse1) 301 ts1 = tse1->tse; 302 else 303 ts1.tid = 0; 304 } 305 if (flags & UNDO_FLAG_SETTID2){ 306 tse2 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree); 307 while (tse2 && ts2.tid--) { 308 tse2 = RB_PREV(undo_hist_entry_rb_tree, 309 &tse_tree, tse2); 310 } 311 if (tse2) 312 ts2 = tse2->tse; 313 else 314 ts2.tid = 0; 315 } 316 317 /* 318 * Single entry, most recent prior to current 319 */ 320 if (ts1.tid == 0) { 321 tse2 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree); 322 if (tse2) { 323 ts2 = tse2->tse; 324 tse1 = RB_PREV(undo_hist_entry_rb_tree, 325 &tse_tree, tse2); 326 if (tse1) 327 ts1 = tse1->tse; 328 } 329 } 330 if (ts1.tid == 0) { 331 printf("%s: No UNDO history found\n", filename); 332 } else { 333 dogenerate(filename, 334 outFileName, outFilePostfix, 335 0, 0, type, 336 ts1, ts2); 337 } 338 } else if (RB_ROOT(&tse_tree)) { 339 /* 340 * Iterate entire history 341 */ 342 printf("%s: ITERATE ENTIRE HISTORY\n", filename); 343 344 tse1 = NULL; 345 i = 0; 346 RB_FOREACH(tse2, undo_hist_entry_rb_tree, &tse_tree) { 347 if (tse1) { 348 dogenerate(filename, 349 outFileName, outFilePostfix, 350 flags, i, type, 351 tse1->tse, tse2->tse); 352 } 353 if (tse1 && tse2->inum != tse1->inum) 354 flags |= UNDO_FLAG_INOCHG; 355 else 356 flags &= ~UNDO_FLAG_INOCHG; 357 tse1 = tse2; 358 ++i; 359 } 360 /* 361 * There is no delta to print for the last pair, 362 * because they are identical. 363 */ 364 if (type != TYPE_DIFF && type != TYPE_RDIFF) { 365 dogenerate(filename, 366 outFileName, outFilePostfix, 367 flags, i, type, 368 tse1->tse, tid_max); 369 } 370 } else { 371 printf("%s: ITERATE ENTIRE HISTORY: %s\n", 372 filename, strerror(error)); 373 } 374 clean_tree(&dir_tree); 375 clean_tree(&tse_tree); 376 } 377 378 /* 379 * Generate output for a file as-of ts1 (ts1 may be 0!), if diffing then 380 * through ts2. 381 */ 382 static 383 void 384 dogenerate(const char *filename, const char *outFileName, 385 const char *outFilePostfix, 386 int flags, int idx, enum undo_type type, 387 struct hammer_ioc_hist_entry ts1, 388 struct hammer_ioc_hist_entry ts2) 389 { 390 struct stat st; 391 const char *elm; 392 char *ipath1 = NULL; 393 char *ipath2 = NULL; 394 FILE *fi; 395 FILE *fp; 396 char *buf; 397 char *path; 398 time_t t; 399 struct tm *tp; 400 char datestr[64]; 401 int n; 402 403 buf = malloc(8192); 404 405 /* 406 * Open the input file. If ts1 is 0 try to locate the most recent 407 * version of the file prior to the current version. 408 */ 409 if (ts1.tid == 0) 410 asprintf(&ipath1, "%s", filename); 411 else 412 asprintf(&ipath1, "%s@@0x%016jx", filename, (uintmax_t)ts1.tid); 413 414 if (ts2.tid == 0) 415 asprintf(&ipath2, "%s", filename); 416 else 417 asprintf(&ipath2, "%s@@0x%016jx", filename, (uintmax_t)ts2.tid); 418 419 if (lstat(ipath1, &st) < 0 && lstat(ipath2, &st) < 0) { 420 if (idx == 0 || VerboseOpt) { 421 fprintf(stderr, "Unable to access either %s or %s\n", 422 ipath1, ipath2); 423 } 424 free(ipath1); 425 free(ipath2); 426 goto done; 427 } 428 429 /* 430 * elm is the last component of the input file name 431 */ 432 if ((elm = strrchr(filename, '/')) != NULL) 433 ++elm; 434 else 435 elm = filename; 436 437 /* 438 * Where do we stuff our output? 439 */ 440 if (outFileName) { 441 if (flags & UNDO_FLAG_MULT) { 442 asprintf(&path, outFileName, elm); 443 fp = fopen(path, "w"); 444 if (fp == NULL) { 445 perror(path); 446 exit(1); 447 } 448 free(path); 449 } else { 450 fp = fopen(outFileName, "w"); 451 if (fp == NULL) { 452 perror(outFileName); 453 exit(1); 454 } 455 } 456 } else if (outFilePostfix) { 457 if (idx >= 0) { 458 asprintf(&path, "%s%s.%04d", filename, 459 outFilePostfix, idx); 460 } else { 461 asprintf(&path, "%s%s", filename, outFilePostfix); 462 } 463 fp = fopen(path, "w"); 464 if (fp == NULL) { 465 perror(path); 466 exit(1); 467 } 468 free(path); 469 } else { 470 if ((flags & UNDO_FLAG_MULT) && type == TYPE_FILE) { 471 if (idx >= 0) { 472 printf("\n>>> %s %04d 0x%016jx %s\n\n", 473 filename, idx, (uintmax_t)ts1.tid, 474 timestamp(&ts1)); 475 } else { 476 printf("\n>>> %s ---- 0x%016jx %s\n\n", 477 filename, (uintmax_t)ts1.tid, 478 timestamp(&ts1)); 479 } 480 } else if (idx >= 0 && type == TYPE_FILE) { 481 printf("\n>>> %s %04d 0x%016jx %s\n\n", 482 filename, idx, (uintmax_t)ts1.tid, 483 timestamp(&ts1)); 484 } 485 fp = stdout; 486 } 487 488 switch(type) { 489 case TYPE_FILE: 490 if ((fi = fopen(ipath1, "r")) != NULL) { 491 while ((n = fread(buf, 1, 8192, fi)) > 0) 492 fwrite(buf, 1, n, fp); 493 fclose(fi); 494 } 495 break; 496 case TYPE_DIFF: 497 printf("diff -N -r -u %s %s (to %s)\n", 498 ipath1, ipath2, timestamp(&ts2)); 499 fflush(stdout); 500 runcmd(fileno(fp), "/usr/bin/diff", "diff", "-N", "-r", "-u", ipath1, ipath2, NULL); 501 break; 502 case TYPE_RDIFF: 503 printf("diff -N -r -u %s %s\n", ipath2, ipath1); 504 fflush(stdout); 505 runcmd(fileno(fp), "/usr/bin/diff", "diff", "-N", "-r", "-u", ipath2, ipath1, NULL); 506 break; 507 case TYPE_HISTORY: 508 t = (time_t)ts1.time32; 509 tp = localtime(&t); 510 strftime(datestr, sizeof(datestr), "%d-%b-%Y %H:%M:%S", tp); 511 printf("\t0x%016jx %s", (uintmax_t)ts1.tid, datestr); 512 if (flags & UNDO_FLAG_INOCHG) 513 printf(" inode-change"); 514 if (lstat(ipath1, &st) < 0) 515 printf(" file-deleted"); 516 printf("\n"); 517 break; 518 } 519 520 if (fp != stdout) 521 fclose(fp); 522 done: 523 free(buf); 524 } 525 526 static 527 void 528 clean_tree(struct undo_hist_entry_rb_tree *tree) 529 { 530 struct undo_hist_entry *tse; 531 532 while ((tse = RB_ROOT(tree)) != NULL) { 533 RB_REMOVE(undo_hist_entry_rb_tree, tree, tse); 534 free(tse); 535 } 536 } 537 538 static 539 void 540 collect_history(int fd, int *errorp, struct undo_hist_entry_rb_tree *tse_tree) 541 { 542 struct hammer_ioc_history hist; 543 struct undo_hist_entry *tse; 544 struct stat st; 545 int istmp; 546 int i; 547 548 /* 549 * Setup 550 */ 551 bzero(&hist, sizeof(hist)); 552 hist.beg_tid = HAMMER_MIN_TID; 553 hist.end_tid = HAMMER_MAX_TID; 554 hist.head.flags |= HAMMER_IOC_HISTORY_ATKEY; 555 hist.key = 0; 556 hist.nxt_key = HAMMER_MAX_KEY; 557 558 *errorp = 0; 559 560 if (tse_tree == NULL) { 561 tse_tree = malloc(sizeof(*tse_tree)); 562 RB_INIT(tse_tree); 563 istmp = 1; 564 } else { 565 istmp = 0; 566 } 567 568 /* 569 * Save the inode so inode changes can be reported. 570 */ 571 st.st_ino = 0; 572 fstat(fd, &st); 573 574 /* 575 * Collect a unique set of transaction ids 576 */ 577 if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) { 578 *errorp = errno; 579 goto done; 580 } 581 for (;;) { 582 for (i = 0; i < hist.count; ++i) { 583 tse = malloc(sizeof(*tse)); 584 tse->tse = hist.hist_ary[i]; 585 tse->inum = st.st_ino; 586 if (RB_INSERT(undo_hist_entry_rb_tree, tse_tree, tse)) { 587 free(tse); 588 } 589 } 590 if (hist.head.flags & HAMMER_IOC_HISTORY_EOF) 591 break; 592 if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_KEY) { 593 hist.key = hist.nxt_key; 594 hist.nxt_key = HAMMER_MAX_KEY; 595 } 596 if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_TID) 597 hist.beg_tid = hist.nxt_tid; 598 if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) { 599 *errorp = errno; 600 break; 601 } 602 } 603 604 /* 605 * Cleanup 606 */ 607 done: 608 if (istmp) { 609 clean_tree(tse_tree); 610 free(tse_tree); 611 } 612 } 613 614 static 615 void 616 collect_dir_history(const char *filename, int *errorp, 617 struct undo_hist_entry_rb_tree *dir_tree) 618 { 619 char *dirname; 620 int fd; 621 int error; 622 623 *errorp = 0; 624 if (strrchr(filename, '/')) { 625 dirname = strdup(filename); 626 *strrchr(dirname, '/') = 0; 627 } else { 628 dirname = strdup("."); 629 } 630 if ((fd = open(dirname, O_RDONLY)) > 0) { 631 collect_history(fd, &error, dir_tree); 632 close(fd); 633 } 634 } 635 636 static 637 hammer_tid_t 638 parse_delta_time(const char *timeStr, int *flags, int ind_flag) 639 { 640 hammer_tid_t tid; 641 642 tid = strtoull(timeStr, NULL, 0); 643 if (timeStr[0] == '+') 644 ++timeStr; 645 if (timeStr[0] >= '0' && timeStr[0] <= '9' && timeStr[1] != 'x') 646 *flags |= ind_flag; 647 return(tid); 648 } 649 650 static void 651 runcmd(int fd, const char *cmd, ...) 652 { 653 va_list va; 654 pid_t pid; 655 char **av; 656 int ac; 657 int i; 658 659 va_start(va, cmd); 660 for (ac = 0; va_arg(va, void *) != NULL; ++ac) 661 ; 662 va_end(va); 663 664 av = malloc((ac + 1) * sizeof(char *)); 665 va_start(va, cmd); 666 for (i = 0; i < ac; ++i) 667 av[i] = va_arg(va, char *); 668 va_end(va); 669 av[i] = NULL; 670 671 if ((pid = fork()) < 0) { 672 perror("fork"); 673 exit(1); 674 } else if (pid == 0) { 675 if (fd != 1) { 676 dup2(fd, 1); 677 close(fd); 678 } 679 execv(cmd, av); 680 _exit(1); 681 } else { 682 while (waitpid(pid, NULL, 0) != pid) 683 ; 684 } 685 free(av); 686 } 687 688 /* 689 * Convert tid to timestamp. 690 */ 691 static char * 692 timestamp(hammer_ioc_hist_entry_t hen) 693 { 694 static char timebuf[64]; 695 time_t t = (time_t)hen->time32; 696 struct tm *tp; 697 698 tp = localtime(&t); 699 strftime(timebuf, sizeof(timebuf), "%d-%b-%Y %H:%M:%S", tp); 700 return(timebuf); 701 } 702 703 static 704 int 705 undo_hist_entry_compare(struct undo_hist_entry *he1, 706 struct undo_hist_entry *he2) 707 { 708 if (he1->tse.tid < he2->tse.tid) 709 return(-1); 710 if (he1->tse.tid > he2->tse.tid) 711 return(1); 712 return(0); 713 } 714 715 static void 716 usage(void) 717 { 718 fprintf(stderr, "undo [-adDiuv] [-o outfile] " 719 "[-t transaction-id] [-t transaction-id] path...\n" 720 " -a Iterate all historical segments\n" 721 " -d Forward diff\n" 722 " -D Reverse diff\n" 723 " -i Dump history transaction ids\n" 724 " -u Generate .undo files\n" 725 " -v Verbose\n" 726 " -o file Output to the specified file\n" 727 " -t TID Retrieve as of transaction-id, TID\n" 728 " (a second `-t TID' to diff two)\n" 729 " transaction ids must be prefixed with 0x, and\n" 730 " otherwise may specify an index starting at 0\n" 731 " and iterating backwards through the history.\n" 732 ); 733 exit(1); 734 } 735 736