[dragonfly.git] / usr.bin / undo / undo.c

/*
 * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
 * 
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * $DragonFly: src/usr.bin/undo/undo.c,v 1.6 2008/07/17 21:34:47 thomas Exp $
 */
/*
 * UNDO - retrieve an older version of a file.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/tree.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <vfs/hammer/hammer_disk.h>
#include <vfs/hammer/hammer_ioctl.h>

/*
 * Sorted list of transaction ids
 */
struct undo_hist_entry;
RB_HEAD(undo_hist_entry_rb_tree, undo_hist_entry);
RB_PROTOTYPE2(undo_hist_entry_rb_tree, undo_hist_entry, rbnode,
	undo_hist_entry_compare, hammer_tid_t);

struct undo_hist_entry {
	RB_ENTRY(undo_hist_entry) rbnode;
	struct hammer_ioc_hist_entry tse;
	ino_t inum;
};

enum undo_type { TYPE_FILE, TYPE_DIFF, TYPE_RDIFF, TYPE_HISTORY };
enum undo_cmd { CMD_DUMP, CMD_ITERATEALL };

#define UNDO_FLAG_MULT		0x0001
#define UNDO_FLAG_INOCHG	0x0002
#define UNDO_FLAG_SETTID1	0x0004
#define UNDO_FLAG_SETTID2	0x0008

static int undo_hist_entry_compare(struct undo_hist_entry *he1,
		    struct undo_hist_entry *he2);
static void doiterate(const char *filename, const char *outFileName,
		   const char *outFilePostfix, int flags,
		   struct hammer_ioc_hist_entry ts1,
		   struct hammer_ioc_hist_entry ts2,
		   enum undo_cmd cmd, enum undo_type type);
static void dogenerate(const char *filename, const char *outFileName,
		   const char *outFilePostfix,
		   int flags, int idx, enum undo_type type,
		   struct hammer_ioc_hist_entry ts1,
		   struct hammer_ioc_hist_entry ts2);
static void collect_history(int fd, int *error,
		   struct undo_hist_entry_rb_tree *tse_tree);
static void collect_dir_history(const char *filename, int *error,
		   struct undo_hist_entry_rb_tree *dir_tree);
static void clean_tree(struct undo_hist_entry_rb_tree *tree);
static hammer_tid_t parse_delta_time(const char *timeStr, int *flags,
		   int ind_flag);
static void runcmd(int fd, const char *cmd, ...);
static char *timestamp(hammer_ioc_hist_entry_t hen);
static void usage(void);

static int VerboseOpt;

RB_GENERATE2(undo_hist_entry_rb_tree, undo_hist_entry, rbnode,
	undo_hist_entry_compare, hammer_tid_t, tse.tid);


