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