undo - stat(2) may not populate struct stat upon failure.
[dragonfly.git] / 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                 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