int
main(int ac, char **av)
{
	const char *outFileName = NULL;
	const char *outFilePostfix = NULL;
	enum undo_cmd cmd;
	enum undo_type type;
	struct hammer_ioc_hist_entry ts1;
	struct hammer_ioc_hist_entry ts2;
	int c;
	int count_t;
	int flags;

	bzero(&ts1, sizeof(ts1));
	bzero(&ts2, sizeof(ts2));

	cmd = CMD_DUMP;
	type = TYPE_FILE;
	count_t = 0;
	flags = 0;

	while ((c = getopt(ac, av, "adDiuvo:t:")) != -1) {
		switch(c) {
		case 'd':
			type = TYPE_DIFF;
			break;
		case 'D':
			type = TYPE_RDIFF;
			break;
		case 'i':
			if (type != TYPE_FILE)
				usage();
			type = TYPE_HISTORY;
			cmd = CMD_ITERATEALL;
			break;
		case 'a':
			cmd = CMD_ITERATEALL;
			break;
		case 'u':
			outFilePostfix = ".undo";
			break;
		case 'v':
			++VerboseOpt;
			break;
		case 'o':
			outFileName = optarg;
			break;
		case 't':
			/*
			 * Parse one or two -t options.  If two are specified
			 * -d is implied (but may be overridden)
			 */
			++count_t;
			if (count_t == 1) {
				ts1.tid = parse_delta_time(optarg, &flags,
				                           UNDO_FLAG_SETTID1);
			} else if (count_t == 2) {
				ts2.tid = parse_delta_time(optarg, &flags,
				                           UNDO_FLAG_SETTID2);
				if (type == TYPE_FILE)
					type = TYPE_DIFF;
			} else {
				usage();
			}
			break;
		default:
			usage();
			/* NOT REACHED */
			break;
		}
	}

	/*
	 * Option validation
	 */
	if (outFileName && outFilePostfix) {
		fprintf(stderr, "The -o option may not be combined with -u\n");
		usage();
	}

	ac -= optind;
	av += optind;
	if (ac > 1)
		flags |= UNDO_FLAG_MULT;

	if (ac == 0)
		usage();

	/*
	 * Validate the output template, if specified.
	 */
	if (outFileName && (flags & UNDO_FLAG_MULT)) {
		const char *ptr = outFileName;
		int didStr = 0;

		while ((ptr = strchr(ptr, '%')) != NULL) {
			if (ptr[1] == 's') {
				if (didStr) {
					fprintf(stderr, "Malformed output "
							"template\n");
					usage();
				}
				didStr = 1;
				++ptr;
			} else if (ptr[1] != '%') {
				fprintf(stderr, "Malformed output template\n");
				usage();
			} else {
				ptr += 2;
			}
		}
	}

	while (ac) {
		doiterate(*av, outFileName, outFilePostfix,
			  flags, ts1, ts2, cmd, type);
		++av;
		--ac;
	}
	return(0);
}

/*
 * Iterate through a file's history.  If cmd == CMD_DUMP we take the
 * next-to-last transaction id, unless another given.  Otherwise if
 * cmd == CMD_ITERATEALL we scan all transaction ids.
 *
 * Also iterate through the directory's history to locate other inodes that
 * used the particular file name.
 */
static
void
doiterate(const char *filename, const char *outFileName,
	  const char *outFilePostfix, int flags,
	  struct hammer_ioc_hist_entry ts1,
	  struct hammer_ioc_hist_entry ts2,
	  enum undo_cmd cmd, enum undo_type type)
{
	struct undo_hist_entry_rb_tree dir_tree;
	struct undo_hist_entry_rb_tree tse_tree;
	struct undo_hist_entry *tse1;
	struct undo_hist_entry *tse2;
	struct hammer_ioc_hist_entry tid_max;
	char *path = NULL;
	int i;
	int fd;
	int error;

	RB_INIT(&dir_tree);
	RB_INIT(&tse_tree);

	tid_max.tid = HAMMER_MAX_TID;
	tid_max.time32 = 0;

	/*
	 * Use the directory history to locate all possible versions of
	 * the file.
	 */
	collect_dir_history(filename, &error, &dir_tree);
	RB_FOREACH(tse1, undo_hist_entry_rb_tree, &dir_tree) {
		asprintf(&path, "%s@@0x%016llx", filename, tse1->tse.tid);
		if ((fd = open(path, O_RDONLY)) > 0) {
			collect_history(fd, &error, &tse_tree);
			close(fd);
		}
	}
	if (cmd == CMD_DUMP) {
		if ((ts1.tid == 0 ||
		     flags & (UNDO_FLAG_SETTID1|UNDO_FLAG_SETTID2)) &&
		    RB_EMPTY(&tse_tree)) {
			if ((fd = open(filename, O_RDONLY)) > 0) {
				collect_history(fd, &error, &tse_tree);
				close(fd);
			}
		}
		/*
		 * Find entry if tid set to placeholder index
		 */
		if (flags & UNDO_FLAG_SETTID1){
			tse1 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree);
			while (tse1 && ts1.tid--) {
				tse1 = RB_PREV(undo_hist_entry_rb_tree,
					       &tse_tree, tse1);
			}
			if (tse1)
				ts1 = tse1->tse;
			else
				ts1.tid = 0;
		}
		if (flags & UNDO_FLAG_SETTID2){
			tse2 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree);
			while (tse2 && ts2.tid--) {
				tse2 = RB_PREV(undo_hist_entry_rb_tree,
					       &tse_tree, tse2);
			}
			if (tse2)
				ts2 = tse2->tse;
			else
				ts2.tid = 0;
		}

		/*
		 * Single entry, most recent prior to current
		 */
		if (ts1.tid == 0) {
			tse2 = RB_MAX(undo_hist_entry_rb_tree, &tse_tree);
			if (tse2) {
				ts2 = tse2->tse;
				tse1 = RB_PREV(undo_hist_entry_rb_tree,
					       &tse_tree, tse2);
				if (tse1)
					ts1 = tse1->tse;
			}
		}
		if (ts1.tid == 0) {
			printf("%s: No UNDO history found\n", filename);
		} else {
			dogenerate(filename,
				   outFileName, outFilePostfix,
				   0, 0, type,
				   ts1, ts2);
		}
	} else if (RB_ROOT(&tse_tree)) {
		/*
		 * Iterate entire history
		 */
		printf("%s: ITERATE ENTIRE HISTORY\n", filename);

		tse1 = NULL;
		i = 0;
		RB_FOREACH(tse2, undo_hist_entry_rb_tree, &tse_tree) {
			if (tse1) {
				dogenerate(filename,
					   outFileName, outFilePostfix,
					   flags, i, type,
					   tse1->tse, tse2->tse);
			}
			if (tse1 && tse2->inum != tse1->inum)
				flags |= UNDO_FLAG_INOCHG;
			else
				flags &= ~UNDO_FLAG_INOCHG;
			tse1 = tse2;
			++i;
		}
		/*
		 * There is no delta to print for the last pair,
		 * because they are identical.
		 */
		if (type != TYPE_DIFF && type != TYPE_RDIFF) {
			dogenerate(filename,
				   outFileName, outFilePostfix,
				   flags, i, type,
				   tse1->tse, tid_max);
		}
	} else {
		printf("%s: ITERATE ENTIRE HISTORY: %s\n",
		       filename, strerror(error));
	}
	if (path)
		free(path);
	clean_tree(&dir_tree);
	clean_tree(&tse_tree);
}

/*
 * Generate output for a file as-of ts1 (ts1 may be 0!), if diffing then
 * through ts2.
 */
static
void
dogenerate(const char *filename, const char *outFileName,
	   const char *outFilePostfix,
	   int flags, int idx, enum undo_type type,
	   struct hammer_ioc_hist_entry ts1,
	   struct hammer_ioc_hist_entry ts2)
{
	struct stat st;
	const char *elm;
	char *ipath1 = NULL;
	char *ipath2 = NULL;
	FILE *fi;
	FILE *fp; 
	char *buf;
	char *path;
	time_t t;
	struct tm *tp;
	char datestr[64];
	int n;

	buf = malloc(8192);

	/*
	 * Open the input file.  If ts1 is 0 try to locate the most recent
	 * version of the file prior to the current version.
	 */
	if (ts1.tid == 0)
		asprintf(&ipath1, "%s", filename);
	else
		asprintf(&ipath1, "%s@@0x%016llx", filename, ts1.tid);

	if (ts2.tid == 0)
		asprintf(&ipath2, "%s", filename);
	else
		asprintf(&ipath2, "%s@@0x%016llx", filename, ts2.tid);

	if (lstat(ipath1, &st) < 0 && lstat(ipath2, &st) < 0) {
		if (idx == 0 || VerboseOpt) {
			fprintf(stderr, "Unable to access either %s or %s\n",
				ipath1, ipath2);
		}
		free(ipath1);
		free(ipath2);
		goto done;
	}

	/*
	 * elm is the last component of the input file name
	 */
	if ((elm = strrchr(filename, '/')) != NULL)
		++elm;
	else
		elm = filename;

	/*
	 * Where do we stuff our output?
	 */
	if (outFileName) {
		if (flags & UNDO_FLAG_MULT) {
			asprintf(&path, outFileName, elm);
			fp = fopen(path, "w");
			if (fp == NULL) {
				perror(path);
				exit(1);
			}
			free(path);
		} else {
			fp = fopen(outFileName, "w");
			if (fp == NULL) {
				perror(outFileName);
				exit(1);
			}
		}
	} else if (outFilePostfix) {
		if (idx >= 0) {
			asprintf(&path, "%s%s.%04d", filename,
				 outFilePostfix, idx);
		} else {
			asprintf(&path, "%s%s", filename, outFilePostfix);
		}
		fp = fopen(path, "w");
		if (fp == NULL) {
			perror(path);
			exit(1);
		}
		free(path);
	} else {
		if ((flags & UNDO_FLAG_MULT) && type == TYPE_FILE) {
			if (idx >= 0) {
				printf("\n>>> %s %04d 0x%016llx %s\n\n",
				       filename, idx, ts1.tid, timestamp(&ts1));
			} else {
				printf("\n>>> %s ---- 0x%016llx %s\n\n",
				       filename, ts1.tid, timestamp(&ts1));
			}
		} else if (idx >= 0 && type == TYPE_FILE) {
			printf("\n>>> %s %04d 0x%016llx %s\n\n", 
			       filename, idx, ts1.tid, timestamp(&ts1));
		}
		fp = stdout;
	}

	switch(type) {
	case TYPE_FILE:
		if ((fi = fopen(ipath1, "r")) != NULL) {
			while ((n = fread(buf, 1, 8192, fi)) > 0)
				fwrite(buf, 1, n, fp);
			fclose(fi);
		}
		break;
	case TYPE_DIFF:
		printf("diff -N -r -u %s %s (to %s)\n",
		       ipath1, ipath2, timestamp(&ts2));
		fflush(stdout);
		runcmd(fileno(fp), "/usr/bin/diff", "diff", "-N", "-r", "-u", ipath1, ipath2, NULL);
		break;
	case TYPE_RDIFF:
		printf("diff -N -r -u %s %s\n", ipath2, ipath1);
		fflush(stdout);
		runcmd(fileno(fp), "/usr/bin/diff", "diff", "-N", "-r", "-u", ipath2, ipath1, NULL);
		break;
	case TYPE_HISTORY:
		t = (time_t)ts1.time32;
		tp = localtime(&t);
		strftime(datestr, sizeof(datestr), "%d-%b-%Y %H:%M:%S", tp);
		printf("\t0x%016llx %s", ts1.tid, datestr);
		if (flags & UNDO_FLAG_INOCHG)
			printf(" inode-change");
		if (lstat(ipath1, &st) < 0)
			printf(" file-deleted");
		printf("\n");
		break;
	}

	if (fp != stdout)
		fclose(fp);
done:
	free(buf);
}

static
void
clean_tree(struct undo_hist_entry_rb_tree *tree)
{
	struct undo_hist_entry *tse;

	while ((tse = RB_ROOT(tree)) != NULL) {
		RB_REMOVE(undo_hist_entry_rb_tree, tree, tse);
		free(tse);
	}
}

static
void
collect_history(int fd, int *errorp, struct undo_hist_entry_rb_tree *tse_tree)
{
	struct hammer_ioc_history hist;
	struct undo_hist_entry *tse;
	struct stat st;
	int istmp;
	int i;

	/*
	 * Setup
	 */
	bzero(&hist, sizeof(hist));
	hist.beg_tid = HAMMER_MIN_TID;
	hist.end_tid = HAMMER_MAX_TID;
	hist.head.flags |= HAMMER_IOC_HISTORY_ATKEY;
	hist.key = 0;
	hist.nxt_key = HAMMER_MAX_KEY;

	*errorp = 0;

	if (tse_tree == NULL) {
		tse_tree = malloc(sizeof(*tse_tree));
		RB_INIT(tse_tree);
		istmp = 1;
	} else {
		istmp = 0;
	}

	/*
	 * Save the inode so inode changes can be reported.
	 */
	st.st_ino = 0;
	fstat(fd, &st);

	/*
	 * Collect a unique set of transaction ids
	 */
	if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
		*errorp = errno;
		goto done;
	}
	for (;;) {
		for (i = 0; i < hist.count; ++i) {
			tse = malloc(sizeof(*tse));
			tse->tse = hist.hist_ary[i];
			tse->inum = st.st_ino;
			if (RB_INSERT(undo_hist_entry_rb_tree, tse_tree, tse)) {
				free(tse);
			}
		}
		if (hist.head.flags & HAMMER_IOC_HISTORY_EOF)
			break;
		if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_KEY) {
			hist.key = hist.nxt_key;
			hist.nxt_key = HAMMER_MAX_KEY;
		}
		if (hist.head.flags & HAMMER_IOC_HISTORY_NEXT_TID) 
			hist.beg_tid = hist.nxt_tid;
		if (ioctl(fd, HAMMERIOC_GETHISTORY, &hist) < 0) {
			*errorp = errno;
			break;
		}
	}

	/*
	 * Cleanup
	 */
done:
	if (istmp) {
		clean_tree(tse_tree);
		free(tse_tree);
	}
}

static
void
collect_dir_history(const char *filename, int *errorp,
		    struct undo_hist_entry_rb_tree *dir_tree)
{
	char *dirname;
	int fd;
	int error;

	*errorp = 0;
	if (strrchr(filename, '/')) {
		dirname = strdup(filename);
		*strrchr(dirname, '/') = 0;
	} else {
		dirname = strdup(".");
	}
	if ((fd = open(dirname, O_RDONLY)) > 0) {
		collect_history(fd, &error, dir_tree);
		close(fd);
	}
}

static
hammer_tid_t
parse_delta_time(const char *timeStr, int *flags, int ind_flag)
{
	hammer_tid_t tid;

	tid = strtoull(timeStr, NULL, 0);
	if (timeStr[0] == '+')
		++timeStr;
	if (timeStr[0] >= '0' && timeStr[0] <= '9' && timeStr[1] != 'x')
		*flags |= ind_flag;
	return(tid);
}

static void
runcmd(int fd, const char *cmd, ...)
{
	va_list va;
	pid_t pid;
	char **av;
	int ac;
	int i;

	va_start(va, cmd);
	for (ac = 0; va_arg(va, void *) != NULL; ++ac)
		;
	va_end(va);

	av = malloc((ac + 1) * sizeof(char *));
	va_start(va, cmd);
	for (i = 0; i < ac; ++i)
		av[i] = va_arg(va, char *);
	va_end(va);
	av[i] = NULL;

	if ((pid = fork()) < 0) {
		perror("fork");
		exit(1);
	} else if (pid == 0) {
		if (fd != 1) {
			dup2(fd, 1);
			close(fd);
		}
		execv(cmd, av);
		_exit(1);
	} else {
		while (waitpid(pid, NULL, 0) != pid)
			;
	}
	free(av);
}

/*
 * Convert tid to timestamp.
 */
static char *
timestamp(hammer_ioc_hist_entry_t hen)
{
	static char timebuf[64];
	time_t t = (time_t)hen->time32;
	struct tm *tp;

	tp = localtime(&t);
	strftime(timebuf, sizeof(timebuf), "%d-%b-%Y %H:%M:%S", tp);
	return(timebuf);
}

static
int
undo_hist_entry_compare(struct undo_hist_entry *he1,
			struct undo_hist_entry *he2)
{
	if (he1->tse.tid < he2->tse.tid)
		return(-1);
	if (he1->tse.tid > he2->tse.tid)
		return(1);
	return(0);
}

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